Changes - j0ke.net Open Build Service

Changes of Revision 36

[-] [+]	Changed	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/Makefile
@@ -86,6 +86,7 @@ SRCDIRS += interface/pxe interface/efi interface/smbios SRCDIRS += interface/bofm SRCDIRS += interface/xen +SRCDIRS += interface/hyperv SRCDIRS += tests SRCDIRS += crypto crypto/axtls crypto/matrixssl SRCDIRS += hci hci/commands hci/tui
[-] [+]	Added	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/arch/i386/include/bits/hyperv.h ^
@@ -0,0 +1,72 @@ +#ifndef _BITS_HYPERV_H +#define _BITS_HYPERV_H + +/** @file + * + * Hyper-V interface + * + / + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stddef.h> +#include <stdint.h> +#include <ipxe/io.h> + +/* + * Issue hypercall + * + * @v hv Hyper-V hypervisor + * @v code Call code + * @v in Input parameters + * @v out Output parameters + * @ret status Status code + / +static inline __attribute__ (( always_inline )) int +hv_call ( struct hv_hypervisor hv, unsigned int code, const void in, + void out ) { + void hypercall = hv->hypercall; + uint32_t in_phys; + uint32_t out_phys; + uint32_t discard_ecx; + uint32_t discard_edx; + uint16_t result; + + in_phys = ( ( __builtin_constant_p ( in ) && ( in == NULL ) ) + ? 0 : virt_to_phys ( in ) ); + out_phys = ( ( __builtin_constant_p ( out ) && ( out == NULL ) ) + ? 0 : virt_to_phys ( out ) ); + __asm__ __volatile__ ( "call %9" + : "=a" ( result ), "=c" ( discard_ecx ), + "=d" ( discard_edx ) + : "d" ( 0 ), "a" ( code ), + "b" ( 0 ), "c" ( in_phys ), + "D" ( 0 ), "S" ( out_phys ), + "m" ( hypercall ) ); + return result; +} + +/** + * Set bit atomically + * + * @v bits Bit field + * @v bit Bit to set + / +static inline __attribute__ (( always_inline )) void +hv_set_bit ( void bits, unsigned int bit ) { + struct { + uint32_t dword[ ( bit / 32 ) + 1 ]; + } dwords = bits; + + / Set bit using "lock bts". Inform compiler that any memory + * from the start of the bit field up to and including the + * dword containing this bit may be modified. (This is + * overkill but shouldn't matter in practice since we're + * unlikely to subsequently read other bits from the same bit + * field.) + / + __asm__ __volatile__ ( "lock bts %1, %0" + : "+m" ( dwords ) : "Ir" ( bit ) ); +} + +#endif /* _BITS_HYPERV_H */
[-] [+]	Deleted	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/arch/i386/include/pic8259.h ^
@@ -1,73 +0,0 @@ -/* - * Basic support for controlling the 8259 Programmable Interrupt Controllers. - * - * Initially written by Michael Brown (mcb30). - / - -FILE_LICENCE ( GPL2_OR_LATER ); - -#ifndef PIC8259_H -#define PIC8259_H - -#include <ipxe/io.h> - -/ For segoff_t / -#include "realmode.h" - -#define IRQ_PIC_CUTOFF 8 - -/ 8259 register locations / -#define PIC1_ICW1 0x20 -#define PIC1_OCW2 0x20 -#define PIC1_OCW3 0x20 -#define PIC1_ICR 0x20 -#define PIC1_IRR 0x20 -#define PIC1_ISR 0x20 -#define PIC1_ICW2 0x21 -#define PIC1_ICW3 0x21 -#define PIC1_ICW4 0x21 -#define PIC1_IMR 0x21 -#define PIC2_ICW1 0xa0 -#define PIC2_OCW2 0xa0 -#define PIC2_OCW3 0xa0 -#define PIC2_ICR 0xa0 -#define PIC2_IRR 0xa0 -#define PIC2_ISR 0xa0 -#define PIC2_ICW2 0xa1 -#define PIC2_ICW3 0xa1 -#define PIC2_ICW4 0xa1 -#define PIC2_IMR 0xa1 - -/ Register command values / -#define OCW3_ID 0x08 -#define OCW3_READ_IRR 0x03 -#define OCW3_READ_ISR 0x02 -#define ICR_EOI_NON_SPECIFIC 0x20 -#define ICR_EOI_NOP 0x40 -#define ICR_EOI_SPECIFIC 0x60 -#define ICR_EOI_SET_PRIORITY 0xc0 - -/ Macros to enable/disable IRQs / -#define IMR_REG(x) ( (x) < IRQ_PIC_CUTOFF ? PIC1_IMR : PIC2_IMR ) -#define IMR_BIT(x) ( 1 << ( (x) % IRQ_PIC_CUTOFF ) ) -#define irq_enabled(x) ( ( inb ( IMR_REG(x) ) & IMR_BIT(x) ) == 0 ) -#define enable_irq(x) outb ( inb( IMR_REG(x) ) & ~IMR_BIT(x), IMR_REG(x) ) -#define disable_irq(x) outb ( inb( IMR_REG(x) ) \| IMR_BIT(x), IMR_REG(x) ) - -/ Macros for acknowledging IRQs / -#define ICR_REG( irq ) ( (irq) < IRQ_PIC_CUTOFF ? PIC1_ICR : PIC2_ICR ) -#define ICR_VALUE( irq ) ( (irq) % IRQ_PIC_CUTOFF ) -#define CHAINED_IRQ 2 - -/ Utility macros to convert IRQ numbers to INT numbers and INT vectors / -#define IRQ_INT( irq ) ( ( ( (irq) - IRQ_PIC_CUTOFF ) ^ 0x70 ) & 0x7f ) - -/ Other constants / -#define IRQ_MAX 15 -#define IRQ_NONE -1U - -/ Function prototypes - / -void send_eoi ( unsigned int irq ); - -#endif / PIC8259_H */
[-] [+]	Changed	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/arch/x86/Makefile ^
@@ -9,9 +9,14 @@ SRCDIRS += arch/x86/prefix SRCDIRS += arch/x86/hci/commands SRCDIRS += arch/x86/drivers/xen +SRCDIRS += arch/x86/drivers/hyperv # breaks building some of the linux-related objects CFLAGS += -Ulinux # disable valgrind CFLAGS += -DNVALGRIND + +# Include Hyper-V driver in the all-drivers build +# +DRIVERS += hyperv
[-] [+]	Changed	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/arch/x86/core/pic8259.c ^
(renamed from src/arch/i386/core/pic8259.c)
[-] [+]	Changed	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/arch/x86/core/pic8259.c ^
(renamed from src/arch/i386/core/pic8259.c)
[-] [+]	Added	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/arch/x86/drivers/hyperv ^
+(directory)
[-] [+]	Added	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/arch/x86/drivers/hyperv/hyperv.c ^
@@ -0,0 +1,564 @@ +/* + * Copyright (C) 2014 Michael Brown <mbrown@fensystems.co.uk>. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA. + / + +FILE_LICENCE ( GPL2_OR_LATER ); + +/* @file + * + * Hyper-V driver + * + / + +#include <stdlib.h> +#include <stdarg.h> +#include <string.h> +#include <unistd.h> +#include <assert.h> +#include <errno.h> +#include <byteswap.h> +#include <pic8259.h> +#include <ipxe/malloc.h> +#include <ipxe/device.h> +#include <ipxe/cpuid.h> +#include <ipxe/msr.h> +#include <ipxe/hyperv.h> +#include <ipxe/vmbus.h> +#include "hyperv.h" + +/* Maximum time to wait for a message response + * + * This is a policy decision. + / +#define HV_MESSAGE_MAX_WAIT_MS 1000 + +/* + * Convert a Hyper-V status code to an iPXE status code + * + * @v status Hyper-V status code + * @ret rc iPXE status code (before negation) + / +#define EHV( status ) EPLATFORM ( EINFO_EPLATFORM, (status) ) + +/* + * Allocate zeroed pages + * + * @v hv Hyper-V hypervisor + * @v ... Page addresses to fill in, terminated by NULL + * @ret rc Return status code + / +__attribute__ (( sentinel )) int +hv_alloc_pages ( struct hv_hypervisor hv, ... ) { + va_list args; + void *page; + int i; + + / Allocate and zero pages / + va_start ( args, hv ); + for ( i = 0 ; ( ( page = va_arg ( args, void * ) ) != NULL ); i++ ) { + page = malloc_dma ( PAGE_SIZE, PAGE_SIZE ); + if ( ! page ) + goto err_alloc; + memset ( page, 0, PAGE_SIZE ); + } + va_end ( args ); + + return 0; + + err_alloc: + va_end ( args ); + va_start ( args, hv ); + for ( ; i >= 0 ; i-- ) { + page = va_arg ( args, void * ); + free_dma ( page, PAGE_SIZE ); + } + va_end ( args ); + return -ENOMEM; +} + +/* + * Free pages + * + * @v hv Hyper-V hypervisor + * @v ... Page addresses, terminated by NULL + / +__attribute__ (( sentinel )) void +hv_free_pages ( struct hv_hypervisor hv, ... ) { + va_list args; + void page; + + va_start ( args, hv ); + while ( ( page = va_arg ( args, void ) ) != NULL ) + free_dma ( page, PAGE_SIZE ); + va_end ( args ); +} + +/** + * Allocate message buffer + * + * @v hv Hyper-V hypervisor + * @ret rc Return status code + / +static int hv_alloc_message ( struct hv_hypervisor hv ) { + + /* Allocate buffer. Must be aligned to at least 8 bytes and + * must not cross a page boundary, so align on its own size. + / + hv->message = malloc_dma ( sizeof ( hv->message ), + sizeof ( hv->message ) ); + if ( ! hv->message ) + return -ENOMEM; + + return 0; +} + +/* + * Free message buffer + * + * @v hv Hyper-V hypervisor + / +static void hv_free_message ( struct hv_hypervisor hv ) { + + /* Free buffer / + free_dma ( hv->message, sizeof ( hv->message ) ); +} + +/** + * Check whether or not we are running in Hyper-V + * + * @v hv Hyper-V hypervisor + * @ret rc Return status code + / +static int hv_check_hv ( struct hv_hypervisor hv ) { + struct x86_features features; + uint32_t interface_id; + uint32_t discard_ebx; + uint32_t discard_ecx; + uint32_t discard_edx; + + /* Check for presence of a hypervisor (not necessarily Hyper-V) / + x86_features ( &features ); + if ( ! ( features.intel.ecx & CPUID_FEATURES_INTEL_ECX_HYPERVISOR ) ) { + DBGC ( hv, "HV %p not running in a hypervisor\n", hv ); + return -ENODEV; + } + + / Check that hypervisor is Hyper-V / + cpuid ( HV_CPUID_INTERFACE_ID, &interface_id, &discard_ebx, + &discard_ecx, &discard_edx ); + if ( interface_id != HV_INTERFACE_ID ) { + DBGC ( hv, "HV %p not running in Hyper-V (interface ID " + "%#08x)\n", hv, interface_id ); + return -ENODEV; + } + + return 0; +} + +/* + * Map hypercall page + * + * @v hv Hyper-V hypervisor + * @ret rc Return status code + / +static int hv_map_hypercall ( struct hv_hypervisor hv ) { + union { + struct { + uint32_t ebx; + uint32_t ecx; + uint32_t edx; + } __attribute__ (( packed )); + char text[ 13 /* "bbbbccccdddd" + NUL / ]; + } vendor_id; + uint32_t build; + uint32_t version; + uint32_t discard_eax; + uint32_t discard_ecx; + uint32_t discard_edx; + uint64_t guest_os_id; + uint64_t hypercall; + + / Report guest OS identity / + guest_os_id = rdmsr ( HV_X64_MSR_GUEST_OS_ID ); + if ( guest_os_id != 0 ) { + DBGC ( hv, "HV %p guest OS ID MSR already set to %#08llx\n", + hv, guest_os_id ); + return -EBUSY; + } + guest_os_id = HV_GUEST_OS_ID_IPXE; + DBGC2 ( hv, "HV %p guest OS ID MSR is %#08llx\n", hv, guest_os_id ); + wrmsr ( HV_X64_MSR_GUEST_OS_ID, guest_os_id ); + + / Get hypervisor system identity (for debugging) / + cpuid ( HV_CPUID_VENDOR_ID, &discard_eax, &vendor_id.ebx, + &vendor_id.ecx, &vendor_id.edx ); + vendor_id.text[ sizeof ( vendor_id.text ) - 1 ] = '\0'; + cpuid ( HV_CPUID_HYPERVISOR_ID, &build, &version, &discard_ecx, + &discard_edx ); + DBGC ( hv, "HV %p detected \"%s\" version %d.%d build %d\n", hv, + vendor_id.text, ( version >> 16 ), ( version & 0xffff ), build ); + + / Map hypercall page / + hypercall = rdmsr ( HV_X64_MSR_HYPERCALL ); + hypercall &= ( PAGE_SIZE - 1 ); + hypercall \|= ( virt_to_phys ( hv->hypercall ) \| HV_HYPERCALL_ENABLE ); + DBGC2 ( hv, "HV %p hypercall MSR is %#08llx\n", hv, hypercall ); + wrmsr ( HV_X64_MSR_HYPERCALL, hypercall ); + + return 0; +} + +/* + * Unmap hypercall page + * + * @v hv Hyper-V hypervisor + / +static void hv_unmap_hypercall ( struct hv_hypervisor hv ) { + uint64_t hypercall; + uint64_t guest_os_id; + + /* Unmap the hypercall page / + hypercall = rdmsr ( HV_X64_MSR_HYPERCALL ); + hypercall &= ( ( PAGE_SIZE - 1 ) & ~HV_HYPERCALL_ENABLE ); + DBGC2 ( hv, "HV %p hypercall MSR is %#08llx\n", hv, hypercall ); + wrmsr ( HV_X64_MSR_HYPERCALL, hypercall ); + + / Reset the guest OS identity / + guest_os_id = 0; + DBGC2 ( hv, "HV %p guest OS ID MSR is %#08llx\n", hv, guest_os_id ); + wrmsr ( HV_X64_MSR_GUEST_OS_ID, guest_os_id ); +} + +/* + * Map synthetic interrupt controller + * + * @v hv Hyper-V hypervisor + * @ret rc Return status code + / +static int hv_map_synic ( struct hv_hypervisor hv ) { + uint64_t simp; + uint64_t siefp; + uint64_t scontrol; + + /* Map SynIC message page / + simp = rdmsr ( HV_X64_MSR_SIMP ); + simp &= ( PAGE_SIZE - 1 ); + simp \|= ( virt_to_phys ( hv->synic.message ) \| HV_SIMP_ENABLE ); + DBGC2 ( hv, "HV %p SIMP MSR is %#08llx\n", hv, simp ); + wrmsr ( HV_X64_MSR_SIMP, simp ); + + / Map SynIC event page / + siefp = rdmsr ( HV_X64_MSR_SIEFP ); + siefp &= ( PAGE_SIZE - 1 ); + siefp \|= ( virt_to_phys ( hv->synic.event ) \| HV_SIEFP_ENABLE ); + DBGC2 ( hv, "HV %p SIEFP MSR is %#08llx\n", hv, siefp ); + wrmsr ( HV_X64_MSR_SIEFP, siefp ); + + / Enable SynIC / + scontrol = rdmsr ( HV_X64_MSR_SCONTROL ); + scontrol \|= HV_SCONTROL_ENABLE; + DBGC2 ( hv, "HV %p SCONTROL MSR is %#08llx\n", hv, scontrol ); + wrmsr ( HV_X64_MSR_SCONTROL, scontrol ); + + return 0; +} + +/* + * Unmap synthetic interrupt controller + * + * @v hv Hyper-V hypervisor + / +static void hv_unmap_synic ( struct hv_hypervisor hv ) { + uint64_t scontrol; + uint64_t siefp; + uint64_t simp; + + /* Disable SynIC / + scontrol = rdmsr ( HV_X64_MSR_SCONTROL ); + scontrol &= ~HV_SCONTROL_ENABLE; + DBGC2 ( hv, "HV %p SCONTROL MSR is %#08llx\n", hv, scontrol ); + wrmsr ( HV_X64_MSR_SCONTROL, scontrol ); + + / Unmap SynIC event page / + siefp = rdmsr ( HV_X64_MSR_SIEFP ); + siefp &= ( ( PAGE_SIZE - 1 ) & ~HV_SIEFP_ENABLE ); + DBGC2 ( hv, "HV %p SIEFP MSR is %#08llx\n", hv, siefp ); + wrmsr ( HV_X64_MSR_SIEFP, siefp ); + + / Unmap SynIC message page / + simp = rdmsr ( HV_X64_MSR_SIMP ); + simp &= ( ( PAGE_SIZE - 1 ) & ~HV_SIMP_ENABLE ); + DBGC2 ( hv, "HV %p SIMP MSR is %#08llx\n", hv, simp ); + wrmsr ( HV_X64_MSR_SIMP, simp ); +} + +/* + * Enable synthetic interrupt + * + * @v hv Hyper-V hypervisor + * @v sintx Synthetic interrupt number + / +void hv_enable_sint ( struct hv_hypervisor hv, unsigned int sintx ) { + unsigned long msr = HV_X64_MSR_SINT ( sintx ); + uint64_t sint; + + /* Enable synthetic interrupt + * + * We have to enable the interrupt, otherwise messages will + * not be delivered (even though the documentation implies + * that polling for messages is possible). We enable AutoEOI + * and hook the interrupt to the obsolete IRQ13 (FPU + * exception) vector, which will be implemented as a no-op. + / + sint = rdmsr ( msr ); + sint &= ~( HV_SINT_MASKED \| HV_SINT_VECTOR_MASK ); + sint \|= ( HV_SINT_AUTO_EOI \| + HV_SINT_VECTOR ( IRQ_INT ( 13 / See comment above / ) ) ); + DBGC2 ( hv, "HV %p SINT%d MSR is %#08llx\n", hv, sintx, sint ); + wrmsr ( msr, sint ); +} + +/* + * Disable synthetic interrupt + * + * @v hv Hyper-V hypervisor + * @v sintx Synthetic interrupt number + / +void hv_disable_sint ( struct hv_hypervisor hv, unsigned int sintx ) { + unsigned long msr = HV_X64_MSR_SINT ( sintx ); + uint64_t sint; + + /* Disable synthetic interrupt / + sint = rdmsr ( msr ); + sint &= ~HV_SINT_AUTO_EOI; + sint \|= HV_SINT_MASKED; + DBGC2 ( hv, "HV %p SINT%d MSR is %#08llx\n", hv, sintx, sint ); + wrmsr ( msr, sint ); +} + +/* + * Post message + * + * @v hv Hyper-V hypervisor + * @v id Connection ID + * @v type Message type + * @v data Message + * @v len Length of message + * @ret rc Return status code + / +int hv_post_message ( struct hv_hypervisor hv, unsigned int id, + unsigned int type, const void data, size_t len ) { + struct hv_post_message msg = &hv->message->posted; + int status; + int rc; + + /* Sanity check / + assert ( len <= sizeof ( msg->data ) ); + + / Construct message / + memset ( msg, 0, sizeof ( msg ) ); + msg->id = cpu_to_le32 ( id ); + msg->type = cpu_to_le32 ( type ); + msg->len = cpu_to_le32 ( len ); + memcpy ( msg->data, data, len ); + DBGC2 ( hv, "HV %p connection %d posting message type %#08x:\n", + hv, id, type ); + DBGC2_HDA ( hv, 0, msg->data, len ); + + /* Post message / + if ( ( status = hv_call ( hv, HV_POST_MESSAGE, msg, NULL ) ) != 0 ) { + rc = -EHV ( status ); + DBGC ( hv, "HV %p could not post message to %#08x: %s\n", + hv, id, strerror ( rc ) ); + return rc; + } + + return 0; +} + +/* + * Wait for received message + * + * @v hv Hyper-V hypervisor + * @v sintx Synthetic interrupt number + * @ret rc Return status code + / +int hv_wait_for_message ( struct hv_hypervisor hv, unsigned int sintx ) { + struct hv_message msg = &hv->message->received; + struct hv_message src = &hv->synic.message[sintx]; + unsigned int retries; + size_t len; + + /* Wait for message to arrive / + for ( retries = 0 ; retries < HV_MESSAGE_MAX_WAIT_MS ; retries++ ) { + + / Check for message / + if ( src->type ) { + + / Copy message / + memset ( msg, 0, sizeof ( msg ) ); + len = src->len; + assert ( len <= sizeof ( msg ) ); + memcpy ( msg, src, + ( offsetof ( typeof ( msg ), data ) + len ) ); + DBGC2 ( hv, "HV %p SINT%d received message type " + "%#08x:\n", hv, sintx, + le32_to_cpu ( msg->type ) ); + DBGC2_HDA ( hv, 0, msg->data, len ); + + /* Consume message / + src->type = 0; + + return 0; + } + + / Trigger message delivery / + wrmsr ( HV_X64_MSR_EOM, 0 ); + + / Delay / + mdelay ( 1 ); + } + + DBGC ( hv, "HV %p SINT%d timed out waiting for message\n", + hv, sintx ); + return -ETIMEDOUT; +} + +/* + * Signal event + * + * @v hv Hyper-V hypervisor + * @v id Connection ID + * @v flag Flag number + * @ret rc Return status code + / +int hv_signal_event ( struct hv_hypervisor hv, unsigned int id, + unsigned int flag ) { + struct hv_signal_event event = &hv->message->signalled; + int status; + int rc; + + / Construct event / + memset ( event, 0, sizeof ( event ) ); + event->id = cpu_to_le32 ( id ); + event->flag = cpu_to_le16 ( flag ); + + /* Signal event / + if ( ( status = hv_call ( hv, HV_SIGNAL_EVENT, event, NULL ) ) != 0 ) { + rc = -EHV ( status ); + DBGC ( hv, "HV %p could not signal event to %#08x: %s\n", + hv, id, strerror ( rc ) ); + return rc; + } + + return 0; +} + +/* + * Probe root device + * + * @v rootdev Root device + * @ret rc Return status code + / +static int hv_probe ( struct root_device rootdev ) { + struct hv_hypervisor hv; + int rc; + + / Allocate and initialise structure / + hv = zalloc ( sizeof ( hv ) ); + if ( ! hv ) { + rc = -ENOMEM; + goto err_alloc; + } + + /* Check we are running in Hyper-V / + if ( ( rc = hv_check_hv ( hv ) ) != 0 ) + goto err_check_hv; + + / Allocate pages / + if ( ( rc = hv_alloc_pages ( hv, &hv->hypercall, &hv->synic.message, + &hv->synic.event, NULL ) ) != 0 ) + goto err_alloc_pages; + + / Allocate message buffer / + if ( ( rc = hv_alloc_message ( hv ) ) != 0 ) + goto err_alloc_message; + + / Map hypercall page / + if ( ( rc = hv_map_hypercall ( hv ) ) != 0 ) + goto err_map_hypercall; + + / Map synthetic interrupt controller / + if ( ( rc = hv_map_synic ( hv ) ) != 0 ) + goto err_map_synic; + + / Probe Hyper-V devices / + if ( ( rc = vmbus_probe ( hv, &rootdev->dev ) ) != 0 ) + goto err_vmbus_probe; + + rootdev_set_drvdata ( rootdev, hv ); + return 0; + + vmbus_remove ( hv, &rootdev->dev ); + err_vmbus_probe: + hv_unmap_synic ( hv ); + err_map_synic: + hv_unmap_hypercall ( hv ); + err_map_hypercall: + hv_free_message ( hv ); + err_alloc_message: + hv_free_pages ( hv, hv->hypercall, hv->synic.message, hv->synic.event, + NULL ); + err_alloc_pages: + err_check_hv: + free ( hv ); + err_alloc: + return rc; +} + +/* + * Remove root device + * + * @v rootdev Root device + / +static void hv_remove ( struct root_device rootdev ) { + struct hv_hypervisor hv = rootdev_get_drvdata ( rootdev ); + + vmbus_remove ( hv, &rootdev->dev ); + hv_unmap_synic ( hv ); + hv_unmap_hypercall ( hv ); + hv_free_message ( hv ); + hv_free_pages ( hv, hv->hypercall, hv->synic.message, hv->synic.event, + NULL ); + free ( hv ); +} + +/* Hyper-V root device driver / +static struct root_driver hv_root_driver = { + .probe = hv_probe, + .remove = hv_remove, +}; + +/* Hyper-V root device / +struct root_device hv_root_device __root_device = { + .dev = { .name = "Hyper-V" }, + .driver = &hv_root_driver, +}; + +/ Drag in netvsc driver */ +REQUIRE_OBJECT ( netvsc );
[-] [+]	Added	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/arch/x86/drivers/hyperv/hyperv.h ^
@@ -0,0 +1,42 @@ +#ifndef _HYPERV_H +#define _HYPERV_H + +/** @file + * + * Hyper-V driver + * + / + +FILE_LICENCE ( GPL2_OR_LATER ); + +/* Get vendor identification / +#define HV_CPUID_VENDOR_ID 0x40000000UL + +/* Get interface identification / +#define HV_CPUID_INTERFACE_ID 0x40000001UL + +/* Get hypervisor identification / +#define HV_CPUID_HYPERVISOR_ID 0x40000002UL + +/* Guest OS identity MSR / +#define HV_X64_MSR_GUEST_OS_ID 0x40000000UL + +/* Hypercall page MSR / +#define HV_X64_MSR_HYPERCALL 0x40000001UL + +/* SynIC control MSR / +#define HV_X64_MSR_SCONTROL 0x40000080UL + +/* SynIC event flags page MSR / +#define HV_X64_MSR_SIEFP 0x40000082UL + +/* SynIC message page MSR / +#define HV_X64_MSR_SIMP 0x40000083UL + +/* SynIC end of message MSR / +#define HV_X64_MSR_EOM 0x40000084UL + +/* SynIC interrupt source MSRs / +#define HV_X64_MSR_SINT(x) ( 0x40000090UL + (x) ) + +#endif / _HYPERV_H */
[-] [+]	Changed	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/arch/x86/include/bits/errfile.h ^
@@ -46,6 +46,7 @@ #define ERRFILE_timer_rdtsc ( ERRFILE_ARCH \| ERRFILE_DRIVER \| 0x00000000 ) #define ERRFILE_timer_bios ( ERRFILE_ARCH \| ERRFILE_DRIVER \| 0x00010000 ) #define ERRFILE_hvm ( ERRFILE_ARCH \| ERRFILE_DRIVER \| 0x00020000 ) +#define ERRFILE_hyperv ( ERRFILE_ARCH \| ERRFILE_DRIVER \| 0x00030000 ) #define ERRFILE_cpuid_cmd ( ERRFILE_ARCH \| ERRFILE_OTHER \| 0x00000000 ) #define ERRFILE_cpuid_settings ( ERRFILE_ARCH \| ERRFILE_OTHER \| 0x00010000 )
[-] [+]	Changed	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/arch/x86/include/ipxe/cpuid.h ^
@@ -39,6 +39,9 @@ /** Get standard features / #define CPUID_FEATURES 0x00000001UL +/* Hypervisor is present / +#define CPUID_FEATURES_INTEL_ECX_HYPERVISOR 0x80000000UL + /* Get largest extended function */ #define CPUID_AMD_MAX_FN 0x80000000UL
[-] [+]	Added	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/arch/x86/include/pic8259.h ^
@@ -0,0 +1,70 @@ +/* + * Basic support for controlling the 8259 Programmable Interrupt Controllers. + * + * Initially written by Michael Brown (mcb30). + / + +FILE_LICENCE ( GPL2_OR_LATER ); + +#ifndef PIC8259_H +#define PIC8259_H + +#include <ipxe/io.h> + +#define IRQ_PIC_CUTOFF 8 + +/ 8259 register locations / +#define PIC1_ICW1 0x20 +#define PIC1_OCW2 0x20 +#define PIC1_OCW3 0x20 +#define PIC1_ICR 0x20 +#define PIC1_IRR 0x20 +#define PIC1_ISR 0x20 +#define PIC1_ICW2 0x21 +#define PIC1_ICW3 0x21 +#define PIC1_ICW4 0x21 +#define PIC1_IMR 0x21 +#define PIC2_ICW1 0xa0 +#define PIC2_OCW2 0xa0 +#define PIC2_OCW3 0xa0 +#define PIC2_ICR 0xa0 +#define PIC2_IRR 0xa0 +#define PIC2_ISR 0xa0 +#define PIC2_ICW2 0xa1 +#define PIC2_ICW3 0xa1 +#define PIC2_ICW4 0xa1 +#define PIC2_IMR 0xa1 + +/ Register command values / +#define OCW3_ID 0x08 +#define OCW3_READ_IRR 0x03 +#define OCW3_READ_ISR 0x02 +#define ICR_EOI_NON_SPECIFIC 0x20 +#define ICR_EOI_NOP 0x40 +#define ICR_EOI_SPECIFIC 0x60 +#define ICR_EOI_SET_PRIORITY 0xc0 + +/ Macros to enable/disable IRQs / +#define IMR_REG(x) ( (x) < IRQ_PIC_CUTOFF ? PIC1_IMR : PIC2_IMR ) +#define IMR_BIT(x) ( 1 << ( (x) % IRQ_PIC_CUTOFF ) ) +#define irq_enabled(x) ( ( inb ( IMR_REG(x) ) & IMR_BIT(x) ) == 0 ) +#define enable_irq(x) outb ( inb( IMR_REG(x) ) & ~IMR_BIT(x), IMR_REG(x) ) +#define disable_irq(x) outb ( inb( IMR_REG(x) ) \| IMR_BIT(x), IMR_REG(x) ) + +/ Macros for acknowledging IRQs / +#define ICR_REG( irq ) ( (irq) < IRQ_PIC_CUTOFF ? PIC1_ICR : PIC2_ICR ) +#define ICR_VALUE( irq ) ( (irq) % IRQ_PIC_CUTOFF ) +#define CHAINED_IRQ 2 + +/ Utility macros to convert IRQ numbers to INT numbers and INT vectors / +#define IRQ_INT( irq ) ( ( ( (irq) - IRQ_PIC_CUTOFF ) ^ 0x70 ) & 0x7f ) + +/ Other constants / +#define IRQ_MAX 15 +#define IRQ_NONE -1U + +/ Function prototypes + / +void send_eoi ( unsigned int irq ); + +#endif / PIC8259_H */
[-] [+]	Added	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/arch/x86_64/include/bits/hyperv.h ^
@@ -0,0 +1,75 @@ +#ifndef _BITS_HYPERV_H +#define _BITS_HYPERV_H + +/** @file + * + * Hyper-V interface + * + / + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stddef.h> +#include <stdint.h> +#include <ipxe/io.h> + +/* + * Issue hypercall + * + * @v hv Hyper-V hypervisor + * @v code Call code + * @v in Input parameters + * @v out Output parameters + * @ret status Status code + / +static inline __attribute__ (( always_inline )) int +hv_call ( struct hv_hypervisor hv, unsigned int code, const void in, + void out ) { + void hypercall = hv->hypercall; + register uint64_t rcx asm ( "rcx" ); + register uint64_t rdx asm ( "rdx" ); + register uint64_t r8 asm ( "r8" ); + uint64_t in_phys; + uint64_t out_phys; + uint16_t result; + + in_phys = ( ( __builtin_constant_p ( in ) && ( in == NULL ) ) + ? 0 : virt_to_phys ( in ) ); + out_phys = ( ( __builtin_constant_p ( out ) && ( out == NULL ) ) + ? 0 : virt_to_phys ( out ) ); + rcx = code; + rdx = in_phys; + r8 = out_phys; + __asm__ __volatile__ ( "call %4" + : "=a" ( result ), "+r" ( rcx ), "+r" ( rdx ), + "+r" ( r8 ) + : "m" ( hypercall ) + : "r9", "r10", "r11", "xmm0", "xmm1", "xmm2", + "xmm3", "xmm4", "xmm5" ); + return result; +} + +/** + * Set bit atomically + * + * @v bits Bit field + * @v bit Bit to set + / +static inline __attribute__ (( always_inline )) void +hv_set_bit ( void bits, unsigned int bit ) { + struct { + uint64_t qword[ ( bit / 64 ) + 1 ]; + } qwords = bits; + + / Set bit using "lock bts". Inform compiler that any memory + * from the start of the bit field up to and including the + * qword containing this bit may be modified. (This is + * overkill but shouldn't matter in practice since we're + * unlikely to subsequently read other bits from the same bit + * field.) + / + __asm__ __volatile__ ( "lock bts %1, %0" + : "+m" ( qwords ) : "Ir" ( bit ) ); +} + +#endif /* _BITS_HYPERV_H */
[-] [+]	Changed	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/core/iobuf.c ^
@@ -200,3 +200,33 @@ return concatenated; } + +/** + * Split I/O buffer + * + * @v iobuf I/O buffer + * @v len Length to split into a new I/O buffer + * @ret split New I/O buffer, or NULL on allocation failure + * + * Split the first @c len bytes of the existing I/O buffer into a + * separate I/O buffer. The resulting buffers are likely to have no + * headroom or tailroom. + * + * If this call fails, then the original buffer will be unmodified. + / +struct io_buffer iob_split ( struct io_buffer iobuf, size_t len ) { + struct io_buffer split; + + /* Sanity checks / + assert ( len <= iob_len ( iobuf ) ); + + / Allocate new I/O buffer / + split = alloc_iob ( len ); + if ( ! split ) + return NULL; + + / Copy in data */ + memcpy ( iob_put ( split, len ), iobuf->data, len ); + iob_pull ( iobuf, len ); + return split; +}
[-] [+]	Changed	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/core/malloc.c ^
@@ -187,6 +187,42 @@ } /** + * Check integrity of the blocks in the free list + * + / +static inline void check_blocks ( void ) { + struct memory_block block; + struct memory_block prev = NULL; + + if ( ! ASSERTING ) + return; + + list_for_each_entry ( block, &free_blocks, list ) { + + / Check that list structure is intact / + list_check ( &block->list ); + + / Check that block size is not too small / + assert ( block->size >= sizeof ( block ) ); + assert ( block->size >= MIN_MEMBLOCK_SIZE ); + + /* Check that block does not wrap beyond end of address space / + assert ( ( ( void ) block + block->size ) > + ( ( void * ) block ) ); + + /* Check that blocks remain in ascending order, and + * that adjacent blocks have been merged. + / + if ( prev ) { + assert ( ( ( void ) block ) > ( ( void * ) prev ) ); + assert ( ( ( void * ) block ) > + ( ( ( void * ) prev ) + prev->size ) ); + } + prev = block; + } +} + +/** * Discard some cached data * * @ret discarded Number of cached items discarded @@ -237,7 +273,12 @@ struct memory_block post; struct memory_block ptr; + /* Sanity checks / + assert ( size != 0 ); + assert ( ( align == 0 ) \|\| ( ( align & ( align - 1 ) ) == 0 ) ); + valgrind_make_blocks_defined(); + check_blocks(); / Round up size to multiple of MIN_MEMBLOCK_SIZE and * calculate alignment mask. @@ -245,7 +286,8 @@ size = ( size + MIN_MEMBLOCK_SIZE - 1 ) & ~( MIN_MEMBLOCK_SIZE - 1 ); align_mask = ( align - 1 ) \| ( MIN_MEMBLOCK_SIZE - 1 ); - DBG ( "Allocating %#zx (aligned %#zx+%zx)\n", size, align, offset ); + DBGC2 ( &heap, "Allocating %#zx (aligned %#zx+%zx)\n", + size, align, offset ); while ( 1 ) { /* Search through blocks for the first one with enough space / list_for_each_entry ( block, &free_blocks, list ) { @@ -261,10 +303,10 @@ pre = block; block = ( ( ( void ) pre ) + pre_size ); post = ( ( ( void * ) block ) + size ); - DBG ( "[%p,%p) -> [%p,%p) + [%p,%p)\n", pre, - ( ( ( void * ) pre ) + pre->size ), - pre, block, post, - ( ( ( void * ) pre ) + pre->size ) ); + DBGC2 ( &heap, "[%p,%p) -> [%p,%p) + [%p,%p)\n", + pre, ( ( ( void * ) pre ) + pre->size ), + pre, block, post, + ( ( ( void * ) pre ) + pre->size ) ); /* If there is a "post" block, add it in to * the free list. Leak it if it is too small * (which can happen only at the very end of @@ -291,8 +333,8 @@ /* Update total free memory / freemem -= size; / Return allocated block / - DBG ( "Allocated [%p,%p)\n", block, - ( ( ( void ) block ) + size ) ); + DBGC2 ( &heap, "Allocated [%p,%p)\n", block, + ( ( ( void * ) block ) + size ) ); ptr = block; goto done; } @@ -301,14 +343,15 @@ /* Try discarding some cached data to free up memory / if ( ! discard_cache() ) { / Nothing available to discard / - DBG ( "Failed to allocate %#zx (aligned %#zx)\n", - size, align ); + DBGC ( &heap, "Failed to allocate %#zx (aligned " + "%#zx)\n", size, align ); ptr = NULL; goto done; } } done: + check_blocks(); valgrind_make_blocks_noaccess(); return ptr; } @@ -333,17 +376,38 @@ return; valgrind_make_blocks_defined(); + check_blocks(); / Round up size to match actual size that alloc_memblock() * would have used. / + assert ( size != 0 ); size = ( size + MIN_MEMBLOCK_SIZE - 1 ) & ~( MIN_MEMBLOCK_SIZE - 1 ); freeing = ptr; VALGRIND_MAKE_MEM_DEFINED ( freeing, sizeof ( freeing ) ); - freeing->size = size; - DBG ( "Freeing [%p,%p)\n", freeing, ( ( ( void * ) freeing ) + size )); + DBGC2 ( &heap, "Freeing [%p,%p)\n", + freeing, ( ( ( void * ) freeing ) + size ) ); + + /* Check that this block does not overlap the free list / + if ( ASSERTING ) { + list_for_each_entry ( block, &free_blocks, list ) { + if ( ( ( ( void ) block ) < + ( ( void * ) freeing + size ) ) && + ( ( void * ) freeing < + ( ( void * ) block + block->size ) ) ) { + assert ( 0 ); + DBGC ( &heap, "Double free of [%p,%p) " + "overlapping [%p,%p) detected from %p\n", + freeing, + ( ( ( void * ) freeing ) + size ), block, + ( ( void * ) block + block->size ), + __builtin_return_address ( 0 ) ); + } + } + } /* Insert/merge into free list / + freeing->size = size; list_for_each_entry_safe ( block, tmp, &free_blocks, list ) { / Calculate gaps before and after the "freeing" block / gap_before = ( ( ( void ) freeing ) - @@ -352,10 +416,11 @@ ( ( ( void * ) freeing ) + freeing->size ) ); /* Merge with immediately preceding block, if possible / if ( gap_before == 0 ) { - DBG ( "[%p,%p) + [%p,%p) -> [%p,%p)\n", block, - ( ( ( void ) block ) + block->size ), freeing, - ( ( ( void * ) freeing ) + freeing->size ),block, - ( ( ( void * ) freeing ) + freeing->size ) ); + DBGC2 ( &heap, "[%p,%p) + [%p,%p) -> [%p,%p)\n", block, + ( ( ( void * ) block ) + block->size ), freeing, + ( ( ( void * ) freeing ) + freeing->size ), + block, + ( ( ( void * ) freeing ) + freeing->size ) ); block->size += size; list_del ( &block->list ); freeing = block; @@ -369,13 +434,14 @@ * possible, merge the following block into the "freeing" * block. / - DBG ( "[%p,%p)\n", freeing, ( ( ( void ) freeing ) + freeing->size)); + DBGC2 ( &heap, "[%p,%p)\n", + freeing, ( ( ( void * ) freeing ) + freeing->size ) ); list_add_tail ( &freeing->list, &block->list ); if ( gap_after == 0 ) { - DBG ( "[%p,%p) + [%p,%p) -> [%p,%p)\n", freeing, - ( ( ( void * ) freeing ) + freeing->size ), block, - ( ( ( void * ) block ) + block->size ), freeing, - ( ( ( void * ) block ) + block->size ) ); + DBGC2 ( &heap, "[%p,%p) + [%p,%p) -> [%p,%p)\n", freeing, + ( ( ( void * ) freeing ) + freeing->size ), block, + ( ( ( void * ) block ) + block->size ), freeing, + ( ( ( void * ) block ) + block->size ) ); freeing->size += block->size; list_del ( &block->list ); } @@ -383,6 +449,7 @@ /* Update free memory counter / freemem += size; + check_blocks(); valgrind_make_blocks_noaccess(); } @@ -440,6 +507,7 @@ data ); VALGRIND_MAKE_MEM_DEFINED ( old_block, offsetof ( struct autosized_block, data ) ); old_total_size = old_block->size; + assert ( old_total_size != 0 ); old_size = ( old_total_size - offsetof ( struct autosized_block, data ) ); memcpy ( new_ptr, old_ptr, @@ -449,6 +517,10 @@ VALGRIND_FREELIKE_BLOCK ( old_ptr, 0 ); } + if ( ASSERTED ) { + DBGC ( &heap, "Possible memory corruption detected from %p\n", + __builtin_return_address ( 0 ) ); + } return new_ptr; } @@ -462,7 +534,14 @@ will be aligned to at least a multiple of sizeof(void). / void * malloc ( size_t size ) { - return realloc ( NULL, size ); + void ptr; + + ptr = realloc ( NULL, size ); + if ( ASSERTED ) { + DBGC ( &heap, "Possible memory corruption detected from %p\n", + __builtin_return_address ( 0 ) ); + } + return ptr; } /* @@ -476,7 +555,12 @@ * If @c ptr is NULL, no action is taken. / void free ( void ptr ) { + realloc ( ptr, 0 ); + if ( ASSERTED ) { + DBGC ( &heap, "Possible memory corruption detected from %p\n", + __builtin_return_address ( 0 ) ); + } } /** @@ -496,6 +580,10 @@ data = malloc ( size ); if ( data ) memset ( data, 0, size ); + if ( ASSERTED ) { + DBGC ( &heap, "Possible memory corruption detected from %p\n", + __builtin_return_address ( 0 ) ); + } return data; }
[-] [+]	Changed	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/core/pinger.c ^
@@ -68,10 +68,16 @@ size_t len; /** Current sequence number / uint16_t sequence; + /* Response for current sequence number is still pending / + int pending; + /* Number of remaining expiry events (zero to continue indefinitely) / + unsigned int remaining; + /* Return status / + int rc; /* Callback function * - * @v src Source socket address + * @v src Source socket address, or NULL * @v sequence Sequence number * @v len Payload length * @v rc Status code @@ -159,6 +165,16 @@ struct io_buffer iobuf; int rc; + / If no response has been received, notify the callback function / + if ( pinger->pending && pinger->callback ) + pinger->callback ( NULL, pinger->sequence, 0, -ETIMEDOUT ); + + / Check for termination / + if ( pinger->remaining && ( --pinger->remaining == 0 ) ) { + pinger_close ( pinger, pinger->rc ); + return; + } + / Increase sequence number / pinger->sequence++; @@ -166,6 +182,7 @@ case the transmission attempt fails. / start_timer_fixed ( &pinger->timer, pinger->timeout ); + pinger->pending = 1; / Allocate I/O buffer / iobuf = xfer_alloc_iob ( &pinger->xfer, pinger->len ); @@ -203,29 +220,56 @@ struct xfer_metadata meta ) { size_t len = iob_len ( iobuf ); uint16_t sequence = meta->offset; + int terminate = 0; int rc; + /* Clear response pending flag, if applicable / + if ( sequence == pinger->sequence ) + pinger->pending = 0; + / Check for errors / if ( len != pinger->len ) { + / Incorrect length: terminate immediately if we are + * not pinging indefinitely. + / DBGC ( pinger, "PINGER %p received incorrect length %zd " "(expected %zd)\n", pinger, len, pinger->len ); rc = -EPROTO_LEN; + terminate = ( pinger->remaining != 0 ); } else if ( ( rc = pinger_verify ( pinger, iobuf->data ) ) != 0 ) { + / Incorrect data: terminate immediately if we are not + * pinging indefinitely. + / DBGC ( pinger, "PINGER %p received incorrect data:\n", pinger ); DBGC_HDA ( pinger, 0, iobuf->data, iob_len ( iobuf ) ); + terminate = ( pinger->remaining != 0 ); } else if ( sequence != pinger->sequence ) { + / Incorrect sequence number (probably a delayed response): + * report via callback but otherwise ignore. + / DBGC ( pinger, "PINGER %p received sequence %d (expected %d)\n", pinger, sequence, pinger->sequence ); rc = -EPROTO_SEQ; + terminate = 0; } else { + / Success: record that a packet was successfully received, + * and terminate if we expect to send no further packets. + / rc = 0; + pinger->rc = 0; + terminate = ( pinger->remaining == 1 ); } / Discard I/O buffer / free_iob ( iobuf ); - / Notify callback function / - pinger->callback ( meta->src, sequence, len, rc ); + / Notify callback function, if applicable / + if ( pinger->callback ) + pinger->callback ( meta->src, sequence, len, rc ); + + / Terminate if applicable / + if ( terminate ) + pinger_close ( pinger, rc ); return rc; } @@ -257,10 +301,12 @@ @v hostname Hostname to ping * @v timeout Timeout (in ticks) * @v len Payload length + * @v count Number of packets to send (or zero for no limit) + * @v callback Callback function (or NULL) * @ret rc Return status code / int create_pinger ( struct interface job, const char hostname, - unsigned long timeout, size_t len, + unsigned long timeout, size_t len, unsigned int count, void ( callback ) ( struct sockaddr src, unsigned int sequence, size_t len, int rc ) ) { @@ -281,7 +327,9 @@ timer_init ( &pinger->timer, pinger_expired, &pinger->refcnt ); pinger->timeout = timeout; pinger->len = len; + pinger->remaining = ( count ? ( count + 1 / Initial packet / ) : 0 ); pinger->callback = callback; + pinger->rc = -ETIMEDOUT; / Open socket */ if ( ( rc = xfer_open_named_socket ( &pinger->xfer, SOCK_ECHO, NULL,
[-] [+]	Changed	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/crypto/ocsp.c ^
@@ -405,12 +405,17 @@ static int ocsp_compare_responder_key_hash ( struct ocsp_check ocsp, struct x509_certificate cert ) { struct ocsp_responder responder = &ocsp->response.responder; + struct asn1_cursor key_hash; uint8_t ctx[SHA1_CTX_SIZE]; uint8_t digest[SHA1_DIGEST_SIZE]; int difference; + / Enter responder key hash / + memcpy ( &key_hash, &responder->id, sizeof ( key_hash ) ); + asn1_enter ( &key_hash, ASN1_OCTET_STRING ); + / Sanity check / - difference = ( sizeof ( digest ) - responder->id.len ); + difference = ( sizeof ( digest ) - key_hash.len ); if ( difference ) return difference; @@ -421,8 +426,8 @@ cert->subject.public_key.raw_bits.len ); digest_final ( &sha1_algorithm, ctx, digest ); - / Compare responder ID with SHA1 hash of certificate's public key / - return memcmp ( digest, responder->id.data, sizeof ( digest ) ); + / Compare responder key hash with hash of certificate's public key / + return memcmp ( digest, key_hash.data, sizeof ( digest ) ); } /*
[-] [+]	Changed	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/drivers/net/intel.c ^
@@ -232,16 +232,16 @@ DBGC ( intel, "INTEL %p has autoloaded MAC address %s\n", intel, eth_ntoa ( mac.raw ) ); - /* Try to read address from EEPROM / - if ( ( rc = intel_fetch_mac_eeprom ( intel, hw_addr ) ) == 0 ) - return 0; - / Use current address if valid / if ( is_valid_ether_addr ( mac.raw ) ) { memcpy ( hw_addr, mac.raw, ETH_ALEN ); return 0; } + / Otherwise, try to read address from EEPROM */ + if ( ( rc = intel_fetch_mac_eeprom ( intel, hw_addr ) ) == 0 ) + return 0; + DBGC ( intel, "INTEL %p has no MAC address to use\n", intel ); return -ENOENT; }
[-] [+]	Added	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/drivers/net/netvsc.c ^
@@ -0,0 +1,844 @@ +/* + * Copyright (C) 2014 Michael Brown <mbrown@fensystems.co.uk>. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA. + / + +FILE_LICENCE ( GPL2_OR_LATER ); + +/* @file + * + * Hyper-V network virtual service client + * + * The network virtual service client (NetVSC) connects to the network + * virtual service provider (NetVSP) via the Hyper-V virtual machine + * bus (VMBus). It provides a transport layer for RNDIS packets. + / + +#include <errno.h> +#include <unistd.h> +#include <byteswap.h> +#include <ipxe/umalloc.h> +#include <ipxe/rndis.h> +#include <ipxe/vmbus.h> +#include "netvsc.h" + +/* + * Send control message and wait for completion + * + * @v netvsc NetVSC device + * @v xrid Relative transaction ID + * @v data Data + * @v len Length of data + * @ret rc Return status code + / +static int netvsc_control ( struct netvsc_device netvsc, unsigned int xrid, + const void data, size_t len ) { + uint64_t xid = ( NETVSC_BASE_XID + xrid ); + unsigned int i; + int rc; + + / Send control message / + if ( ( rc = vmbus_send_control ( netvsc->vmdev, xid, data, len ) ) !=0){ + DBGC ( netvsc, "NETVSC %s could not send control message: %s\n", + netvsc->name, strerror ( rc ) ); + return rc; + } + + / Record transaction ID / + netvsc->wait_xrid = xrid; + + / Wait for operation to complete / + for ( i = 0 ; i < NETVSC_MAX_WAIT_MS ; i++ ) { + + / Check for completion / + if ( ! netvsc->wait_xrid ) + return netvsc->wait_rc; + + / Poll VMBus device / + vmbus_poll ( netvsc->vmdev ); + + / Delay for 1ms / + mdelay ( 1 ); + } + + DBGC ( netvsc, "NETVSC %s timed out waiting for XRID %d\n", + netvsc->name, xrid ); + vmbus_dump_channel ( netvsc->vmdev ); + return -ETIMEDOUT; +} + +/* + * Handle generic completion + * + * @v netvsc NetVSC device + * @v data Data + * @v len Length of data + * @ret rc Return status code + / +static int netvsc_completed ( struct netvsc_device netvsc __unused, + const void data __unused, size_t len __unused ) { + return 0; +} + +/* + * Initialise communication + * + * @v netvsc NetVSC device + * @ret rc Return status code + / +static int netvsc_initialise ( struct netvsc_device netvsc ) { + struct netvsc_init_message msg; + int rc; + + /* Construct message / + memset ( &msg, 0, sizeof ( msg ) ); + msg.header.type = cpu_to_le32 ( NETVSC_INIT_MSG ); + msg.min = cpu_to_le32 ( NETVSC_VERSION_1 ); + msg.max = cpu_to_le32 ( NETVSC_VERSION_1 ); + + / Send message and wait for completion / + if ( ( rc = netvsc_control ( netvsc, NETVSC_INIT_XRID, &msg, + sizeof ( msg ) ) ) != 0 ) { + DBGC ( netvsc, "NETVSC %s could not initialise: %s\n", + netvsc->name, strerror ( rc ) ); + return rc; + } + + return 0; +} + +/* + * Handle initialisation completion + * + * @v netvsc NetVSC device + * @v data Data + * @v len Length of data + * @ret rc Return status code + / +static int +netvsc_initialised ( struct netvsc_device netvsc, const void data, + size_t len ) { + const struct netvsc_init_completion cmplt = data; + + /* Check completion / + if ( len < sizeof ( cmplt ) ) { + DBGC ( netvsc, "NETVSC %s underlength initialisation " + "completion (%zd bytes)\n", netvsc->name, len ); + return -EINVAL; + } + if ( cmplt->header.type != cpu_to_le32 ( NETVSC_INIT_CMPLT ) ) { + DBGC ( netvsc, "NETVSC %s unexpected initialisation completion " + "type %d\n", netvsc->name, + le32_to_cpu ( cmplt->header.type ) ); + return -EPROTO; + } + if ( cmplt->status != cpu_to_le32 ( NETVSC_OK ) ) { + DBGC ( netvsc, "NETVSC %s initialisation failure status %d\n", + netvsc->name, le32_to_cpu ( cmplt->status ) ); + return -EPROTO; + } + + return 0; +} + +/** + * Set NDIS version + * + * @v netvsc NetVSC device + * @ret rc Return status code + / +static int netvsc_ndis_version ( struct netvsc_device netvsc ) { + struct netvsc_ndis_version_message msg; + int rc; + + /* Construct message / + memset ( &msg, 0, sizeof ( msg ) ); + msg.header.type = cpu_to_le32 ( NETVSC_NDIS_VERSION_MSG ); + msg.major = cpu_to_le32 ( NETVSC_NDIS_MAJOR ); + msg.minor = cpu_to_le32 ( NETVSC_NDIS_MINOR ); + + / Send message and wait for completion / + if ( ( rc = netvsc_control ( netvsc, NETVSC_NDIS_VERSION_XRID, + &msg, sizeof ( msg ) ) ) != 0 ) { + DBGC ( netvsc, "NETVSC %s could not set NDIS version: %s\n", + netvsc->name, strerror ( rc ) ); + return rc; + } + + return 0; +} + +/* + * Establish data buffer + * + * @v netvsc NetVSC device + * @v buffer Data buffer + * @ret rc Return status code + / +static int netvsc_establish_buffer ( struct netvsc_device netvsc, + struct netvsc_buffer buffer ) { + struct netvsc_establish_buffer_message msg; + int rc; + + / Construct message / + memset ( &msg, 0, sizeof ( msg ) ); + msg.header.type = cpu_to_le32 ( buffer->establish_type ); + msg.gpadl = cpu_to_le32 ( buffer->gpadl ); + msg.pageset = buffer->pages.pageset; / Already protocol-endian / + + / Send message and wait for completion / + if ( ( rc = netvsc_control ( netvsc, buffer->establish_xrid, &msg, + sizeof ( msg ) ) ) != 0 ) { + DBGC ( netvsc, "NETVSC %s could not establish buffer: %s\n", + netvsc->name, strerror ( rc ) ); + return rc; + } + + return 0; +} + +/* + * Handle establish receive data buffer completion + * + * @v netvsc NetVSC device + * @v data Data + * @v len Length of data + * @ret rc Return status code + / +static int netvsc_rx_established_buffer ( struct netvsc_device netvsc, + const void data, size_t len ) { + const struct netvsc_rx_establish_buffer_completion cmplt = data; + + /* Check completion / + if ( len < sizeof ( cmplt ) ) { + DBGC ( netvsc, "NETVSC %s underlength buffer completion (%zd " + "bytes)\n", netvsc->name, len ); + return -EINVAL; + } + if ( cmplt->header.type != cpu_to_le32 ( NETVSC_RX_ESTABLISH_CMPLT ) ) { + DBGC ( netvsc, "NETVSC %s unexpected buffer completion type " + "%d\n", netvsc->name, le32_to_cpu ( cmplt->header.type)); + return -EPROTO; + } + if ( cmplt->status != cpu_to_le32 ( NETVSC_OK ) ) { + DBGC ( netvsc, "NETVSC %s buffer failure status %d\n", + netvsc->name, le32_to_cpu ( cmplt->status ) ); + return -EPROTO; + } + + return 0; +} + +/** + * Revoke data buffer + * + * @v netvsc NetVSC device + * @v buffer Data buffer + * @ret rc Return status code + / +static int netvsc_revoke_buffer ( struct netvsc_device netvsc, + struct netvsc_buffer buffer ) { + struct netvsc_revoke_buffer_message msg; + int rc; + + / Construct message / + memset ( &msg, 0, sizeof ( msg ) ); + msg.header.type = cpu_to_le32 ( buffer->revoke_type ); + msg.pageset = buffer->pages.pageset; / Already protocol-endian / + + / Send message and wait for completion / + if ( ( rc = netvsc_control ( netvsc, buffer->revoke_xrid, + &msg, sizeof ( msg ) ) ) != 0 ) { + DBGC ( netvsc, "NETVSC %s could not revoke buffer: %s\n", + netvsc->name, strerror ( rc ) ); + return rc; + } + + return 0; +} + +/* + * Handle received control packet + * + * @v vmdev VMBus device + * @v xid Transaction ID + * @v data Data + * @v len Length of data + * @ret rc Return status code + / +static int netvsc_recv_control ( struct vmbus_device vmdev, uint64_t xid, + const void data, size_t len ) { + struct rndis_device rndis = vmbus_get_drvdata ( vmdev ); + struct netvsc_device netvsc = rndis->priv; + + DBGC ( netvsc, "NETVSC %s received unsupported control packet " + "(%08llx):\n", netvsc->name, xid ); + DBGC_HDA ( netvsc, 0, data, len ); + return -ENOTSUP; +} + +/* + * Handle received data packet + * + * @v vmdev VMBus device + * @v xid Transaction ID + * @v data Data + * @v len Length of data + * @v list List of I/O buffers + * @ret rc Return status code + / +static int netvsc_recv_data ( struct vmbus_device vmdev, uint64_t xid, + const void data, size_t len, + struct list_head list ) { + struct rndis_device rndis = vmbus_get_drvdata ( vmdev ); + struct netvsc_device netvsc = rndis->priv; + const struct netvsc_rndis_message msg = data; + struct io_buffer iobuf; + struct io_buffer tmp; + int rc; + + / Sanity check / + if ( len < sizeof ( msg ) ) { + DBGC ( netvsc, "NETVSC %s received underlength RNDIS packet " + "(%zd bytes)\n", netvsc->name, len ); + rc = -EINVAL; + goto err_sanity; + } + if ( msg->header.type != cpu_to_le32 ( NETVSC_RNDIS_MSG ) ) { + DBGC ( netvsc, "NETVSC %s received unexpected RNDIS packet " + "type %d\n", netvsc->name, + le32_to_cpu ( msg->header.type ) ); + rc = -EINVAL; + goto err_sanity; + } + + /* Send completion back to host / + if ( ( rc = vmbus_send_completion ( vmdev, xid, NULL, 0 ) ) != 0 ) { + DBGC ( netvsc, "NETVSC %s could not send completion: %s\n", + netvsc->name, strerror ( rc ) ); + goto err_completion; + } + + / Hand off to RNDIS / + list_for_each_entry_safe ( iobuf, tmp, list, list ) { + list_del ( &iobuf->list ); + rndis_rx ( rndis, iob_disown ( iobuf ) ); + } + + return 0; + + err_completion: + err_sanity: + list_for_each_entry_safe ( iobuf, tmp, list, list ) { + list_del ( &iobuf->list ); + free_iob ( iobuf ); + } + return rc; +} + +/* + * Handle received completion packet + * + * @v vmdev VMBus device + * @v xid Transaction ID + * @v data Data + * @v len Length of data + * @ret rc Return status code + / +static int netvsc_recv_completion ( struct vmbus_device vmdev, uint64_t xid, + const void data, size_t len ) { + struct rndis_device rndis = vmbus_get_drvdata ( vmdev ); + struct netvsc_device netvsc = rndis->priv; + struct io_buffer iobuf; + int ( * completion ) ( struct netvsc_device netvsc, + const void data, size_t len ); + unsigned int xrid = ( xid - NETVSC_BASE_XID ); + unsigned int tx_id; + int rc; + + /* Handle transmit completion, if applicable / + tx_id = ( xrid - NETVSC_TX_BASE_XRID ); + if ( ( tx_id < NETVSC_TX_NUM_DESC ) && + ( ( iobuf = netvsc->tx.iobufs[tx_id] ) != NULL ) ) { + + / Free buffer ID / + netvsc->tx.iobufs[tx_id] = NULL; + netvsc->tx.ids[ ( netvsc->tx.id_cons++ ) & + ( netvsc->tx.count - 1 ) ] = tx_id; + + / Hand back to RNDIS / + rndis_tx_complete ( rndis, iobuf ); + return 0; + } + + / Otherwise determine completion handler / + if ( xrid == NETVSC_INIT_XRID ) { + completion = netvsc_initialised; + } else if ( xrid == NETVSC_RX_ESTABLISH_XRID ) { + completion = netvsc_rx_established_buffer; + } else if ( ( netvsc->wait_xrid != 0 ) && + ( xrid == netvsc->wait_xrid ) ) { + completion = netvsc_completed; + } else { + DBGC ( netvsc, "NETVSC %s received unexpected completion " + "(%08llx)\n", netvsc->name, xid ); + return -EPIPE; + } + + / Hand off to completion handler / + rc = completion ( netvsc, data, len ); + + / Record completion handler result if applicable / + if ( xrid == netvsc->wait_xrid ) { + netvsc->wait_xrid = 0; + netvsc->wait_rc = rc; + } + + return rc; +} + +/* + * Handle received cancellation packet + * + * @v vmdev VMBus device + * @v xid Transaction ID + * @ret rc Return status code + / +static int netvsc_recv_cancellation ( struct vmbus_device vmdev, + uint64_t xid ) { + struct rndis_device rndis = vmbus_get_drvdata ( vmdev ); + struct netvsc_device netvsc = rndis->priv; + + DBGC ( netvsc, "NETVSC %s received unsupported cancellation packet " + "(%08llx):\n", netvsc->name, xid ); + return -ENOTSUP; +} + +/** VMBus channel operations / +static struct vmbus_channel_operations netvsc_channel_operations = { + .recv_control = netvsc_recv_control, + .recv_data = netvsc_recv_data, + .recv_completion = netvsc_recv_completion, + .recv_cancellation = netvsc_recv_cancellation, +}; + +/* + * Poll for completed and received packets + * + * @v rndis RNDIS device + / +static void netvsc_poll ( struct rndis_device rndis ) { + struct netvsc_device netvsc = rndis->priv; + struct vmbus_device vmdev = netvsc->vmdev; + + /* Poll VMBus device / + while ( vmbus_has_data ( vmdev ) ) + vmbus_poll ( vmdev ); +} + +/* + * Transmit packet + * + * @v rndis RNDIS device + * @v iobuf I/O buffer + * @ret rc Return status code + * + * If this method returns success then the RNDIS device must + * eventually report completion via rndis_tx_complete(). + / +static int netvsc_transmit ( struct rndis_device rndis, + struct io_buffer iobuf ) { + struct netvsc_device netvsc = rndis->priv; + struct rndis_header header = iobuf->data; + struct netvsc_rndis_message msg; + unsigned int tx_id; + unsigned int xrid; + uint64_t xid; + int rc; + + / Sanity check / + assert ( iob_len ( iobuf ) >= sizeof ( header ) ); + assert ( iob_len ( iobuf ) == le32_to_cpu ( header->len ) ); + + /* Check that we have space in the transmit ring / + if ( netvsc_ring_is_full ( &netvsc->tx ) ) + return rndis_tx_defer ( rndis, iobuf ); + + / Allocate buffer ID and calculate transaction ID / + tx_id = netvsc->tx.ids[ netvsc->tx.id_prod & ( netvsc->tx.count - 1 ) ]; + assert ( netvsc->tx.iobufs[tx_id] == NULL ); + xrid = ( NETVSC_TX_BASE_XRID + tx_id ); + xid = ( NETVSC_BASE_XID + xrid ); + + / Construct message / + memset ( &msg, 0, sizeof ( msg ) ); + msg.header.type = cpu_to_le32 ( NETVSC_RNDIS_MSG ); + msg.channel = ( ( header->type == cpu_to_le32 ( RNDIS_PACKET_MSG ) ) ? + NETVSC_RNDIS_DATA : NETVSC_RNDIS_CONTROL ); + msg.buffer = cpu_to_le32 ( NETVSC_RNDIS_NO_BUFFER ); + + / Send message / + if ( ( rc = vmbus_send_data ( netvsc->vmdev, xid, &msg, sizeof ( msg ), + iobuf ) ) != 0 ) { + DBGC ( netvsc, "NETVSC %s could not send RNDIS message: %s\n", + netvsc->name, strerror ( rc ) ); + return rc; + } + + / Store I/O buffer and consume buffer ID / + netvsc->tx.iobufs[tx_id] = iobuf; + netvsc->tx.id_prod++; + + return 0; +} + +/* + * Cancel transmission + * + * @v netvsc NetVSC device + * @v iobuf I/O buffer + * @v tx_id Transmission ID + / +static void netvsc_cancel_transmit ( struct netvsc_device netvsc, + struct io_buffer iobuf, + unsigned int tx_id ) { + unsigned int xrid; + uint64_t xid; + + / Send cancellation / + xrid = ( NETVSC_TX_BASE_XRID + tx_id ); + xid = ( NETVSC_BASE_XID + xrid ); + DBGC ( netvsc, "NETVSC %s cancelling transmission %#x\n", + netvsc->name, tx_id ); + vmbus_send_cancellation ( netvsc->vmdev, xid ); + + / Report back to RNDIS / + rndis_tx_complete_err ( netvsc->rndis, iobuf, -ECANCELED ); +} + +/* + * Create descriptor ring + * + * @v netvsc NetVSC device + * @v ring Descriptor ring + * @ret rc Return status code + / +static int netvsc_create_ring ( struct netvsc_device netvsc __unused, + struct netvsc_ring ring ) { + unsigned int i; + + / Initialise buffer ID ring / + for ( i = 0 ; i < ring->count ; i++ ) { + ring->ids[i] = i; + assert ( ring->iobufs[i] == NULL ); + } + ring->id_prod = 0; + ring->id_cons = 0; + + return 0; +} + +/* + * Destroy descriptor ring + * + * @v netvsc NetVSC device + * @v ring Descriptor ring + * @v discard Method used to discard outstanding buffer, or NULL + / +static void netvsc_destroy_ring ( struct netvsc_device netvsc, + struct netvsc_ring ring, + void ( discard ) ( struct netvsc_device , + struct io_buffer , + unsigned int ) ) { + struct io_buffer iobuf; + unsigned int i; + + / Flush any outstanding buffers / + for ( i = 0 ; i < ring->count ; i++ ) { + iobuf = ring->iobufs[i]; + if ( ! iobuf ) + continue; + ring->iobufs[i] = NULL; + ring->ids[ ( ring->id_cons++ ) & ( ring->count - 1 ) ] = i; + if ( discard ) + discard ( netvsc, iobuf, i ); + } + + / Sanity check / + assert ( netvsc_ring_is_empty ( ring ) ); +} + +/* + * Copy data from data buffer + * + * @v pages Transfer page set + * @v data Data buffer + * @v offset Offset within page set + * @v len Length within page set + * @ret rc Return status code + / +static int netvsc_buffer_copy ( struct vmbus_xfer_pages pages, void data, + size_t offset, size_t len ) { + struct netvsc_buffer buffer = + container_of ( pages, struct netvsc_buffer, pages ); + + /* Sanity check / + if ( ( offset > buffer->len ) \|\| ( len > ( buffer->len - offset ) ) ) + return -ERANGE; + + / Copy data from buffer / + copy_from_user ( data, buffer->data, offset, len ); + + return 0; +} + +/* Transfer page set operations / +static struct vmbus_xfer_pages_operations netvsc_xfer_pages_operations = { + .copy = netvsc_buffer_copy, +}; + +/* + * Create data buffer + * + * @v netvsc NetVSC device + * @v buffer Data buffer + * @ret rc Return status code + / +static int netvsc_create_buffer ( struct netvsc_device netvsc, + struct netvsc_buffer buffer ) { + struct vmbus_device vmdev = netvsc->vmdev; + int gpadl; + int rc; + + /* Allocate receive buffer / + buffer->data = umalloc ( buffer->len ); + if ( ! buffer->data ) { + DBGC ( netvsc, "NETVSC %s could not allocate %zd-byte buffer\n", + netvsc->name, buffer->len ); + rc = -ENOMEM; + goto err_alloc; + } + + / Establish GPA descriptor list / + gpadl = vmbus_establish_gpadl ( vmdev, buffer->data, buffer->len ); + if ( gpadl < 0 ) { + rc = gpadl; + DBGC ( netvsc, "NETVSC %s could not establish GPADL: %s\n", + netvsc->name, strerror ( rc ) ); + goto err_establish_gpadl; + } + buffer->gpadl = gpadl; + + / Register transfer page set / + if ( ( rc = vmbus_register_pages ( vmdev, &buffer->pages ) ) != 0 ) { + DBGC ( netvsc, "NETVSC %s could not register transfer pages: " + "%s\n", netvsc->name, strerror ( rc ) ); + goto err_register_pages; + } + + return 0; + + vmbus_unregister_pages ( vmdev, &buffer->pages ); + err_register_pages: + vmbus_gpadl_teardown ( vmdev, gpadl ); + err_establish_gpadl: + ufree ( buffer->data ); + err_alloc: + return rc; +} + +/* + * Destroy data buffer + * + * @v netvsc NetVSC device + * @v buffer Data buffer + / +static void netvsc_destroy_buffer ( struct netvsc_device netvsc, + struct netvsc_buffer buffer ) { + struct vmbus_device vmdev = netvsc->vmdev; + int rc; + + /* Unregister transfer pages / + vmbus_unregister_pages ( vmdev, &buffer->pages ); + + / Tear down GPA descriptor list / + if ( ( rc = vmbus_gpadl_teardown ( vmdev, buffer->gpadl ) ) != 0 ) { + DBGC ( netvsc, "NETVSC %s could not tear down GPADL: %s\n", + netvsc->name, strerror ( rc ) ); + / Death is imminent. The host may well continue to + * write to the data buffer. The best we can do is + * leak memory for now and hope that the host doesn't + * write to this region after we load an OS. + / + return; + } + + / Free buffer / + ufree ( buffer->data ); +} + +/* + * Open device + * + * @v rndis RNDIS device + * @ret rc Return status code + / +static int netvsc_open ( struct rndis_device rndis ) { + struct netvsc_device netvsc = rndis->priv; + int rc; + + / Initialise receive buffer / + if ( ( rc = netvsc_create_buffer ( netvsc, &netvsc->rx ) ) != 0 ) + goto err_create_rx; + + / Open channel / + if ( ( rc = vmbus_open ( netvsc->vmdev, &netvsc_channel_operations, + PAGE_SIZE, PAGE_SIZE, NETVSC_MTU ) ) != 0 ) { + DBGC ( netvsc, "NETVSC %s could not open VMBus: %s\n", + netvsc->name, strerror ( rc ) ); + goto err_vmbus_open; + } + + / Initialise communication with NetVSP / + if ( ( rc = netvsc_initialise ( netvsc ) ) != 0 ) + goto err_initialise; + if ( ( rc = netvsc_ndis_version ( netvsc ) ) != 0 ) + goto err_ndis_version; + + / Initialise transmit ring / + if ( ( rc = netvsc_create_ring ( netvsc, &netvsc->tx ) ) != 0 ) + goto err_create_tx; + + / Establish receive buffer / + if ( ( rc = netvsc_establish_buffer ( netvsc, &netvsc->rx ) ) != 0 ) + goto err_establish_rx; + + return 0; + + netvsc_revoke_buffer ( netvsc, &netvsc->rx ); + err_establish_rx: + netvsc_destroy_ring ( netvsc, &netvsc->tx, NULL ); + err_create_tx: + err_ndis_version: + err_initialise: + vmbus_close ( netvsc->vmdev ); + err_vmbus_open: + netvsc_destroy_buffer ( netvsc, &netvsc->rx ); + err_create_rx: + return rc; +} + +/* + * Close device + * + * @v rndis RNDIS device + / +static void netvsc_close ( struct rndis_device rndis ) { + struct netvsc_device netvsc = rndis->priv; + + / Revoke receive buffer / + netvsc_revoke_buffer ( netvsc, &netvsc->rx ); + + / Destroy transmit ring / + netvsc_destroy_ring ( netvsc, &netvsc->tx, netvsc_cancel_transmit ); + + / Close channel / + vmbus_close ( netvsc->vmdev ); + + / Destroy receive buffer / + netvsc_destroy_buffer ( netvsc, &netvsc->rx ); +} + +/* RNDIS operations / +static struct rndis_operations netvsc_operations = { + .open = netvsc_open, + .close = netvsc_close, + .transmit = netvsc_transmit, + .poll = netvsc_poll, +}; + +/* + * Probe device + * + * @v vmdev VMBus device + * @ret rc Return status code + / +static int netvsc_probe ( struct vmbus_device vmdev ) { + struct netvsc_device netvsc; + struct rndis_device rndis; + int rc; + + /* Allocate and initialise structure / + rndis = alloc_rndis ( sizeof ( netvsc ) ); + if ( ! rndis ) { + rc = -ENOMEM; + goto err_alloc; + } + rndis_init ( rndis, &netvsc_operations ); + rndis->netdev->dev = &vmdev->dev; + netvsc = rndis->priv; + netvsc->vmdev = vmdev; + netvsc->rndis = rndis; + netvsc->name = vmdev->dev.name; + netvsc_init_ring ( &netvsc->tx, NETVSC_TX_NUM_DESC, + netvsc->tx_iobufs, netvsc->tx_ids ); + netvsc_init_buffer ( &netvsc->rx, NETVSC_RX_BUF_PAGESET, + &netvsc_xfer_pages_operations, + NETVSC_RX_ESTABLISH_MSG, NETVSC_RX_ESTABLISH_XRID, + NETVSC_RX_REVOKE_MSG, NETVSC_RX_REVOKE_XRID, + NETVSC_RX_BUF_LEN ); + vmbus_set_drvdata ( vmdev, rndis ); + + /* Register RNDIS device / + if ( ( rc = register_rndis ( rndis ) ) != 0 ) { + DBGC ( netvsc, "NETVSC %s could not register: %s\n", + netvsc->name, strerror ( rc ) ); + goto err_register; + } + + return 0; + + unregister_rndis ( rndis ); + err_register: + free_rndis ( rndis ); + err_alloc: + return rc; +} + +/* + * Remove device + * + * @v vmdev VMBus device + / +static void netvsc_remove ( struct vmbus_device vmdev ) { + struct rndis_device rndis = vmbus_get_drvdata ( vmdev ); + + / Unregister RNDIS device / + unregister_rndis ( rndis ); + + / Free RNDIS device / + free_rndis ( rndis ); +} + +/* NetVSC driver */ +struct vmbus_driver netvsc_driver __vmbus_driver = { + .name = "netvsc", + .type = VMBUS_TYPE ( 0xf8615163, 0xdf3e, 0x46c5, 0x913f, + 0xf2, 0xd2, 0xf9, 0x65, 0xed, 0x0e ), + .probe = netvsc_probe, + .remove = netvsc_remove, +};
[-] [+]	Added	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/drivers/net/netvsc.h ^
@@ -0,0 +1,365 @@ +#ifndef _NETVSC_H +#define _NETVSC_H + +/** @file + * + * Hyper-V network virtual service client + * + / + +FILE_LICENCE ( GPL2_OR_LATER ); + +/* Maximum supported NetVSC message length / +#define NETVSC_MTU 512 + +/* Maximum time to wait for a transaction to complete + * + * This is a policy decision. + / +#define NETVSC_MAX_WAIT_MS 1000 + +/* Number of transmit ring entries + * + * Must be a power of two. This is a policy decision. This value + * must be sufficiently small to guarantee that we never run out of + * space in the VMBus outbound ring buffer. + / +#define NETVSC_TX_NUM_DESC 32 + +/* RX data buffer page set ID + * + * This is a policy decision. + / +#define NETVSC_RX_BUF_PAGESET 0xbead + +/* RX data buffer length + * + * This is a policy decision. + / +#define NETVSC_RX_BUF_LEN ( 16 PAGE_SIZE ) + +/** Base transaction ID + * + * This is a policy decision. + / +#define NETVSC_BASE_XID 0x18ae0000UL + +/* Relative transaction IDs / +enum netvsc_xrid { + /* Transmit descriptors (one per transmit buffer ID) / + NETVSC_TX_BASE_XRID = 0, + /* Initialisation / + NETVSC_INIT_XRID = ( NETVSC_TX_BASE_XRID + NETVSC_TX_NUM_DESC ), + /* NDIS version / + NETVSC_NDIS_VERSION_XRID, + /* Establish receive buffer / + NETVSC_RX_ESTABLISH_XRID, + /* Revoke receive buffer / + NETVSC_RX_REVOKE_XRID, +}; + +/* NetVSC status codes / +enum netvsc_status { + NETVSC_NONE = 0, + NETVSC_OK = 1, + NETVSC_FAIL = 2, + NETVSC_TOO_NEW = 3, + NETVSC_TOO_OLD = 4, + NETVSC_BAD_PACKET = 5, + NETVSC_BUSY = 6, + NETVSC_UNSUPPORTED = 7, +}; + +/* NetVSC message header / +struct netvsc_header { + /* Type / + uint32_t type; +} __attribute__ (( packed )); + +/* NetVSC initialisation message / +#define NETVSC_INIT_MSG 1 + +/* NetVSC initialisation message / +struct netvsc_init_message { + /* Message header / + struct netvsc_header header; + /* Minimum supported protocol version / + uint32_t min; + /* Maximum supported protocol version / + uint32_t max; + /* Reserved / + uint8_t reserved[20]; +} __attribute__ (( packed )); + +/* Oldest known NetVSC protocol version / +#define NETVSC_VERSION_1 2 / sic / + +/* NetVSC initialisation completion / +#define NETVSC_INIT_CMPLT 2 + +/* NetVSC initialisation completion / +struct netvsc_init_completion { + /* Message header / + struct netvsc_header header; + /* Protocol version / + uint32_t version; + /* Maximum memory descriptor list length / + uint32_t max_mdl_len; + /* Status / + uint32_t status; + /* Reserved / + uint8_t reserved[16]; +} __attribute__ (( packed )); + +/* NetVSC NDIS version message / +#define NETVSC_NDIS_VERSION_MSG 100 + +/* NetVSC NDIS version message / +struct netvsc_ndis_version_message { + /* Message header / + struct netvsc_header header; + /* Major version / + uint32_t major; + /* Minor version / + uint32_t minor; + /* Reserved / + uint8_t reserved[20]; +} __attribute__ (( packed )); + +/* NetVSC NDIS major version / +#define NETVSC_NDIS_MAJOR 6 + +/* NetVSC NDIS minor version / +#define NETVSC_NDIS_MINOR 1 + +/* NetVSC establish receive data buffer message / +#define NETVSC_RX_ESTABLISH_MSG 101 + +/* NetVSC establish receive data buffer completion / +#define NETVSC_RX_ESTABLISH_CMPLT 102 + +/* NetVSC revoke receive data buffer message / +#define NETVSC_RX_REVOKE_MSG 103 + +/* NetVSC establish transmit data buffer message / +#define NETVSC_TX_ESTABLISH_MSG 104 + +/* NetVSC establish transmit data buffer completion / +#define NETVSC_TX_ESTABLISH_CMPLT 105 + +/* NetVSC revoke transmit data buffer message / +#define NETVSC_TX_REVOKE_MSG 106 + +/* NetVSC establish data buffer message / +struct netvsc_establish_buffer_message { + /* Message header / + struct netvsc_header header; + /* GPADL ID / + uint32_t gpadl; + /* Page set ID / + uint16_t pageset; + /* Reserved / + uint8_t reserved[22]; +} __attribute__ (( packed )); + +/* NetVSC receive data buffer section / +struct netvsc_rx_buffer_section { + /* Starting offset / + uint32_t start; + /* Subsection length / + uint32_t len; + /* Number of subsections / + uint32_t count; + /* Ending offset / + uint32_t end; +} __attribute__ (( packed )); + +/* NetVSC establish receive data buffer completion / +struct netvsc_rx_establish_buffer_completion { + /* Message header / + struct netvsc_header header; + /* Status / + uint32_t status; + /* Number of sections (must be 1) / + uint32_t count; + /* Section descriptors / + struct netvsc_rx_buffer_section section[1]; +} __attribute__ (( packed )); + +/* NetVSC establish transmit data buffer completion / +struct netvsc_tx_establish_buffer_completion { + /* Message header / + struct netvsc_header header; + /* Status / + uint32_t status; + /* Section length / + uint32_t len; +} __attribute__ (( packed )); + +/* NetVSC revoke data buffer message / +struct netvsc_revoke_buffer_message { + /* Message header / + struct netvsc_header header; + /* Page set ID / + uint16_t pageset; + /* Reserved / + uint8_t reserved[26]; +} __attribute__ (( packed )); + +/* NetVSC RNDIS message / +#define NETVSC_RNDIS_MSG 107 + +/* NetVSC RNDIS message / +struct netvsc_rndis_message { + /* Message header / + struct netvsc_header header; + /* RNDIS channel / + uint32_t channel; + /* Buffer index (or NETVSC_RNDIS_NO_BUFFER) / + uint32_t buffer; + /* Buffer length / + uint32_t len; + /* Reserved / + uint8_t reserved[16]; +} __attribute__ (( packed )); + +/* RNDIS data channel (for RNDIS_PACKET_MSG only) / +#define NETVSC_RNDIS_DATA 0 + +/* RNDIS control channel (for all other RNDIS messages) / +#define NETVSC_RNDIS_CONTROL 1 + +/* "No buffer used" index / +#define NETVSC_RNDIS_NO_BUFFER 0xffffffffUL + +/* A NetVSC descriptor ring / +struct netvsc_ring { + /* Number of descriptors / + unsigned int count; + /* I/O buffers, indexed by buffer ID / + struct io_buffer iobufs; + /* Buffer ID ring / + uint8_t ids; + /** Buffer ID producer counter / + unsigned int id_prod; + /* Buffer ID consumer counter / + unsigned int id_cons; +}; + +/* + * Initialise descriptor ring + * + * @v ring Descriptor ring + * @v count Maximum number of used descriptors + * @v iobufs I/O buffers + * @v ids Buffer IDs + / +static inline __attribute__ (( always_inline )) void +netvsc_init_ring ( struct netvsc_ring ring, unsigned int count, + struct io_buffer *iobufs, uint8_t ids ) { + + ring->count = count; + ring->iobufs = iobufs; + ring->ids = ids; +} + +/** + * Check whether or not descriptor ring is full + * + * @v ring Descriptor ring + * @v is_full Ring is full + / +static inline __attribute__ (( always_inline )) int +netvsc_ring_is_full ( struct netvsc_ring ring ) { + unsigned int fill_level; + + fill_level = ( ring->id_prod - ring->id_cons ); + assert ( fill_level <= ring->count ); + return ( fill_level >= ring->count ); +} + +/** + * Check whether or not descriptor ring is empty + * + * @v ring Descriptor ring + * @v is_empty Ring is empty + / +static inline __attribute__ (( always_inline )) int +netvsc_ring_is_empty ( struct netvsc_ring ring ) { + + return ( ring->id_prod == ring->id_cons ); +} + +/** A NetVSC data buffer / +struct netvsc_buffer { + /* Transfer page set / + struct vmbus_xfer_pages pages; + /* Establish data buffer message type / + uint8_t establish_type; + /* Establish data buffer relative transaction ID / + uint8_t establish_xrid; + /* Revoke data buffer message type / + uint8_t revoke_type; + /* Revoke data buffer relative transaction ID / + uint8_t revoke_xrid; + /* Buffer length / + size_t len; + /* Buffer / + userptr_t data; + /* GPADL ID / + unsigned int gpadl; +}; + +/* + * Initialise data buffer + * + * @v buffer Data buffer + * @v pageset Page set ID + * @v op Page set operations + * @v establish_type Establish data buffer message type + * @v establish_xrid Establish data buffer relative transaction ID + * @v revoke_type Revoke data buffer message type + * @v revoke_type Revoke data buffer relative transaction ID + * @v len Required length + / +static inline __attribute__ (( always_inline )) void +netvsc_init_buffer ( struct netvsc_buffer buffer, uint16_t pageset, + struct vmbus_xfer_pages_operations op, + uint8_t establish_type, uint8_t establish_xrid, + uint8_t revoke_type, uint8_t revoke_xrid, size_t len ) { + + buffer->pages.pageset = cpu_to_le16 ( pageset ); + buffer->pages.op = op; + buffer->establish_type = establish_type; + buffer->establish_xrid = establish_xrid; + buffer->revoke_type = revoke_type; + buffer->revoke_xrid = revoke_xrid; + buffer->len = len; +} + +/* A NetVSC device / +struct netvsc_device { + /* VMBus device / + struct vmbus_device vmdev; + /** RNDIS device / + struct rndis_device rndis; + /** Name / + const char name; + + /** Transmit ring / + struct netvsc_ring tx; + /* Transmit buffer IDs / + uint8_t tx_ids[NETVSC_TX_NUM_DESC]; + /* Transmit I/O buffers / + struct io_buffer tx_iobufs[NETVSC_TX_NUM_DESC]; + + /** Receive buffer / + struct netvsc_buffer rx; + + /* Relative transaction ID for current blocking transaction / + unsigned int wait_xrid; + /* Return status code for current blocking transaction / + int wait_rc; +}; + +#endif / _NETVSC_H */
[-] [+]	Changed	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/drivers/net/vmxnet3.c ^
@@ -26,6 +26,7 @@ #include <ipxe/pci.h> #include <ipxe/io.h> #include <ipxe/malloc.h> +#include <ipxe/profile.h> #include <ipxe/iobuf.h> #include <ipxe/netdevice.h> #include <ipxe/if_ether.h> @@ -39,6 +40,22 @@ * / +/* VM command profiler / +static struct profiler vmxnet3_vm_command_profiler __profiler = + { .name = "vmxnet3.vm_command" }; + +/* VM transmit profiler / +static struct profiler vmxnet3_vm_tx_profiler __profiler = + { .name = "vmxnet3.vm_tx" }; + +/* VM receive refill profiler / +static struct profiler vmxnet3_vm_refill_profiler __profiler = + { .name = "vmxnet3.vm_refill" }; + +/* VM event profiler / +static struct profiler vmxnet3_vm_event_profiler __profiler = + { .name = "vmxnet3.vm_event" }; + /* * Issue command * @@ -48,10 +65,16 @@ / static inline uint32_t vmxnet3_command ( struct vmxnet3_nic vmxnet, uint32_t command ) { + uint32_t result; /* Issue command / + profile_start ( &vmxnet3_vm_command_profiler ); writel ( command, ( vmxnet->vd + VMXNET3_VD_CMD ) ); - return readl ( vmxnet->vd + VMXNET3_VD_CMD ); + result = readl ( vmxnet->vd + VMXNET3_VD_CMD ); + profile_stop ( &vmxnet3_vm_command_profiler ); + profile_exclude ( &vmxnet3_vm_command_profiler ); + + return result; } /* @@ -92,8 +115,11 @@ /* Hand over descriptor to NIC / wmb(); + profile_start ( &vmxnet3_vm_tx_profiler ); writel ( ( vmxnet->count.tx_prod % VMXNET3_NUM_TX_DESC ), ( vmxnet->pt + VMXNET3_PT_TXPROD ) ); + profile_stop ( &vmxnet3_vm_tx_profiler ); + profile_exclude ( &vmxnet3_vm_tx_profiler ); return 0; } @@ -212,8 +238,11 @@ / Hand over any new descriptors to NIC / if ( vmxnet->count.rx_prod != orig_rx_prod ) { wmb(); + profile_start ( &vmxnet3_vm_refill_profiler ); writel ( ( vmxnet->count.rx_prod % VMXNET3_NUM_RX_DESC ), ( vmxnet->pt + VMXNET3_PT_RXPROD ) ); + profile_stop ( &vmxnet3_vm_refill_profiler ); + profile_exclude ( &vmxnet3_vm_refill_profiler ); } } @@ -331,7 +360,10 @@ events = le32_to_cpu ( vmxnet->dma->shared.ecr ); / Acknowledge these events / + profile_start ( &vmxnet3_vm_event_profiler ); writel ( events, ( vmxnet->vd + VMXNET3_VD_ECR ) ); + profile_stop ( &vmxnet3_vm_event_profiler ); + profile_exclude ( &vmxnet3_vm_event_profiler ); / Check for link state change */ if ( events & VMXNET3_ECR_LINK ) {
[-] [+]	Changed	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/hci/commands/ping_cmd.c ^
@@ -48,6 +48,10 @@ unsigned int size; /** Timeout (in ms) / unsigned long timeout; + /* Number of packets to send (or zero for no limit) / + unsigned int count; + /* Inhibit output / + int quiet; }; /* "ping" option list / @@ -56,6 +60,10 @@ struct ping_options, size, parse_integer ), OPTION_DESC ( "timeout", 't', required_argument, struct ping_options, timeout, parse_timeout ), + OPTION_DESC ( "count", 'c', required_argument, + struct ping_options, count, parse_integer ), + OPTION_DESC ( "quiet", 'q', no_argument, + struct ping_options, quiet, parse_flag ), }; /* "ping" command descriptor / @@ -87,7 +95,8 @@ hostname = argv[optind]; / Ping */ - if ( ( rc = ping ( hostname, opts.timeout, opts.size ) ) != 0 ) + if ( ( rc = ping ( hostname, opts.timeout, opts.size, + opts.count, opts.quiet ) ) != 0 ) return rc; return 0;
[-] [+]	Changed	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/include/assert.h ^
@@ -20,6 +20,8 @@ extern unsigned int assertion_failures; +#define ASSERTED ( ASSERTING && ( assertion_failures != 0 ) ) + /** printf() for assertions * * This function exists so that the assert() macro can expand to
[-] [+]	Changed	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/include/ipxe/device.h ^
@@ -63,6 +63,9 @@ /** Xen bus type / #define BUS_TYPE_XEN 8 +/* Hyper-V bus type / +#define BUS_TYPE_HV 9 + /* A hardware device / struct device { /* Name / @@ -93,6 +96,8 @@ struct device dev; /* Root device driver / struct root_driver driver; + /** Driver-private data / + void priv; }; /** A root device driver / @@ -123,6 +128,27 @@ /* Declare a root device / #define __root_device __table_entry ( ROOT_DEVICES, 01 ) +/* + * Set root device driver-private data + * + * @v rootdev Root device + * @v priv Private data + / +static inline void rootdev_set_drvdata ( struct root_device rootdev, + void priv ){ + rootdev->priv = priv; +} + +/* + * Get root device driver-private data + * + * @v rootdev Root device + * @ret priv Private data + / +static inline void rootdev_get_drvdata ( struct root_device rootdev ) { + return rootdev->priv; +} + extern int device_keep_count; /*
[-] [+]	Changed	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/include/ipxe/errfile.h ^
@@ -157,6 +157,7 @@ #define ERRFILE_snp ( ERRFILE_DRIVER \| 0x00680000 ) #define ERRFILE_netfront ( ERRFILE_DRIVER \| 0x00690000 ) #define ERRFILE_nii ( ERRFILE_DRIVER \| 0x006a0000 ) +#define ERRFILE_netvsc ( ERRFILE_DRIVER \| 0x006b0000 ) #define ERRFILE_scsi ( ERRFILE_DRIVER \| 0x00700000 ) #define ERRFILE_arbel ( ERRFILE_DRIVER \| 0x00710000 ) @@ -227,6 +228,7 @@ #define ERRFILE_ping ( ERRFILE_NET \| 0x003a0000 ) #define ERRFILE_dhcpv6 ( ERRFILE_NET \| 0x003b0000 ) #define ERRFILE_nfs_uri ( ERRFILE_NET \| 0x003c0000 ) +#define ERRFILE_rndis ( ERRFILE_NET \| 0x003d0000 ) #define ERRFILE_image ( ERRFILE_IMAGE \| 0x00000000 ) #define ERRFILE_elf ( ERRFILE_IMAGE \| 0x00010000 ) @@ -308,6 +310,7 @@ #define ERRFILE_xengrant ( ERRFILE_OTHER \| 0x00440000 ) #define ERRFILE_efi_utils ( ERRFILE_OTHER \| 0x00450000 ) #define ERRFILE_efi_wrap ( ERRFILE_OTHER \| 0x00460000 ) +#define ERRFILE_vmbus ( ERRFILE_OTHER \| 0x00470000 ) /** @} */
[-] [+]	Added	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/include/ipxe/hyperv.h ^
@@ -0,0 +1,232 @@ +#ifndef _IPXE_HYPERV_H +#define _IPXE_HYPERV_H + +/** @file + * + * Hyper-V interface + * + / + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> +#include <ipxe/io.h> + +/* Hyper-V interface identification / +#define HV_INTERFACE_ID 0x31237648 / "Hv#1" / + +/* Guest OS identity for iPXE + * + * This field comprises: + * + * Bit 63 : set to 1 to indicate an open source OS + * Bits 62:56 : OS Type + * Bits 55:48 : OS ID + * Bits 47:16 : Version + * Bits 15:0 : Build number + * + * There appears to be no central registry for the "OS Type". The + * specification states that "Linux is 0x100", and the FreeBSD source + * states that "FreeBSD is 0x200". Both of these statements are + * actually referring to the combined "OS Type" and "OS ID" field. + * + * We choose to use 0x98ae: this is generated by setting bit 63 (to + * indicate an open source OS) and setting the OS Type+ID equal to the + * PnP vendor ID used in romprefix.S. No version information or build + * number is included. + / +#define HV_GUEST_OS_ID_IPXE ( ( 1ULL << 63 ) \| ( 0x18aeULL << 48 ) ) + +/* Enable hypercall page / +#define HV_HYPERCALL_ENABLE 0x00000001UL + +/* Enable SynIC / +#define HV_SCONTROL_ENABLE 0x00000001UL + +/* Enable SynIC event flags / +#define HV_SIEFP_ENABLE 0x00000001UL + +/* Enable SynIC messages / +#define HV_SIMP_ENABLE 0x00000001UL + +/* Perform implicit EOI upon synthetic interrupt delivery / +#define HV_SINT_AUTO_EOI 0x00020000UL + +/* Mask synthetic interrupt / +#define HV_SINT_MASKED 0x00010000UL + +/* Synthetic interrupt vector / +#define HV_SINT_VECTOR(x) ( (x) << 0 ) + +/* Synthetic interrupt vector mask / +#define HV_SINT_VECTOR_MASK HV_SINT_VECTOR ( 0xff ) + +/* Post message / +#define HV_POST_MESSAGE 0x005c + +/* A posted message + * + * This is the input parameter list for the HvPostMessage hypercall. + / +struct hv_post_message { + /* Connection ID / + uint32_t id; + /* Padding / + uint32_t reserved; + /* Type / + uint32_t type; + /* Length of message / + uint32_t len; + /* Message / + uint8_t data[240]; +} __attribute__ (( packed )); + +/* A received message + * + * This is the HV_MESSAGE structure from the Hypervisor Top-Level + * Functional Specification. The field order given in the + * documentation is incorrect. + / +struct hv_message { + /* Type / + uint32_t type; + /* Length of message / + uint8_t len; + /* Flags / + uint8_t flags; + /* Padding / + uint16_t reserved; + /* Origin / + uint64_t origin; + /* Message / + uint8_t data[240]; +} __attribute__ (( packed )); + +/* Signal event / +#define HV_SIGNAL_EVENT 0x005d + +/* A signalled event / +struct hv_signal_event { + /* Connection ID / + uint32_t id; + /* Flag number / + uint16_t flag; + /* Reserved / + uint16_t reserved; +} __attribute__ (( packed )); + +/* A received event / +struct hv_event { + /* Event flags / + uint8_t flags[256]; +} __attribute__ (( packed )); + +/* A monitor trigger group + * + * This is the HV_MONITOR_TRIGGER_GROUP structure from the Hypervisor + * Top-Level Functional Specification. + / +struct hv_monitor_trigger { + /* Pending events / + uint32_t pending; + /* Armed events / + uint32_t armed; +} __attribute__ (( packed )); + +/* A monitor parameter set + * + * This is the HV_MONITOR_PARAMETER structure from the Hypervisor + * Top-Level Functional Specification. + / +struct hv_monitor_parameter { + /* Connection ID / + uint32_t id; + /* Flag number / + uint16_t flag; + /* Reserved / + uint16_t reserved; +} __attribute__ (( packed )); + +/* A monitor page + * + * This is the HV_MONITOR_PAGE structure from the Hypervisor Top-Level + * Functional Specification. + / +struct hv_monitor { + /* Flags / + uint32_t flags; + /* Reserved / + uint8_t reserved_a[4]; + /* Trigger groups / + struct hv_monitor_trigger trigger[4]; + /* Reserved / + uint8_t reserved_b[536]; + /* Latencies / + uint16 latency[4][32]; + /* Reserved / + uint8_t reserved_c[256]; + /* Parameters / + struct hv_monitor_parameter param[4][32]; + /* Reserved / + uint8_t reserved_d[1984]; +} __attribute__ (( packed )); + +/* A synthetic interrupt controller / +struct hv_synic { + /* Message page / + struct hv_message message; + /** Event flag page / + struct hv_event event; +}; + +/** A message buffer / +union hv_message_buffer { + /* Posted message / + struct hv_post_message posted; + /* Received message / + struct hv_message received; + /* Signalled event / + struct hv_signal_event signalled; +}; + +/* A Hyper-V hypervisor / +struct hv_hypervisor { + /* Hypercall page / + void hypercall; + /** Synthetic interrupt controller (SynIC) / + struct hv_synic synic; + /* Message buffer / + union hv_message_buffer message; + /** Virtual machine bus / + struct vmbus vmbus; +}; + +#include <bits/hyperv.h> + +/** + * Calculate the number of pages covering an address range + * + * @v data Start of data + * @v len Length of data (must be non-zero) + * @ret pfn_count Number of pages covered + / +static inline unsigned int hv_pfn_count ( physaddr_t data, size_t len ) { + unsigned int first_pfn = ( data / PAGE_SIZE ); + unsigned int last_pfn = ( ( data + len - 1 ) / PAGE_SIZE ); + + return ( last_pfn - first_pfn + 1 ); +} + +extern __attribute__ (( sentinel )) int +hv_alloc_pages ( struct hv_hypervisor hv, ... ); +extern __attribute__ (( sentinel )) void +hv_free_pages ( struct hv_hypervisor hv, ... ); +extern void hv_enable_sint ( struct hv_hypervisor hv, unsigned int sintx ); +extern void hv_disable_sint ( struct hv_hypervisor hv, unsigned int sintx ); +extern int hv_post_message ( struct hv_hypervisor hv, unsigned int id, + unsigned int type, const void data, size_t len ); +extern int hv_wait_for_message ( struct hv_hypervisor hv, unsigned int sintx ); +extern int hv_signal_event ( struct hv_hypervisor hv, unsigned int id, + unsigned int flag ); + +#endif / _IPXE_HYPERV_H */
[-] [+]	Changed	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/include/ipxe/iobuf.h ^
@@ -217,5 +217,6 @@ extern void iob_pad ( struct io_buffer iobuf, size_t min_len ); extern int iob_ensure_headroom ( struct io_buffer iobuf, size_t len ); extern struct io_buffer * iob_concatenate ( struct list_head list ); +extern struct io_buffer iob_split ( struct io_buffer iobuf, size_t len ); #endif / _IPXE_IOBUF_H */
[-] [+]	Changed	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/include/ipxe/list.h ^
@@ -69,6 +69,8 @@ #define list_add( new, head ) do { \ list_check ( (head) ); \ extern_list_add ( (new), (head) ); \ + list_check ( (head) ); \ + list_check ( (new) ); \ } while ( 0 ) static inline void inline_list_add ( struct list_head new, struct list_head head ) { @@ -91,6 +93,8 @@ #define list_add_tail( new, head ) do { \ list_check ( (head) ); \ extern_list_add_tail ( (new), (head) ); \ + list_check ( (head) ); \ + list_check ( (new) ); \ } while ( 0 ) static inline void inline_list_add_tail ( struct list_head new, struct list_head head ) {
[-] [+]	Changed	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/include/ipxe/netdevice.h ^
@@ -36,13 +36,12 @@ /** Maximum length of a link-layer header * - * The longest currently-supported link-layer header is for 802.11: a - * 24-byte frame header plus an 8-byte 802.3 LLC/SNAP header, plus a - * possible 4-byte VLAN header. (The IPoIB link-layer pseudo-header - * doesn't actually include link-layer addresses; see ipoib.c for - * details.) + * The longest currently-supported link-layer header is for RNDIS: an + * 8-byte RNDIS header, a 32-byte RNDIS packet message header, a + * 14-byte Ethernet header and a possible 4-byte VLAN header. Round + * up to 64 bytes. / -#define MAX_LL_HEADER_LEN 36 +#define MAX_LL_HEADER_LEN 64 /* Maximum length of a network-layer address */ #define MAX_NET_ADDR_LEN 16
[-] [+]	Changed	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/include/ipxe/pinger.h ^
@@ -15,6 +15,7 @@ extern int create_pinger ( struct interface job, const char hostname, unsigned long timeout, size_t len, + unsigned int count, void ( * callback ) ( struct sockaddr *peer, unsigned int sequence, size_t len,
[-] [+]	Added	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/include/ipxe/rndis.h ^
@@ -0,0 +1,368 @@ +#ifndef _IPXE_RNDIS_H +#define _IPXE_RNDIS_H + +/** @file + * + * Remote Network Driver Interface Specification + * + / + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <stdint.h> +#include <ipxe/netdevice.h> +#include <ipxe/iobuf.h> + +/* Maximum time to wait for a transaction to complete + * + * This is a policy decision. + / +#define RNDIS_MAX_WAIT_MS 1000 + +/* RNDIS message header / +struct rndis_header { + /* Message type / + uint32_t type; + /* Message length / + uint32_t len; +} __attribute__ (( packed )); + +/* RNDIS initialise message / +#define RNDIS_INITIALISE_MSG 0x00000002UL + +/* RNDIS initialise message / +struct rndis_initialise_message { + /* Request ID / + uint32_t id; + /* Major version / + uint32_t major; + /* Minor version / + uint32_t minor; + /* Maximum transfer size / + uint32_t mtu; +} __attribute__ (( packed )); + +/* Request ID used for initialisation + * + * This is a policy decision. + / +#define RNDIS_INIT_ID 0xe110e110UL + +/* RNDIS major version / +#define RNDIS_VERSION_MAJOR 1 + +/* RNDIS minor version / +#define RNDIS_VERSION_MINOR 0 + +/* RNDIS maximum transfer size + * + * This is a policy decision. + / +#define RNDIS_MTU 2048 + +/* RNDIS initialise completion / +#define RNDIS_INITIALISE_CMPLT 0x80000002UL + +/* RNDIS initialise completion / +struct rndis_initialise_completion { + /* Request ID / + uint32_t id; + /* Status / + uint32_t status; + /* Major version / + uint32_t major; + /* Minor version / + uint32_t minor; + /* Device flags / + uint32_t flags; + /* Medium / + uint32_t medium; + /* Maximum packets per transfer / + uint32_t max_pkts; + /* Maximum transfer size / + uint32_t mtu; + /* Packet alignment factor / + uint32_t align; + /* Reserved / + uint32_t reserved; +} __attribute__ (( packed )); + +/* RNDIS halt message / +#define RNDIS_HALT_MSG 0x00000003UL + +/* RNDIS halt message / +struct rndis_halt_message { + /* Request ID / + uint32_t id; +} __attribute__ (( packed )); + +/* RNDIS query OID message / +#define RNDIS_QUERY_MSG 0x00000004UL + +/* RNDIS set OID message / +#define RNDIS_SET_MSG 0x00000005UL + +/* RNDIS query or set OID message / +struct rndis_oid_message { + /* Request ID / + uint32_t id; + /* Object ID / + uint32_t oid; + /* Information buffer length / + uint32_t len; + /* Information buffer offset / + uint32_t offset; + /* Reserved / + uint32_t reserved; +} __attribute__ (( packed )); + +/* RNDIS query OID completion / +#define RNDIS_QUERY_CMPLT 0x80000004UL + +/* RNDIS query OID completion / +struct rndis_query_completion { + /* Request ID / + uint32_t id; + /* Status / + uint32_t status; + /* Information buffer length / + uint32_t len; + /* Information buffer offset / + uint32_t offset; +} __attribute__ (( packed )); + +/* RNDIS set OID completion / +#define RNDIS_SET_CMPLT 0x80000005UL + +/* RNDIS set OID completion / +struct rndis_set_completion { + /* Request ID / + uint32_t id; + /* Status / + uint32_t status; +} __attribute__ (( packed )); + +/* RNDIS reset message / +#define RNDIS_RESET_MSG 0x00000006UL + +/* RNDIS reset message / +struct rndis_reset_message { + /* Reserved / + uint32_t reserved; +} __attribute__ (( packed )); + +/* RNDIS reset completion / +#define RNDIS_RESET_CMPLT 0x80000006UL + +/* RNDIS reset completion / +struct rndis_reset_completion { + /* Status / + uint32_t status; + /* Addressing reset / + uint32_t addr; +} __attribute__ (( packed )); + +/* RNDIS indicate status message / +#define RNDIS_INDICATE_STATUS_MSG 0x00000007UL + +/* RNDIS diagnostic information / +struct rndis_diagnostic_info { + /* Status / + uint32_t status; + /* Error offset / + uint32_t offset; +} __attribute__ (( packed )); + +/* RNDIS indicate status message / +struct rndis_indicate_status_message { + /* Status / + uint32_t status; + /* Status buffer length / + uint32_t len; + /* Status buffer offset / + uint32_t offset; + /* Diagnostic information (optional) / + struct rndis_diagnostic_info diag[0]; +} __attribute__ (( packed )); + +/* RNDIS status codes / +enum rndis_status { + /* Device is connected to a network medium / + RNDIS_STATUS_MEDIA_CONNECT = 0x4001000bUL, + /* Device is disconnected from the medium / + RNDIS_STATUS_MEDIA_DISCONNECT = 0x4001000cUL, + /* Unknown start-of-day status code / + RNDIS_STATUS_WTF_WORLD = 0x40020006UL, +}; + +/* RNDIS keepalive message / +#define RNDIS_KEEPALIVE_MSG 0x00000008UL + +/* RNDIS keepalive message / +struct rndis_keepalive_message { + /* Request ID / + uint32_t id; +} __attribute__ (( packed )); + +/* RNDIS keepalive completion / +#define RNDIS_KEEPALIVE_CMPLT 0x80000008UL + +/* RNDIS keepalive completion / +struct rndis_keepalive_completion { + /* Request ID / + uint32_t id; + /* Status / + uint32_t status; +} __attribute__ (( packed )); + +/* RNDIS packet message / +#define RNDIS_PACKET_MSG 0x00000001UL + +/* RNDIS packet field / +struct rndis_packet_field { + /* Offset / + uint32_t offset; + /* Length / + uint32_t len; +} __attribute__ (( packed )); + +/* RNDIS packet message / +struct rndis_packet_message { + /* Data / + struct rndis_packet_field data; + /* Out-of-band data records / + struct rndis_packet_field oob; + /* Number of out-of-band data records / + uint32_t oob_count; + /* Per-packet information record / + struct rndis_packet_field ppi; + /* Reserved / + uint32_t reserved; +} __attribute__ (( packed )); + +/* RNDIS packet record / +struct rndis_packet_record { + /* Length / + uint32_t len; + /* Type / + uint32_t type; + /* Offset / + uint32_t offset; +} __attribute__ (( packed )); + +/* OID for packet filter / +#define RNDIS_OID_GEN_CURRENT_PACKET_FILTER 0x0001010eUL + +/* Packet filter bits / +enum rndis_packet_filter { + /* Unicast packets / + RNDIS_FILTER_UNICAST = 0x00000001UL, + /* Multicast packets / + RNDIS_FILTER_MULTICAST = 0x00000002UL, + /* All multicast packets / + RNDIS_FILTER_ALL_MULTICAST = 0x00000004UL, + /* Broadcast packets / + RNDIS_FILTER_BROADCAST = 0x00000008UL, + /* All packets / + RNDIS_FILTER_PROMISCUOUS = 0x00000020UL +}; + +/* OID for media status / +#define RNDIS_OID_GEN_MEDIA_CONNECT_STATUS 0x00010114UL + +/* OID for permanent MAC address / +#define RNDIS_OID_802_3_PERMANENT_ADDRESS 0x01010101UL + +/* OID for current MAC address / +#define RNDIS_OID_802_3_CURRENT_ADDRESS 0x01010102UL + +struct rndis_device; + +/* RNDIS device operations / +struct rndis_operations { + /* + * Open RNDIS device + * + * @v rndis RNDIS device + * @ret rc Return status code + / + int ( open ) ( struct rndis_device rndis ); + /* + * Close RNDIS device + * + * @v rndis RNDIS device + / + void ( close ) ( struct rndis_device rndis ); + /* + * Transmit packet + * + * @v rndis RNDIS device + * @v iobuf I/O buffer + * @ret rc Return status code + * + * If this method returns success then the RNDIS device must + * eventually report completion via rndis_tx_complete(). + / + int ( transmit ) ( struct rndis_device rndis, + struct io_buffer iobuf ); + /** + * Poll for completed and received packets + * + * @v rndis RNDIS device + / + void ( poll ) ( struct rndis_device rndis ); +}; + +/* An RNDIS device / +struct rndis_device { + /* Network device / + struct net_device netdev; + /** Device name / + const char name; + /** RNDIS operations / + struct rndis_operations op; + /** Driver private data / + void priv; + + /** Request ID for current blocking request / + unsigned int wait_id; + /* Return status code for current blocking request / + int wait_rc; +}; + +/* + * Initialise an RNDIS device + * + * @v rndis RNDIS device + * @v op RNDIS device operations + / +static inline void rndis_init ( struct rndis_device rndis, + struct rndis_operations op ) { + + rndis->op = op; +} + +extern void rndis_tx_complete_err ( struct rndis_device rndis, + struct io_buffer iobuf, int rc ); +extern int rndis_tx_defer ( struct rndis_device rndis, + struct io_buffer iobuf ); +extern void rndis_rx ( struct rndis_device rndis, struct io_buffer iobuf ); + +extern struct rndis_device alloc_rndis ( size_t priv_len ); +extern int register_rndis ( struct rndis_device rndis ); +extern void unregister_rndis ( struct rndis_device rndis ); +extern void free_rndis ( struct rndis_device rndis ); + +/* + * Complete message transmission + * + * @v rndis RNDIS device + * @v iobuf I/O buffer + / +static inline void rndis_tx_complete ( struct rndis_device rndis, + struct io_buffer iobuf ) { + + rndis_tx_complete_err ( rndis, iobuf, 0 ); +} + +#endif / _IPXE_RNDIS_H */
[-] [+]	Added	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/include/ipxe/vmbus.h ^
@@ -0,0 +1,634 @@ +#ifndef _IPXE_VMBUS_H +#define _IPXE_VMBUS_H + +/** @file + * + * Hyper-V virtual machine bus + * + / + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include <byteswap.h> +#include <ipxe/uuid.h> +#include <ipxe/device.h> +#include <ipxe/tables.h> +#include <ipxe/uaccess.h> +#include <ipxe/iobuf.h> +#include <ipxe/hyperv.h> + +/* VMBus message connection ID / +#define VMBUS_MESSAGE_ID 1 + +/* VMBus event connection ID / +#define VMBUS_EVENT_ID 2 + +/* VMBus message type / +#define VMBUS_MESSAGE_TYPE 1 + +/* VMBus message synthetic interrupt / +#define VMBUS_MESSAGE_SINT 2 + +/* VMBus version number / +union vmbus_version { + /* Raw version / + uint32_t raw; + /* Major/minor version / + struct { + /* Minor version / + uint16_t minor; + /* Major version / + uint16_t major; + }; +} __attribute__ (( packed )); + +/* Known VMBus protocol versions / +enum vmbus_raw_version { + /* Windows Server 2008 / + VMBUS_VERSION_WS2008 = ( ( 0 << 16 ) \| ( 13 << 0 ) ), + /* Windows 7 / + VMBUS_VERSION_WIN7 = ( ( 1 << 16 ) \| ( 1 << 0 ) ), + /* Windows 8 / + VMBUS_VERSION_WIN8 = ( ( 2 << 16 ) \| ( 4 << 0 ) ), + /* Windows 8.1 / + VMBUS_VERSION_WIN8_1 = ( ( 3 << 16 ) \| ( 0 << 0 ) ), +}; + +/* Guest physical address range descriptor / +struct vmbus_gpa_range { + /* Byte count / + uint32_t len; + /* Starting byte offset / + uint32_t offset; + /* Page frame numbers + * + * The length of this array is implied by the byte count and + * starting offset. + / + uint64_t pfn[0]; +} __attribute__ (( packed )); + +/* VMBus message header / +struct vmbus_message_header { + /* Message type / + uint32_t type; + /* Reserved / + uint32_t reserved; +} __attribute__ (( packed )); + +/* VMBus message types / +enum vmbus_message_type { + VMBUS_OFFER_CHANNEL = 1, + VMBUS_REQUEST_OFFERS = 3, + VMBUS_ALL_OFFERS_DELIVERED = 4, + VMBUS_OPEN_CHANNEL = 5, + VMBUS_OPEN_CHANNEL_RESULT = 6, + VMBUS_CLOSE_CHANNEL = 7, + VMBUS_GPADL_HEADER = 8, + VMBUS_GPADL_CREATED = 10, + VMBUS_GPADL_TEARDOWN = 11, + VMBUS_GPADL_TORNDOWN = 12, + VMBUS_INITIATE_CONTACT = 14, + VMBUS_VERSION_RESPONSE = 15, + VMBUS_UNLOAD = 16, + VMBUS_UNLOAD_RESPONSE = 17, +}; + +/* VMBus "offer channel" message / +struct vmbus_offer_channel { + /* Message header / + struct vmbus_message_header header; + /* Channel type / + union uuid type; + /* Channel instance / + union uuid instance; + /* Reserved / + uint8_t reserved_a[16]; + /* Flags / + uint16_t flags; + /* Reserved / + uint8_t reserved_b[2]; + /* User data / + uint8_t data[120]; + /* Reserved / + uint8_t reserved_c[4]; + /* Channel ID / + uint32_t channel; + /* Monitor ID / + uint8_t monitor; + /* Monitor exists / + uint8_t monitored; + /* Reserved / + uint8_t reserved[2]; + /* Connection ID / + uint32_t connection; +} __attribute__ (( packed )); + +/* VMBus "open channel" message / +struct vmbus_open_channel { + /* Message header / + struct vmbus_message_header header; + /* Channel ID / + uint32_t channel; + /* Open ID / + uint32_t id; + /* Ring buffer GPADL ID / + uint32_t gpadl; + /* Reserved / + uint32_t reserved; + /* Outbound ring buffer size (in pages) / + uint32_t out_pages; + /* User-specific data / + uint8_t data[120]; +} __attribute__ (( packed )); + +/* VMBus "open channel result" message / +struct vmbus_open_channel_result { + /* Message header / + struct vmbus_message_header header; + /* Channel ID / + uint32_t channel; + /* Open ID / + uint32_t id; + /* Status / + uint32_t status; +} __attribute__ (( packed )); + +/* VMBus "close channel" message / +struct vmbus_close_channel { + /* Message header / + struct vmbus_message_header header; + /* Channel ID / + uint32_t channel; +} __attribute__ (( packed )); + +/* VMBus "GPADL header" message / +struct vmbus_gpadl_header { + /* Message header / + struct vmbus_message_header header; + /* Channel ID / + uint32_t channel; + /* GPADL ID / + uint32_t gpadl; + /* Length of range descriptors / + uint16_t range_len; + /* Number of range descriptors / + uint16_t range_count; + /* Range descriptors / + struct vmbus_gpa_range range[0]; +} __attribute__ (( packed )); + +/* VMBus "GPADL created" message / +struct vmbus_gpadl_created { + /* Message header / + struct vmbus_message_header header; + /* Channel ID / + uint32_t channel; + /* GPADL ID / + uint32_t gpadl; + /* Creation status / + uint32_t status; +} __attribute__ (( packed )); + +/* VMBus "GPADL teardown" message / +struct vmbus_gpadl_teardown { + /* Message header / + struct vmbus_message_header header; + /* Channel ID / + uint32_t channel; + /* GPADL ID / + uint32_t gpadl; +} __attribute__ (( packed )); + +/* VMBus "GPADL torndown" message / +struct vmbus_gpadl_torndown { + /* Message header / + struct vmbus_message_header header; + /* GPADL ID / + uint32_t gpadl; +} __attribute__ (( packed )); + +/* VMBus "initiate contact" message / +struct vmbus_initiate_contact { + /* Message header / + struct vmbus_message_header header; + /* Requested version / + union vmbus_version version; + /* Target virtual CPU / + uint32_t vcpu; + /* Interrupt page base address / + uint64_t intr; + /* Parent to child monitor page base address / + uint64_t monitor_in; + /* Child to parent monitor page base address / + uint64_t monitor_out; +} __attribute__ (( packed )); + +/* VMBus "version response" message / +struct vmbus_version_response { + /* Message header / + struct vmbus_message_header header; + /* Version is supported / + uint8_t supported; + /* Reserved / + uint8_t reserved[3]; + /* Version / + union vmbus_version version; +} __attribute__ (( packed )); + +/* VMBus message / +union vmbus_message { + /* Common message header / + struct vmbus_message_header header; + /* "Offer channel" message / + struct vmbus_offer_channel offer; + /* "Open channel" message / + struct vmbus_open_channel open; + /* "Open channel result" message / + struct vmbus_open_channel_result opened; + /* "Close channel" message / + struct vmbus_close_channel close; + /* "GPADL header" message / + struct vmbus_gpadl_header gpadlhdr; + /* "GPADL created" message / + struct vmbus_gpadl_created created; + /* "GPADL teardown" message / + struct vmbus_gpadl_teardown teardown; + /* "GPADL torndown" message / + struct vmbus_gpadl_torndown torndown; + /* "Initiate contact" message / + struct vmbus_initiate_contact initiate; + /* "Version response" message / + struct vmbus_version_response version; +}; + +/* VMBus packet header / +struct vmbus_packet_header { + /* Type / + uint16_t type; + /* Length of packet header (in quadwords) / + uint16_t hdr_qlen; + /* Length of packet (in quadwords) / + uint16_t qlen; + /* Flags / + uint16_t flags; + /* Transaction ID + * + * This is an opaque token: we therefore treat it as + * native-endian and don't worry about byte-swapping. + / + uint64_t xid; +} __attribute__ (( packed )); + +/* VMBus packet types / +enum vmbus_packet_type { + VMBUS_DATA_INBAND = 6, + VMBUS_DATA_XFER_PAGES = 7, + VMBUS_DATA_GPA_DIRECT = 9, + VMBUS_CANCELLATION = 10, + VMBUS_COMPLETION = 11, +}; + +/* VMBus packet flags / +enum vmbus_packet_flags { + VMBUS_COMPLETION_REQUESTED = 0x0001, +}; + +/* VMBus GPA direct header / +struct vmbus_gpa_direct_header { + /* Packet header / + struct vmbus_packet_header header; + /* Reserved / + uint32_t reserved; + /* Number of range descriptors / + uint32_t range_count; + /* Range descriptors / + struct vmbus_gpa_range range[0]; +} __attribute__ (( packed )); + +/* VMBus transfer page range / +struct vmbus_xfer_page_range { + /* Length / + uint32_t len; + /* Offset / + uint32_t offset; +} __attribute__ (( packed )); + +/* VMBus transfer page header / +struct vmbus_xfer_page_header { + /* Packet header / + struct vmbus_packet_header header; + /* Page set ID / + uint16_t pageset; + /* Sender owns page set / + uint8_t owner; + /* Reserved / + uint8_t reserved; + /* Number of range descriptors / + uint32_t range_count; + /* Range descriptors / + struct vmbus_xfer_page_range range[0]; +} __attribute__ (( packed )); + +/* Maximum expected size of VMBus packet header / +#define VMBUS_PACKET_MAX_HEADER_LEN 64 + +/* VMBus maximum-sized packet header / +union vmbus_packet_header_max { + /* Common header / + struct vmbus_packet_header header; + /* GPA direct header / + struct vmbus_gpa_direct_header gpa; + /* Transfer page header / + struct vmbus_xfer_page_header xfer; + /* Padding to maximum supported size / + uint8_t padding[VMBUS_PACKET_MAX_HEADER_LEN]; +} __attribute__ (( packed )); + +/* VMBus packet footer / +struct vmbus_packet_footer { + /* Reserved / + uint32_t reserved; + /* Producer index of the first byte of the packet / + uint32_t prod; +} __attribute__ (( packed )); + +/* VMBus ring buffer + * + * This is the structure of the each of the ring buffers created when + * a VMBus channel is opened. + / +struct vmbus_ring { + /* Producer index (modulo ring length) / + uint32_t prod; + /* Consumer index (modulo ring length) / + uint32_t cons; + /* Interrupt mask / + uint32_t intr_mask; + /* Reserved / + uint8_t reserved[4084]; + /* Ring buffer contents / + uint8_t data[0]; +} __attribute__ (( packed )); + +/* VMBus interrupt page / +struct vmbus_interrupt { + /* Inbound interrupts / + uint8_t in[ PAGE_SIZE / 2 ]; + /* Outbound interrupts / + uint8_t out[ PAGE_SIZE / 2 ]; +} __attribute__ (( packed )); + +/* A virtual machine bus / +struct vmbus { + /* Interrupt page / + struct vmbus_interrupt intr; + /** Inbound notifications / + struct hv_monitor monitor_in; + /** Outbound notifications / + struct hv_monitor monitor_out; + /** Received message buffer / + const union vmbus_message message; +}; + +struct vmbus_device; + +/** VMBus channel operations / +struct vmbus_channel_operations { + /* + * Handle received control packet + * + * @v vmdev VMBus device + * @v xid Transaction ID + * @v data Data + * @v len Length of data + * @ret rc Return status code + / + int ( recv_control ) ( struct vmbus_device vmdev, uint64_t xid, + const void data, size_t len ); + /** + * Handle received data packet + * + * @v vmdev VMBus device + * @v xid Transaction ID + * @v data Data + * @v len Length of data + * @v list List of I/O buffers + * @ret rc Return status code + * + * This function takes ownership of the I/O buffer. It should + * eventually call vmbus_send_completion() to indicate to the + * host that the buffer can be reused. + / + int ( recv_data ) ( struct vmbus_device vmdev, uint64_t xid, + const void data, size_t len, + struct list_head list ); + /* + * Handle received completion packet + * + * @v vmdev VMBus device + * @v xid Transaction ID + * @v data Data + * @v len Length of data + * @ret rc Return status code + / + int ( recv_completion ) ( struct vmbus_device vmdev, uint64_t xid, + const void data, size_t len ); + /** + * Handle received cancellation packet + * + * @v vmdev VMBus device + * @v xid Transaction ID + * @ret rc Return status code + / + int ( recv_cancellation ) ( struct vmbus_device vmdev, + uint64_t xid ); +}; + +struct vmbus_xfer_pages; + +/* VMBus transfer page set operations / +struct vmbus_xfer_pages_operations { + /* + * Copy data from transfer page + * + * @v pages Transfer page set + * @v data Data buffer + * @v offset Offset within page set + * @v len Length within page set + * @ret rc Return status code + / + int ( copy ) ( struct vmbus_xfer_pages pages, void data, + size_t offset, size_t len ); +}; + +/** VMBus transfer page set / +struct vmbus_xfer_pages { + /* List of all transfer page sets / + struct list_head list; + /* Page set ID (in protocol byte order) / + uint16_t pageset; + /* Page set operations / + struct vmbus_xfer_pages_operations op; +}; + +/** A VMBus device / +struct vmbus_device { + /* Generic iPXE device / + struct device dev; + /* Hyper-V hypervisor / + struct hv_hypervisor hv; + + /** Channel ID / + unsigned int channel; + /* Monitor ID / + unsigned int monitor; + /* Signal channel + * + * @v vmdev VMBus device + / + void ( signal ) ( struct vmbus_device vmdev ); + + /* Outbound ring buffer length / + uint32_t out_len; + /* Inbound ring buffer length / + uint32_t in_len; + /* Outbound ring buffer / + struct vmbus_ring out; + /** Inbound ring buffer / + struct vmbus_ring in; + /** Ring buffer GPADL ID / + unsigned int gpadl; + + /* Channel operations / + struct vmbus_channel_operations op; + /** Maximum expected data packet length / + size_t mtu; + /* Packet buffer / + void packet; + /** List of transfer page sets / + struct list_head pages; + + /* Driver / + struct vmbus_driver driver; + /** Driver-private data / + void priv; +}; + +/** A VMBus device driver / +struct vmbus_driver { + /* Name / + const char name; + /** Device type / + union uuid type; + /* Probe device + * + * @v vmdev VMBus device + * @ret rc Return status code + / + int ( probe ) ( struct vmbus_device vmdev ); + /* Remove device + * + * @v vmdev VMBus device + / + void ( remove ) ( struct vmbus_device vmdev ); +}; + +/* VMBus device driver table / +#define VMBUS_DRIVERS __table ( struct vmbus_driver, "vmbus_drivers" ) + +/* Declare a VMBus device driver / +#define __vmbus_driver __table_entry ( VMBUS_DRIVERS, 01 ) + +/* + * Set VMBus device driver-private data + * + * @v vmdev VMBus device + * @v priv Private data + / +static inline void vmbus_set_drvdata ( struct vmbus_device vmdev, void priv ){ + vmdev->priv = priv; +} + +/* + * Get VMBus device driver-private data + * + * @v vmdev VMBus device + * @ret priv Private data + / +static inline void vmbus_get_drvdata ( struct vmbus_device vmdev ) { + return vmdev->priv; +} + +/* Construct VMBus type / +#define VMBUS_TYPE( a, b, c, d, e0, e1, e2, e3, e4, e5 ) { \ + .canonical = { \ + cpu_to_le32 ( a ), cpu_to_le16 ( b ), \ + cpu_to_le16 ( c ), cpu_to_be16 ( d ), \ + { e0, e1, e2, e3, e4, e5 } \ + } } + +/* + * Check if data is present in ring buffer + * + * @v vmdev VMBus device + * @v has_data Data is present + / +static inline __attribute__ (( always_inline )) int +vmbus_has_data ( struct vmbus_device vmdev ) { + + return ( vmdev->in->prod != vmdev->in->cons ); +} + +/** + * Register transfer page set + * + * @v vmdev VMBus device + * @v pages Transfer page set + * @ret rc Return status code + / +static inline __attribute__ (( always_inline )) int +vmbus_register_pages ( struct vmbus_device vmdev, + struct vmbus_xfer_pages pages ) { + + list_add ( &pages->list, &vmdev->pages ); + return 0; +} + +/* + * Unregister transfer page set + * + * @v vmdev VMBus device + * @v pages Transfer page set + / +static inline __attribute__ (( always_inline )) void +vmbus_unregister_pages ( struct vmbus_device vmdev, + struct vmbus_xfer_pages pages ) { + + list_check_contains_entry ( pages, &vmdev->pages, list ); + list_del ( &pages->list ); +} + +extern int vmbus_establish_gpadl ( struct vmbus_device vmdev, userptr_t data, + size_t len ); +extern int vmbus_gpadl_teardown ( struct vmbus_device vmdev, + unsigned int gpadl ); +extern int vmbus_open ( struct vmbus_device vmdev, + struct vmbus_channel_operations op, + size_t out_len, size_t in_len, size_t mtu ); +extern void vmbus_close ( struct vmbus_device vmdev ); +extern int vmbus_send_control ( struct vmbus_device vmdev, uint64_t xid, + const void data, size_t len ); +extern int vmbus_send_data ( struct vmbus_device vmdev, uint64_t xid, + const void data, size_t len, + struct io_buffer iobuf ); +extern int vmbus_send_completion ( struct vmbus_device vmdev, uint64_t xid, + const void data, size_t len ); +extern int vmbus_send_cancellation ( struct vmbus_device vmdev, uint64_t xid ); +extern int vmbus_poll ( struct vmbus_device vmdev ); +extern void vmbus_dump_channel ( struct vmbus_device vmdev ); + +extern int vmbus_probe ( struct hv_hypervisor hv, struct device parent ); +extern void vmbus_remove ( struct hv_hypervisor hv, struct device parent ); + +#endif /* _IPXE_VMBUS_H */
[-] [+]	Changed	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/include/usr/pingmgmt.h ^
@@ -11,6 +11,7 @@ #include <stdint.h> -extern int ping ( const char hostname, unsigned long timeout, size_t len ); +extern int ping ( const char hostname, unsigned long timeout, size_t len, + unsigned int count, int quiet ); #endif /* _USR_PINGMGMT_H */
[-] [+]	Added	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/interface/hyperv ^
+(directory)
[-] [+]	Added	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/interface/hyperv/vmbus.c ^
@@ -0,0 +1,1329 @@ +/* + * Copyright (C) 2014 Michael Brown <mbrown@fensystems.co.uk>. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA. + / + +FILE_LICENCE ( GPL2_OR_LATER ); + +/* @file + * + * Hyper-V virtual machine bus + * + / + +#include <stdint.h> +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include <errno.h> +#include <assert.h> +#include <byteswap.h> +#include <ipxe/nap.h> +#include <ipxe/malloc.h> +#include <ipxe/iobuf.h> +#include <ipxe/hyperv.h> +#include <ipxe/vmbus.h> + +/* VMBus initial GPADL ID + * + * This is an opaque value with no meaning. The Linux kernel uses + * 0xe1e10. + / +#define VMBUS_GPADL_MAGIC 0x18ae0000 + +/* + * Post message + * + * @v hv Hyper-V hypervisor + * @v header Message header + * @v len Length of message (including header) + * @ret rc Return status code + / +static int vmbus_post_message ( struct hv_hypervisor hv, + const struct vmbus_message_header header, + size_t len ) { + struct vmbus vmbus = hv->vmbus; + int rc; + + /* Post message / + if ( ( rc = hv_post_message ( hv, VMBUS_MESSAGE_ID, VMBUS_MESSAGE_TYPE, + header, len ) ) != 0 ) { + DBGC ( vmbus, "VMBUS %p could not post message: %s\n", + vmbus, strerror ( rc ) ); + return rc; + } + + return 0; +} + +/* + * Post empty message + * + * @v hv Hyper-V hypervisor + * @v type Message type + * @ret rc Return status code + / +static int vmbus_post_empty_message ( struct hv_hypervisor hv, + unsigned int type ) { + struct vmbus_message_header header = { .type = cpu_to_le32 ( type ) }; + + return vmbus_post_message ( hv, &header, sizeof ( header ) ); +} + +/** + * Wait for received message + * + * @v hv Hyper-V hypervisor + * @ret rc Return status code + / +static int vmbus_wait_for_message ( struct hv_hypervisor hv ) { + struct vmbus vmbus = hv->vmbus; + int rc; + + / Wait for message / + if ( ( rc = hv_wait_for_message ( hv, VMBUS_MESSAGE_SINT ) ) != 0 ) { + DBGC ( vmbus, "VMBUS %p failed waiting for message: %s\n", + vmbus, strerror ( rc ) ); + return rc; + } + + / Sanity check / + if ( hv->message->received.type != cpu_to_le32 ( VMBUS_MESSAGE_TYPE ) ){ + DBGC ( vmbus, "VMBUS %p invalid message type %d\n", + vmbus, le32_to_cpu ( hv->message->received.type ) ); + return -EINVAL; + } + + return 0; +} + +/* + * Initiate contact + * + * @v hv Hyper-V hypervisor + * @v raw VMBus protocol (raw) version + * @ret rc Return status code + / +static int vmbus_initiate_contact ( struct hv_hypervisor hv, + unsigned int raw ) { + struct vmbus vmbus = hv->vmbus; + const struct vmbus_version_response version = &vmbus->message->version; + struct vmbus_initiate_contact initiate; + int rc; + + /* Construct message / + memset ( &initiate, 0, sizeof ( initiate ) ); + initiate.header.type = cpu_to_le32 ( VMBUS_INITIATE_CONTACT ); + initiate.version.raw = cpu_to_le32 ( raw ); + initiate.intr = virt_to_phys ( vmbus->intr ); + initiate.monitor_in = virt_to_phys ( vmbus->monitor_in ); + initiate.monitor_out = virt_to_phys ( vmbus->monitor_out ); + + / Post message / + if ( ( rc = vmbus_post_message ( hv, &initiate.header, + sizeof ( initiate ) ) ) != 0 ) + return rc; + + / Wait for response / + if ( ( rc = vmbus_wait_for_message ( hv ) ) != 0 ) + return rc; + + / Check response / + if ( version->header.type != cpu_to_le32 ( VMBUS_VERSION_RESPONSE ) ) { + DBGC ( vmbus, "VMBUS %p unexpected version response type %d\n", + vmbus, le32_to_cpu ( version->header.type ) ); + return -EPROTO; + } + if ( ! version->supported ) { + DBGC ( vmbus, "VMBUS %p requested version not supported\n", + vmbus ); + return -ENOTSUP; + } + if ( version->version.raw != cpu_to_le32 ( raw ) ) { + DBGC ( vmbus, "VMBUS %p unexpected version %d.%d\n", + vmbus, le16_to_cpu ( version->version.major ), + le16_to_cpu ( version->version.minor ) ); + return -EPROTO; + } + + DBGC ( vmbus, "VMBUS %p initiated contact using version %d.%d\n", + vmbus, le16_to_cpu ( version->version.major ), + le16_to_cpu ( version->version.minor ) ); + return 0; +} + +/* + * Terminate contact + * + * @v hv Hyper-V hypervisor + * @ret rc Return status code + / +static int vmbus_unload ( struct hv_hypervisor hv ) { + struct vmbus vmbus = hv->vmbus; + const struct vmbus_message_header header = &vmbus->message->header; + int rc; + + /* Post message / + if ( ( rc = vmbus_post_empty_message ( hv, VMBUS_UNLOAD ) ) != 0 ) + return rc; + + / Wait for response / + if ( ( rc = vmbus_wait_for_message ( hv ) ) != 0 ) + return rc; + + / Check response / + if ( header->type != cpu_to_le32 ( VMBUS_UNLOAD_RESPONSE ) ) { + DBGC ( vmbus, "VMBUS %p unexpected unload response type %d\n", + vmbus, le32_to_cpu ( header->type ) ); + return -EPROTO; + } + + return 0; +} + +/* + * Negotiate protocol version + * + * @v hv Hyper-V hypervisor + * @ret rc Return status code + / +static int vmbus_negotiate_version ( struct hv_hypervisor hv ) { + int rc; + + /* We require the ability to disconnect from and reconnect to + * VMBus; if we don't have this then there is no (viable) way + * for a loaded operating system to continue to use any VMBus + * devices. (There is also a small but non-zero risk that the + * host will continue to write to our interrupt and monitor + * pages, since the VMBUS_UNLOAD message in earlier versions + * is essentially a no-op.) + * + * This requires us to ensure that the host supports protocol + * version 3.0 (VMBUS_VERSION_WIN8_1). However, we can't + * actually _use_ protocol version 3.0, since doing so causes + * an iSCSI-booted Windows Server 2012 R2 VM to crash due to a + * NULL pointer dereference in vmbus.sys. + * + * To work around this problem, we first ensure that we can + * connect using protocol v3.0, then disconnect and reconnect + * using the oldest known protocol. + / + + / Initiate contact to check for required protocol support / + if ( ( rc = vmbus_initiate_contact ( hv, VMBUS_VERSION_WIN8_1 ) ) != 0 ) + return rc; + + / Terminate contact / + if ( ( rc = vmbus_unload ( hv ) ) != 0 ) + return rc; + + / Reinitiate contact using the oldest known protocol version / + if ( ( rc = vmbus_initiate_contact ( hv, VMBUS_VERSION_WS2008 ) ) != 0 ) + return rc; + + return 0; +} + +/* + * Establish GPA descriptor list + * + * @v vmdev VMBus device + * @v data Data buffer + * @v len Length of data buffer + * @ret gpadl GPADL ID, or negative error + / +int vmbus_establish_gpadl ( struct vmbus_device vmdev, userptr_t data, + size_t len ) { + struct hv_hypervisor hv = vmdev->hv; + struct vmbus vmbus = hv->vmbus; + physaddr_t addr = user_to_phys ( data, 0 ); + unsigned int pfn_count = hv_pfn_count ( addr, len ); + struct { + struct vmbus_gpadl_header gpadlhdr; + struct vmbus_gpa_range range; + uint64_t pfn[pfn_count]; + } __attribute__ (( packed )) gpadlhdr; + const struct vmbus_gpadl_created created = &vmbus->message->created; + static unsigned int gpadl = VMBUS_GPADL_MAGIC; + unsigned int i; + int rc; + + / Allocate GPADL ID / + gpadl++; + + / Construct message / + memset ( &gpadlhdr, 0, sizeof ( gpadlhdr ) ); + gpadlhdr.gpadlhdr.header.type = cpu_to_le32 ( VMBUS_GPADL_HEADER ); + gpadlhdr.gpadlhdr.channel = cpu_to_le32 ( vmdev->channel ); + gpadlhdr.gpadlhdr.gpadl = cpu_to_le32 ( gpadl ); + gpadlhdr.gpadlhdr.range_len = + cpu_to_le16 ( ( sizeof ( gpadlhdr.range ) + + sizeof ( gpadlhdr.pfn ) ) ); + gpadlhdr.gpadlhdr.range_count = cpu_to_le16 ( 1 ); + gpadlhdr.range.len = cpu_to_le32 ( len ); + gpadlhdr.range.offset = cpu_to_le32 ( addr & ( PAGE_SIZE - 1 ) ); + for ( i = 0 ; i < pfn_count ; i++ ) + gpadlhdr.pfn[i] = ( ( addr / PAGE_SIZE ) + i ); + + / Post message / + if ( ( rc = vmbus_post_message ( hv, &gpadlhdr.gpadlhdr.header, + sizeof ( gpadlhdr ) ) ) != 0 ) + return rc; + + / Wait for response / + if ( ( rc = vmbus_wait_for_message ( hv ) ) != 0 ) + return rc; + + / Check response / + if ( created->header.type != cpu_to_le32 ( VMBUS_GPADL_CREATED ) ) { + DBGC ( vmdev, "VMBUS %s unexpected GPADL response type %d\n", + vmdev->dev.name, le32_to_cpu ( created->header.type ) ); + return -EPROTO; + } + if ( created->channel != cpu_to_le32 ( vmdev->channel ) ) { + DBGC ( vmdev, "VMBUS %s unexpected GPADL channel %d\n", + vmdev->dev.name, le32_to_cpu ( created->channel ) ); + return -EPROTO; + } + if ( created->gpadl != cpu_to_le32 ( gpadl ) ) { + DBGC ( vmdev, "VMBUS %s unexpected GPADL ID %#08x\n", + vmdev->dev.name, le32_to_cpu ( created->gpadl ) ); + return -EPROTO; + } + if ( created->status != 0 ) { + DBGC ( vmdev, "VMBUS %s GPADL creation failed: %#08x\n", + vmdev->dev.name, le32_to_cpu ( created->status ) ); + return -EPROTO; + } + + DBGC ( vmdev, "VMBUS %s GPADL %#08x is [%08lx,%08lx)\n", + vmdev->dev.name, gpadl, addr, ( addr + len ) ); + return gpadl; +} + +/* + * Tear down GPA descriptor list + * + * @v vmdev VMBus device + * @v gpadl GPADL ID + * @ret rc Return status code + / +int vmbus_gpadl_teardown ( struct vmbus_device vmdev, unsigned int gpadl ) { + struct hv_hypervisor hv = vmdev->hv; + struct vmbus vmbus = hv->vmbus; + struct vmbus_gpadl_teardown teardown; + const struct vmbus_gpadl_torndown torndown = &vmbus->message->torndown; + int rc; + + / Construct message / + memset ( &teardown, 0, sizeof ( teardown ) ); + teardown.header.type = cpu_to_le32 ( VMBUS_GPADL_TEARDOWN ); + teardown.channel = cpu_to_le32 ( vmdev->channel ); + teardown.gpadl = cpu_to_le32 ( gpadl ); + + / Post message / + if ( ( rc = vmbus_post_message ( hv, &teardown.header, + sizeof ( teardown ) ) ) != 0 ) + return rc; + + / Wait for response / + if ( ( rc = vmbus_wait_for_message ( hv ) ) != 0 ) + return rc; + + / Check response / + if ( torndown->header.type != cpu_to_le32 ( VMBUS_GPADL_TORNDOWN ) ) { + DBGC ( vmdev, "VMBUS %s unexpected GPADL response type %d\n", + vmdev->dev.name, le32_to_cpu ( torndown->header.type ) ); + return -EPROTO; + } + if ( torndown->gpadl != cpu_to_le32 ( gpadl ) ) { + DBGC ( vmdev, "VMBUS %s unexpected GPADL ID %#08x\n", + vmdev->dev.name, le32_to_cpu ( torndown->gpadl ) ); + return -EPROTO; + } + + return 0; +} + +/* + * Open VMBus channel + * + * @v vmdev VMBus device + * @v op Channel operations + * @v out_len Outbound ring buffer length + * @v in_len Inbound ring buffer length + * @v mtu Maximum expected data packet length (including headers) + * @ret rc Return status code + * + * Both outbound and inbound ring buffer lengths must be a power of + * two and a multiple of PAGE_SIZE. The requirement to be a power of + * two is a policy decision taken to simplify the ring buffer indexing + * logic. + / +int vmbus_open ( struct vmbus_device vmdev, + struct vmbus_channel_operations op, + size_t out_len, size_t in_len, size_t mtu ) { + struct hv_hypervisor hv = vmdev->hv; + struct vmbus vmbus = hv->vmbus; + struct vmbus_open_channel open; + const struct vmbus_open_channel_result opened = + &vmbus->message->opened; + size_t len; + void ring; + void packet; + int gpadl; + uint32_t open_id; + int rc; + + /* Sanity checks / + assert ( ( out_len % PAGE_SIZE ) == 0 ); + assert ( ( out_len & ( out_len - 1 ) ) == 0 ); + assert ( ( in_len % PAGE_SIZE ) == 0 ); + assert ( ( in_len & ( in_len - 1 ) ) == 0 ); + assert ( mtu >= ( sizeof ( struct vmbus_packet_header ) + + sizeof ( struct vmbus_packet_footer ) ) ); + + / Allocate packet buffer / + packet = malloc ( mtu ); + if ( ! packet ) { + rc = -ENOMEM; + goto err_alloc_packet; + } + + / Allocate ring buffer / + len = ( sizeof ( vmdev->out ) + out_len + + sizeof ( vmdev->in ) + in_len ); + assert ( ( len % PAGE_SIZE ) == 0 ); + ring = malloc_dma ( len, PAGE_SIZE ); + if ( ! ring ) { + rc = -ENOMEM; + goto err_alloc_ring; + } + memset ( ring, 0, len ); + + / Establish GPADL for ring buffer / + gpadl = vmbus_establish_gpadl ( vmdev, virt_to_user ( ring ), len ); + if ( gpadl < 0 ) { + rc = gpadl; + goto err_establish; + } + + / Construct message / + memset ( &open, 0, sizeof ( open ) ); + open.header.type = cpu_to_le32 ( VMBUS_OPEN_CHANNEL ); + open.channel = cpu_to_le32 ( vmdev->channel ); + open_id = random(); + open.id = open_id; / Opaque random value: endianness irrelevant / + open.gpadl = cpu_to_le32 ( gpadl ); + open.out_pages = ( ( sizeof ( vmdev->out ) / PAGE_SIZE ) + + ( out_len / PAGE_SIZE ) ); + + /* Post message / + if ( ( rc = vmbus_post_message ( hv, &open.header, + sizeof ( open ) ) ) != 0 ) + return rc; + + / Wait for response / + if ( ( rc = vmbus_wait_for_message ( hv ) ) != 0 ) + return rc; + + / Check response / + if ( opened->header.type != cpu_to_le32 ( VMBUS_OPEN_CHANNEL_RESULT ) ){ + DBGC ( vmdev, "VMBUS %s unexpected open response type %d\n", + vmdev->dev.name, le32_to_cpu ( opened->header.type ) ); + return -EPROTO; + } + if ( opened->channel != cpu_to_le32 ( vmdev->channel ) ) { + DBGC ( vmdev, "VMBUS %s unexpected opened channel %#08x\n", + vmdev->dev.name, le32_to_cpu ( opened->channel ) ); + return -EPROTO; + } + if ( opened->id != open_id / Non-endian / ) { + DBGC ( vmdev, "VMBUS %s unexpected open ID %#08x\n", + vmdev->dev.name, le32_to_cpu ( opened->id ) ); + return -EPROTO; + } + if ( opened->status != 0 ) { + DBGC ( vmdev, "VMBUS %s open failed: %#08x\n", + vmdev->dev.name, le32_to_cpu ( opened->status ) ); + return -EPROTO; + } + + / Store channel parameters / + vmdev->out_len = out_len; + vmdev->in_len = in_len; + vmdev->out = ring; + vmdev->in = ( ring + sizeof ( vmdev->out ) + out_len ); + vmdev->gpadl = gpadl; + vmdev->op = op; + vmdev->mtu = mtu; + vmdev->packet = packet; + + DBGC ( vmdev, "VMBUS %s channel GPADL %#08x ring " + "[%#08lx,%#08lx,%#08lx)\n", vmdev->dev.name, vmdev->gpadl, + virt_to_phys ( vmdev->out ), virt_to_phys ( vmdev->in ), + ( virt_to_phys ( vmdev->out ) + len ) ); + return 0; + + vmbus_gpadl_teardown ( vmdev, vmdev->gpadl ); + err_establish: + free_dma ( ring, len ); + err_alloc_ring: + free ( packet ); + err_alloc_packet: + return rc; +} + +/** + * Close VMBus channel + * + * @v vmdev VMBus device + / +void vmbus_close ( struct vmbus_device vmdev ) { + struct hv_hypervisor hv = vmdev->hv; + struct vmbus_close_channel close; + size_t len; + int rc; + + / Construct message / + memset ( &close, 0, sizeof ( close ) ); + close.header.type = cpu_to_le32 ( VMBUS_CLOSE_CHANNEL ); + close.channel = cpu_to_le32 ( vmdev->channel ); + + / Post message / + if ( ( rc = vmbus_post_message ( hv, &close.header, + sizeof ( close ) ) ) != 0 ) { + DBGC ( vmdev, "VMBUS %s failed to close: %s\n", + vmdev->dev.name, strerror ( rc ) ); + / Continue to attempt to tear down GPADL, so that our + * memory is no longer accessible by the remote VM. + / + } + + / Tear down GPADL / + if ( ( rc = vmbus_gpadl_teardown ( vmdev, + vmdev->gpadl ) ) != 0 ) { + DBGC ( vmdev, "VMBUS %s failed to tear down channel GPADL: " + "%s\n", vmdev->dev.name, strerror ( rc ) ); + / We can't prevent the remote VM from continuing to + * access this memory, so leak it. + / + return; + } + + / Free ring buffer / + len = ( sizeof ( vmdev->out ) + vmdev->out_len + + sizeof ( vmdev->in ) + vmdev->in_len ); + free_dma ( vmdev->out, len ); + vmdev->out = NULL; + vmdev->in = NULL; + + / Free packet buffer / + free ( vmdev->packet ); + vmdev->packet = NULL; + + DBGC ( vmdev, "VMBUS %s closed\n", vmdev->dev.name ); +} + +/* + * Signal channel via monitor page + * + * @v vmdev VMBus device + / +static void vmbus_signal_monitor ( struct vmbus_device vmdev ) { + struct hv_hypervisor hv = vmdev->hv; + struct vmbus vmbus = hv->vmbus; + struct hv_monitor_trigger trigger; + unsigned int group; + unsigned int bit; + + / Set bit in monitor trigger group / + group = ( vmdev->monitor / ( 8 sizeof ( trigger->pending ) )); + bit = ( vmdev->monitor % ( 8 * sizeof ( trigger->pending ) ) ); + trigger = &vmbus->monitor_out->trigger[group]; + hv_set_bit ( trigger, bit ); +} + +/** + * Signal channel via hypervisor event + * + * @v vmdev VMBus device + / +static void vmbus_signal_event ( struct vmbus_device vmdev ) { + struct hv_hypervisor hv = vmdev->hv; + int rc; + + / Signal hypervisor event / + if ( ( rc = hv_signal_event ( hv, VMBUS_EVENT_ID, 0 ) ) != 0 ) { + DBGC ( vmdev, "VMBUS %s could not signal event: %s\n", + vmdev->dev.name, strerror ( rc ) ); + return; + } +} + +/* + * Fill outbound ring buffer + * + * @v vmdev VMBus device + * @v prod Producer index + * @v data Data + * @v len Length + * @ret prod New producer index + * + * The caller must ensure that there is sufficient space in the ring + * buffer. + / +static size_t vmbus_produce ( struct vmbus_device vmdev, size_t prod, + const void data, size_t len ) { + size_t first; + size_t second; + + / Determine fragment lengths / + first = ( vmdev->out_len - prod ); + if ( first > len ) + first = len; + second = ( len - first ); + + / Copy fragment(s) / + memcpy ( &vmdev->out->data[prod], data, first ); + if ( second ) + memcpy ( &vmdev->out->data[0], ( data + first ), second ); + + return ( ( prod + len ) & ( vmdev->out_len - 1 ) ); +} + +/* + * Consume inbound ring buffer + * + * @v vmdev VMBus device + * @v cons Consumer index + * @v data Data buffer, or NULL + * @v len Length to consume + * @ret cons New consumer index + / +static size_t vmbus_consume ( struct vmbus_device vmdev, size_t cons, + void data, size_t len ) { + size_t first; + size_t second; + + / Determine fragment lengths / + first = ( vmdev->in_len - cons ); + if ( first > len ) + first = len; + second = ( len - first ); + + / Copy fragment(s) / + memcpy ( data, &vmdev->in->data[cons], first ); + if ( second ) + memcpy ( ( data + first ), &vmdev->in->data[0], second ); + + return ( ( cons + len ) & ( vmdev->in_len - 1 ) ); +} + +/* + * Send packet via ring buffer + * + * @v vmdev VMBus device + * @v header Packet header + * @v data Data + * @v len Length of data + * @ret rc Return status code + * + * Send a packet via the outbound ring buffer. All fields in the + * packet header must be filled in, with the exception of the total + * packet length. + / +static int vmbus_send ( struct vmbus_device vmdev, + struct vmbus_packet_header header, + const void data, size_t len ) { + struct hv_hypervisor hv = vmdev->hv; + struct vmbus vmbus = hv->vmbus; + static uint8_t padding[ 8 - 1 ]; + struct vmbus_packet_footer footer; + size_t header_len; + size_t pad_len; + size_t footer_len; + size_t ring_len; + size_t cons; + size_t prod; + size_t old_prod; + size_t fill; + + /* Sanity check / + assert ( vmdev->out != NULL ); + + / Calculate lengths / + header_len = ( le16_to_cpu ( header->hdr_qlen ) 8 ); + pad_len = ( ( -len ) & ( 8 - 1 ) ); + footer_len = sizeof ( footer ); + ring_len = ( header_len + len + pad_len + footer_len ); + + /* Check that we have enough room in the outbound ring buffer / + cons = le32_to_cpu ( vmdev->out->cons ); + prod = le32_to_cpu ( vmdev->out->prod ); + old_prod = prod; + fill = ( ( prod - cons ) & ( vmdev->out_len - 1 ) ); + if ( ( fill + ring_len ) >= vmdev->out_len ) { + DBGC ( vmdev, "VMBUS %s ring buffer full\n", vmdev->dev.name ); + return -ENOBUFS; + } + + / Complete header / + header->qlen = cpu_to_le16 ( ( ring_len - footer_len ) / 8 ); + + / Construct footer / + footer.reserved = 0; + footer.prod = vmdev->out->prod; + + / Copy packet to buffer / + DBGC2 ( vmdev, "VMBUS %s sending:\n", vmdev->dev.name ); + DBGC2_HDA ( vmdev, prod, header, header_len ); + prod = vmbus_produce ( vmdev, prod, header, header_len ); + DBGC2_HDA ( vmdev, prod, data, len ); + prod = vmbus_produce ( vmdev, prod, data, len ); + prod = vmbus_produce ( vmdev, prod, padding, pad_len ); + DBGC2_HDA ( vmdev, prod, &footer, sizeof ( footer ) ); + prod = vmbus_produce ( vmdev, prod, &footer, sizeof ( footer ) ); + assert ( ( ( prod - old_prod ) & ( vmdev->out_len - 1 ) ) == ring_len ); + + / Update producer index / + wmb(); + vmdev->out->prod = cpu_to_le32 ( prod ); + + / Return if we do not need to signal the host. This follows + * the logic of hv_need_to_signal() in the Linux driver. + / + mb(); + if ( vmdev->out->intr_mask ) + return 0; + rmb(); + cons = le32_to_cpu ( vmdev->out->cons ); + if ( cons != old_prod ) + return 0; + + / Set channel bit in interrupt page / + hv_set_bit ( vmbus->intr->out, vmdev->channel ); + + / Signal the host / + vmdev->signal ( vmdev ); + + return 0; +} + +/* + * Send control packet via ring buffer + * + * @v vmdev VMBus device + * @v xid Transaction ID (or zero to not request completion) + * @v data Data + * @v len Length of data + * @ret rc Return status code + * + * Send data using a VMBUS_DATA_INBAND packet. + / +int vmbus_send_control ( struct vmbus_device vmdev, uint64_t xid, + const void data, size_t len ) { + struct vmbus_packet_header header = vmdev->packet; + + /* Construct header in packet buffer / + assert ( header != NULL ); + header->type = cpu_to_le16 ( VMBUS_DATA_INBAND ); + header->hdr_qlen = cpu_to_le16 ( sizeof ( header ) / 8 ); + header->flags = ( xid ? + cpu_to_le16 ( VMBUS_COMPLETION_REQUESTED ) : 0 ); + header->xid = xid; /* Non-endian / + + return vmbus_send ( vmdev, header, data, len ); +} + +/* + * Send data packet via ring buffer + * + * @v vmdev VMBus device + * @v xid Transaction ID + * @v data Data + * @v len Length of data + * @v iobuf I/O buffer + * @ret rc Return status code + * + * Send data using a VMBUS_DATA_GPA_DIRECT packet. The caller is + * responsible for ensuring that the I/O buffer remains untouched + * until the corresponding completion has been received. + / +int vmbus_send_data ( struct vmbus_device vmdev, uint64_t xid, + const void data, size_t len, struct io_buffer iobuf ) { + physaddr_t addr = virt_to_phys ( iobuf->data ); + unsigned int pfn_count = hv_pfn_count ( addr, iob_len ( iobuf ) ); + struct { + struct vmbus_gpa_direct_header gpa; + struct vmbus_gpa_range range; + uint64_t pfn[pfn_count]; + } __attribute__ (( packed )) header = vmdev->packet; + unsigned int i; + + / Sanity check / + assert ( header != NULL ); + assert ( sizeof ( header ) <= vmdev->mtu ); + + /* Construct header in packet buffer / + header->gpa.header.type = cpu_to_le16 ( VMBUS_DATA_GPA_DIRECT ); + header->gpa.header.hdr_qlen = cpu_to_le16 ( sizeof ( header ) / 8 ); + header->gpa.header.flags = cpu_to_le16 ( VMBUS_COMPLETION_REQUESTED ); + header->gpa.header.xid = xid; /* Non-endian / + header->gpa.range_count = 1; + header->range.len = cpu_to_le32 ( iob_len ( iobuf ) ); + header->range.offset = cpu_to_le32 ( addr & ( PAGE_SIZE - 1 ) ); + for ( i = 0 ; i < pfn_count ; i++ ) + header->pfn[i] = ( ( addr / PAGE_SIZE ) + i ); + + return vmbus_send ( vmdev, &header->gpa.header, data, len ); +} + +/* + * Send completion packet via ring buffer + * + * @v vmdev VMBus device + * @v xid Transaction ID + * @v data Data + * @v len Length of data + * @ret rc Return status code + * + * Send data using a VMBUS_COMPLETION packet. + / +int vmbus_send_completion ( struct vmbus_device vmdev, uint64_t xid, + const void data, size_t len ) { + struct vmbus_packet_header header = vmdev->packet; + + /* Construct header in packet buffer / + assert ( header != NULL ); + header->type = cpu_to_le16 ( VMBUS_COMPLETION ); + header->hdr_qlen = cpu_to_le16 ( sizeof ( header ) / 8 ); + header->flags = 0; + header->xid = xid; /* Non-endian / + + return vmbus_send ( vmdev, header, data, len ); +} + +/* + * Send cancellation packet via ring buffer + * + * @v vmdev VMBus device + * @v xid Transaction ID + * @ret rc Return status code + * + * Send data using a VMBUS_CANCELLATION packet. + / +int vmbus_send_cancellation ( struct vmbus_device vmdev, uint64_t xid ) { + struct vmbus_packet_header header = vmdev->packet; + + / Construct header in packet buffer / + assert ( header != NULL ); + header->type = cpu_to_le16 ( VMBUS_CANCELLATION ); + header->hdr_qlen = cpu_to_le16 ( sizeof ( header ) / 8 ); + header->flags = 0; + header->xid = xid; /* Non-endian / + + return vmbus_send ( vmdev, header, NULL, 0 ); +} + +/* + * Get transfer page set from pageset ID + * + * @v vmdev VMBus device + * @v pageset Page set ID (in protocol byte order) + * @ret pages Page set, or NULL if not found + / +static struct vmbus_xfer_pages vmbus_xfer_pages ( struct vmbus_device vmdev, + uint16_t pageset ) { + struct vmbus_xfer_pages pages; + + /* Locate page set / + list_for_each_entry ( pages, &vmdev->pages, list ) { + if ( pages->pageset == pageset ) + return pages; + } + + DBGC ( vmdev, "VMBUS %s unrecognised page set ID %#04x\n", + vmdev->dev.name, le16_to_cpu ( pageset ) ); + return NULL; +} + +/* + * Construct I/O buffer list from transfer pages + * + * @v vmdev VMBus device + * @v header Transfer page header + * @v list I/O buffer list to populate + * @ret rc Return status code + / +static int vmbus_xfer_page_iobufs ( struct vmbus_device vmdev, + struct vmbus_packet_header header, + struct list_head list ) { + struct vmbus_xfer_page_header page_header = + container_of ( header, struct vmbus_xfer_page_header, header ); + struct vmbus_xfer_pages pages; + struct io_buffer iobuf; + struct io_buffer tmp; + size_t len; + size_t offset; + unsigned int range_count; + unsigned int i; + int rc; + + /* Sanity check / + assert ( header->type == cpu_to_le16 ( VMBUS_DATA_XFER_PAGES ) ); + + / Locate page set / + pages = vmbus_xfer_pages ( vmdev, page_header->pageset ); + if ( ! pages ) { + rc = -ENOENT; + goto err_pages; + } + + / Allocate and populate I/O buffers / + range_count = le32_to_cpu ( page_header->range_count ); + for ( i = 0 ; i < range_count ; i++ ) { + + / Parse header / + len = le32_to_cpu ( page_header->range[i].len ); + offset = le32_to_cpu ( page_header->range[i].offset ); + + / Allocate I/O buffer / + iobuf = alloc_iob ( len ); + if ( ! iobuf ) { + DBGC ( vmdev, "VMBUS %s could not allocate %zd-byte " + "I/O buffer\n", vmdev->dev.name, len ); + rc = -ENOMEM; + goto err_alloc; + } + + / Add I/O buffer to list / + list_add ( &iobuf->list, list ); + + / Populate I/O buffer / + if ( ( rc = pages->op->copy ( pages, iob_put ( iobuf, len ), + offset, len ) ) != 0 ) { + DBGC ( vmdev, "VMBUS %s could not populate I/O buffer " + "range [%zd,%zd): %s\n", + vmdev->dev.name, offset, len, strerror ( rc ) ); + goto err_copy; + } + } + + return 0; + + err_copy: + err_alloc: + list_for_each_entry_safe ( iobuf, tmp, list, list ) { + list_del ( &iobuf->list ); + free_iob ( iobuf ); + } + err_pages: + return rc; +} + +/* + * Poll ring buffer + * + * @v vmdev VMBus device + * @ret rc Return status code + / +int vmbus_poll ( struct vmbus_device vmdev ) { + struct vmbus_packet_header header = vmdev->packet; + struct list_head list; + void data; + size_t header_len; + size_t len; + size_t footer_len; + size_t ring_len; + size_t cons; + size_t old_cons; + uint64_t xid; + int rc; + + /* Sanity checks / + assert ( vmdev->packet != NULL ); + assert ( vmdev->in != NULL ); + + / Return immediately if buffer is empty / + if ( ! vmbus_has_data ( vmdev ) ) + return 0; + cons = le32_to_cpu ( vmdev->in->cons ); + old_cons = cons; + + / Consume (start of) header / + cons = vmbus_consume ( vmdev, cons, header, sizeof ( header ) ); + + /* Parse and sanity check header / + header_len = ( le16_to_cpu ( header->hdr_qlen ) 8 ); + if ( header_len < sizeof ( header ) ) { + DBGC ( vmdev, "VMBUS %s received underlength header (%zd " + "bytes)\n", vmdev->dev.name, header_len ); + return -EINVAL; + } + len = ( ( le16_to_cpu ( header->qlen ) 8 ) - header_len ); + footer_len = sizeof ( struct vmbus_packet_footer ); + ring_len = ( header_len + len + footer_len ); + if ( ring_len > vmdev->mtu ) { + DBGC ( vmdev, "VMBUS %s received overlength packet (%zd " + "bytes)\n", vmdev->dev.name, ring_len ); + return -ERANGE; + } + xid = le64_to_cpu ( header->xid ); + + /* Consume remainder of packet / + cons = vmbus_consume ( vmdev, cons, + ( ( ( void ) header ) + sizeof ( header ) ), + ( ring_len - sizeof ( header ) ) ); + DBGC2 ( vmdev, "VMBUS %s received:\n", vmdev->dev.name ); + DBGC2_HDA ( vmdev, old_cons, header, ring_len ); + assert ( ( ( cons - old_cons ) & ( vmdev->in_len - 1 ) ) == ring_len ); + + /* Allocate I/O buffers, if applicable / + INIT_LIST_HEAD ( &list ); + if ( header->type == cpu_to_le16 ( VMBUS_DATA_XFER_PAGES ) ) { + if ( ( rc = vmbus_xfer_page_iobufs ( vmdev, header, + &list ) ) != 0 ) + return rc; + } + + / Update producer index / + rmb(); + vmdev->in->cons = cpu_to_le32 ( cons ); + + / Handle packet / + data = ( ( ( void ) header ) + header_len ); + switch ( header->type ) { + + case cpu_to_le16 ( VMBUS_DATA_INBAND ) : + if ( ( rc = vmdev->op->recv_control ( vmdev, xid, data, + len ) ) != 0 ) { + DBGC ( vmdev, "VMBUS %s could not handle control " + "packet: %s\n", + vmdev->dev.name, strerror ( rc ) ); + return rc; + } + break; + + case cpu_to_le16 ( VMBUS_DATA_XFER_PAGES ) : + if ( ( rc = vmdev->op->recv_data ( vmdev, xid, data, len, + &list ) ) != 0 ) { + DBGC ( vmdev, "VMBUS %s could not handle data packet: " + "%s\n", vmdev->dev.name, strerror ( rc ) ); + return rc; + } + break; + + case cpu_to_le16 ( VMBUS_COMPLETION ) : + if ( ( rc = vmdev->op->recv_completion ( vmdev, xid, data, + len ) ) != 0 ) { + DBGC ( vmdev, "VMBUS %s could not handle completion: " + "%s\n", vmdev->dev.name, strerror ( rc ) ); + return rc; + } + break; + + case cpu_to_le16 ( VMBUS_CANCELLATION ) : + if ( ( rc = vmdev->op->recv_cancellation ( vmdev, xid ) ) != 0){ + DBGC ( vmdev, "VMBUS %s could not handle cancellation: " + "%s\n", vmdev->dev.name, strerror ( rc ) ); + return rc; + } + break; + + default: + DBGC ( vmdev, "VMBUS %s unknown packet type %d\n", + vmdev->dev.name, le16_to_cpu ( header->type ) ); + return -ENOTSUP; + } + + return 0; +} + +/** + * Dump channel status (for debugging) + * + * @v vmdev VMBus device + / +void vmbus_dump_channel ( struct vmbus_device vmdev ) { + size_t out_prod = le32_to_cpu ( vmdev->out->prod ); + size_t out_cons = le32_to_cpu ( vmdev->out->cons ); + size_t in_prod = le32_to_cpu ( vmdev->in->prod ); + size_t in_cons = le32_to_cpu ( vmdev->in->cons ); + size_t in_len; + size_t first; + size_t second; + + /* Dump ring status / + DBGC ( vmdev, "VMBUS %s out %03zx:%03zx%s in %03zx:%03zx%s\n", + vmdev->dev.name, out_prod, out_cons, + ( vmdev->out->intr_mask ? "(m)" : "" ), in_prod, in_cons, + ( vmdev->in->intr_mask ? "(m)" : "" ) ); + + / Dump inbound ring contents, if any / + if ( in_prod != in_cons ) { + in_len = ( ( in_prod - in_cons ) & + ( vmdev->in_len - 1 ) ); + first = ( vmdev->in_len - in_cons ); + if ( first > in_len ) + first = in_len; + second = ( in_len - first ); + DBGC_HDA ( vmdev, in_cons, &vmdev->in->data[in_cons], first ); + DBGC_HDA ( vmdev, 0, &vmdev->in->data[0], second ); + } +} + +/* + * Find driver for VMBus device + * + * @v vmdev VMBus device + * @ret driver Driver, or NULL + / +static struct vmbus_driver vmbus_find_driver ( const union uuid type ) { + struct vmbus_driver vmdrv; + + for_each_table_entry ( vmdrv, VMBUS_DRIVERS ) { + if ( memcmp ( &vmdrv->type, type, sizeof ( type ) ) == 0 ) + return vmdrv; + } + return NULL; +} + +/* + * Probe channels + * + * @v hv Hyper-V hypervisor + * @v parent Parent device + * @ret rc Return status code + / +static int vmbus_probe_channels ( struct hv_hypervisor hv, + struct device parent ) { + struct vmbus vmbus = hv->vmbus; + const struct vmbus_message_header header = &vmbus->message->header; + const struct vmbus_offer_channel offer = &vmbus->message->offer; + const union uuid type; + struct vmbus_driver driver; + struct vmbus_device vmdev; + struct vmbus_device tmp; + unsigned int channel; + int rc; + + /* Post message / + if ( ( rc = vmbus_post_empty_message ( hv, VMBUS_REQUEST_OFFERS ) ) !=0) + goto err_post_message; + + / Collect responses / + while ( 1 ) { + + / Wait for response / + if ( ( rc = vmbus_wait_for_message ( hv ) ) != 0 ) + goto err_wait_for_message; + + / Handle response / + if ( header->type == cpu_to_le32 ( VMBUS_OFFER_CHANNEL ) ) { + + / Parse offer / + type = &offer->type; + channel = le32_to_cpu ( offer->channel ); + DBGC2 ( vmbus, "VMBUS %p offer %d type %s", + vmbus, channel, uuid_ntoa ( type ) ); + if ( offer->monitored ) + DBGC2 ( vmbus, " monitor %d", offer->monitor ); + DBGC2 ( vmbus, "\n" ); + + / Look for a driver / + driver = vmbus_find_driver ( type ); + if ( ! driver ) { + DBGC2 ( vmbus, "VMBUS %p has no driver for " + "type %s\n", vmbus, uuid_ntoa ( type )); + / Not a fatal error / + continue; + } + + / Allocate and initialise device / + vmdev = zalloc ( sizeof ( vmdev ) ); + if ( ! vmdev ) { + rc = -ENOMEM; + goto err_alloc_vmdev; + } + snprintf ( vmdev->dev.name, sizeof ( vmdev->dev.name ), + "vmbus:%02x", channel ); + vmdev->dev.desc.bus_type = BUS_TYPE_HV; + INIT_LIST_HEAD ( &vmdev->dev.children ); + list_add_tail ( &vmdev->dev.siblings, + &parent->children ); + vmdev->dev.parent = parent; + vmdev->hv = hv; + vmdev->channel = channel; + vmdev->monitor = offer->monitor; + vmdev->signal = ( offer->monitored ? + vmbus_signal_monitor : + vmbus_signal_event ); + INIT_LIST_HEAD ( &vmdev->pages ); + vmdev->driver = driver; + vmdev->dev.driver_name = driver->name; + DBGC ( vmdev, "VMBUS %s has driver \"%s\"\n", + vmdev->dev.name, vmdev->driver->name ); + + } else if ( header->type == + cpu_to_le32 ( VMBUS_ALL_OFFERS_DELIVERED ) ) { + + break; + + } else { + DBGC ( vmbus, "VMBUS %p unexpected offer response type " + "%d\n", vmbus, le32_to_cpu ( header->type ) ); + rc = -EPROTO; + goto err_unexpected_offer; + } + } + + /* Probe all devices. We do this only after completing + * enumeration since devices will need to send and receive + * VMBus messages. + / + list_for_each_entry ( vmdev, &parent->children, dev.siblings ) { + if ( ( rc = vmdev->driver->probe ( vmdev ) ) != 0 ) { + DBGC ( vmdev, "VMBUS %s could not probe: %s\n", + vmdev->dev.name, strerror ( rc ) ); + goto err_probe; + } + } + + return 0; + + err_probe: + / Remove driver from each device that was already probed / + list_for_each_entry_continue_reverse ( vmdev, &parent->children, + dev.siblings ) { + vmdev->driver->remove ( vmdev ); + } + err_unexpected_offer: + err_alloc_vmdev: + err_wait_for_message: + / Free any devices allocated (but potentially not yet probed) / + list_for_each_entry_safe ( vmdev, tmp, &parent->children, + dev.siblings ) { + list_del ( &vmdev->dev.siblings ); + free ( vmdev ); + } + err_post_message: + return rc; +} + +/* + * Remove channels + * + * @v hv Hyper-V hypervisor + * @v parent Parent device + / +static void vmbus_remove_channels ( struct hv_hypervisor hv __unused, + struct device parent ) { + struct vmbus_device vmdev; + struct vmbus_device tmp; + + / Remove devices / + list_for_each_entry_safe ( vmdev, tmp, &parent->children, + dev.siblings ) { + vmdev->driver->remove ( vmdev ); + assert ( list_empty ( &vmdev->dev.children ) ); + assert ( vmdev->out == NULL ); + assert ( vmdev->in == NULL ); + assert ( vmdev->packet == NULL ); + assert ( list_empty ( &vmdev->pages ) ); + list_del ( &vmdev->dev.siblings ); + free ( vmdev ); + } +} + +/* + * Probe Hyper-V virtual machine bus + * + * @v hv Hyper-V hypervisor + * @v parent Parent device + * @ret rc Return status code + / +int vmbus_probe ( struct hv_hypervisor hv, struct device parent ) { + struct vmbus vmbus; + int rc; + + /* Allocate and initialise structure / + vmbus = zalloc ( sizeof ( vmbus ) ); + if ( ! vmbus ) { + rc = -ENOMEM; + goto err_alloc; + } + hv->vmbus = vmbus; + + /* Initialise message buffer pointer + * + * We use a pointer to the fixed-size Hyper-V received message + * buffer. This allows us to access fields within received + * messages without first checking the message size: any + * fields beyond the end of the message will read as zero. + / + vmbus->message = ( ( void ) hv->message->received.data ); + assert ( sizeof ( vmbus->message ) <= + sizeof ( hv->message->received.data ) ); + + / Allocate interrupt and monitor pages / + if ( ( rc = hv_alloc_pages ( hv, &vmbus->intr, &vmbus->monitor_in, + &vmbus->monitor_out, NULL ) ) != 0 ) + goto err_alloc_pages; + + / Enable message interrupt / + hv_enable_sint ( hv, VMBUS_MESSAGE_SINT ); + + / Negotiate protocol version / + if ( ( rc = vmbus_negotiate_version ( hv ) ) != 0 ) + goto err_negotiate_version; + + / Enumerate channels / + if ( ( rc = vmbus_probe_channels ( hv, parent ) ) != 0 ) + goto err_probe_channels; + + return 0; + + vmbus_remove_channels ( hv, parent ); + err_probe_channels: + vmbus_unload ( hv ); + err_negotiate_version: + hv_disable_sint ( hv, VMBUS_MESSAGE_SINT ); + hv_free_pages ( hv, vmbus->intr, vmbus->monitor_in, vmbus->monitor_out, + NULL ); + err_alloc_pages: + free ( vmbus ); + err_alloc: + return rc; +} + +/* + * Remove Hyper-V virtual machine bus + * + * @v hv Hyper-V hypervisor + * @v parent Parent device + / +void vmbus_remove ( struct hv_hypervisor hv, struct device parent ) { + struct vmbus vmbus = hv->vmbus; + + vmbus_remove_channels ( hv, parent ); + vmbus_unload ( hv ); + hv_disable_sint ( hv, VMBUS_MESSAGE_SINT ); + hv_free_pages ( hv, vmbus->intr, vmbus->monitor_in, vmbus->monitor_out, + NULL ); + free ( vmbus ); +}
[-] [+]	Changed	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/net/netdevice.c ^
@@ -1080,7 +1080,7 @@ /* Discard first deferred packet / list_del ( &iobuf->list ); - free ( iobuf ); + free_iob ( iobuf ); / Report discard */ discarded++;
[-] [+]	Added	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/net/rndis.c ^
@@ -0,0 +1,1033 @@ +/* + * Copyright (C) 2014 Michael Brown <mbrown@fensystems.co.uk>. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA. + / + +FILE_LICENCE ( GPL2_OR_LATER ); + +/* @file + * + * Remote Network Driver Interface Specification + * + / + +#include <unistd.h> +#include <string.h> +#include <errno.h> +#include <byteswap.h> +#include <ipxe/iobuf.h> +#include <ipxe/netdevice.h> +#include <ipxe/ethernet.h> +#include <ipxe/device.h> +#include <ipxe/rndis.h> + +/* + * Allocate I/O buffer + * + * @v len Length + * @ret iobuf I/O buffer, or NULL + / +static struct io_buffer rndis_alloc_iob ( size_t len ) { + struct rndis_header header; + struct io_buffer iobuf; + + /* Allocate I/O buffer and reserve space / + iobuf = alloc_iob ( sizeof ( header ) + len ); + if ( iobuf ) + iob_reserve ( iobuf, sizeof ( header ) ); + + return iobuf; +} + +/* + * Wait for completion + * + * @v rndis RNDIS device + * @v wait_id Request ID + * @ret rc Return status code + / +static int rndis_wait ( struct rndis_device rndis, unsigned int wait_id ) { + unsigned int i; + + /* Record query ID / + rndis->wait_id = wait_id; + + / Wait for operation to complete / + for ( i = 0 ; i < RNDIS_MAX_WAIT_MS ; i++ ) { + + / Check for completion / + if ( ! rndis->wait_id ) + return rndis->wait_rc; + + / Poll RNDIS device / + rndis->op->poll ( rndis ); + + / Delay for 1ms / + mdelay ( 1 ); + } + + DBGC ( rndis, "RNDIS %s timed out waiting for ID %#08x\n", + rndis->name, wait_id ); + return -ETIMEDOUT; +} + +/* + * Transmit message + * + * @v rndis RNDIS device + * @v iobuf I/O buffer + * @v type Message type + * @ret rc Return status code + / +static int rndis_tx_message ( struct rndis_device rndis, + struct io_buffer iobuf, unsigned int type ) { + struct rndis_header header; + int rc; + + /* Prepend RNDIS header / + header = iob_push ( iobuf, sizeof ( header ) ); + header->type = cpu_to_le32 ( type ); + header->len = cpu_to_le32 ( iob_len ( iobuf ) ); + + /* Transmit message / + if ( ( rc = rndis->op->transmit ( rndis, iobuf ) ) != 0 ) { + DBGC ( rndis, "RNDIS %s could not transmit: %s\n", + rndis->name, strerror ( rc ) ); + return rc; + } + + return 0; +} + +/* + * Complete message transmission + * + * @v rndis RNDIS device + * @v iobuf I/O buffer + * @v rc Packet status code + / +void rndis_tx_complete_err ( struct rndis_device rndis, + struct io_buffer iobuf, int rc ) { + struct net_device netdev = rndis->netdev; + struct rndis_header header; + size_t len = iob_len ( iobuf ); + + / Sanity check / + if ( len < sizeof ( header ) ) { + DBGC ( rndis, "RNDIS %s completed underlength transmission:\n", + rndis->name ); + DBGC_HDA ( rndis, 0, iobuf->data, len ); + netdev_tx_err ( netdev, NULL, -EINVAL ); + return; + } + header = iobuf->data; + + /* Complete buffer / + if ( header->type == cpu_to_le32 ( RNDIS_PACKET_MSG ) ) { + netdev_tx_complete_err ( netdev, iobuf, rc ); + } else { + free_iob ( iobuf ); + } +} + +/* + * Transmit data packet + * + * @v rndis RNDIS device + * @v iobuf I/O buffer + * @ret rc Return status code + / +static int rndis_tx_data ( struct rndis_device rndis, + struct io_buffer iobuf ) { + struct rndis_packet_message msg; + size_t len = iob_len ( iobuf ); + int rc; + + /* Prepend packet message header / + msg = iob_push ( iobuf, sizeof ( msg ) ); + memset ( msg, 0, sizeof ( msg ) ); + msg->data.offset = cpu_to_le32 ( sizeof ( msg ) ); + msg->data.len = cpu_to_le32 ( len ); + + /* Transmit message / + if ( ( rc = rndis_tx_message ( rndis, iobuf, RNDIS_PACKET_MSG ) ) != 0 ) + return rc; + + return 0; +} + +/* + * Defer transmitted packet + * + * @v rndis RNDIS device + * @v iobuf I/O buffer + * @ret rc Return status code + * + * As with netdev_tx_defer(), the caller must ensure that space in the + * transmit descriptor ring is freed up before calling + * rndis_tx_complete(). + * + * Unlike netdev_tx_defer(), this call may fail. + / +int rndis_tx_defer ( struct rndis_device rndis, struct io_buffer iobuf ) { + struct net_device netdev = rndis->netdev; + struct rndis_header header; + struct rndis_packet_message msg; + + /* Fail unless this was a packet message. Only packet + * messages correspond to I/O buffers in the network device's + * TX queue; other messages cannot be deferred in this way. + / + assert ( iob_len ( iobuf ) >= sizeof ( header ) ); + header = iobuf->data; + if ( header->type != cpu_to_le32 ( RNDIS_PACKET_MSG ) ) + return -ENOTSUP; + + /* Strip RNDIS header and packet message header, to return + * this packet to the state in which we received it. + / + iob_pull ( iobuf, ( sizeof ( header ) + sizeof ( msg ) ) ); + + / Defer packet / + netdev_tx_defer ( netdev, iobuf ); + + return 0; +} + +/* + * Receive data packet + * + * @v rndis RNDIS device + * @v iobuf I/O buffer + / +static void rndis_rx_data ( struct rndis_device rndis, + struct io_buffer iobuf ) { + struct net_device netdev = rndis->netdev; + struct rndis_packet_message msg; + size_t len = iob_len ( iobuf ); + size_t data_offset; + size_t data_len; + int rc; + + / Sanity check / + if ( len < sizeof ( msg ) ) { + DBGC ( rndis, "RNDIS %s received underlength data packet:\n", + rndis->name ); + DBGC_HDA ( rndis, 0, iobuf->data, len ); + rc = -EINVAL; + goto err_len; + } + msg = iobuf->data; + + /* Locate and sanity check data buffer / + data_offset = le32_to_cpu ( msg->data.offset ); + data_len = le32_to_cpu ( msg->data.len ); + if ( ( data_offset > len ) \|\| ( data_len > ( len - data_offset ) ) ) { + DBGC ( rndis, "RNDIS %s data packet data exceeds packet:\n", + rndis->name ); + DBGC_HDA ( rndis, 0, iobuf->data, len ); + rc = -EINVAL; + goto err_data; + } + + / Strip non-data portions / + iob_pull ( iobuf, data_offset ); + iob_unput ( iobuf, ( iob_len ( iobuf ) - data_len ) ); + + / Hand off to network stack / + netdev_rx ( netdev, iob_disown ( iobuf ) ); + + return; + + err_data: + err_len: + / Report error to network stack / + netdev_rx_err ( netdev, iob_disown ( iobuf ), rc ); +} + +/* + * Transmit initialisation message + * + * @v rndis RNDIS device + * @v id Request ID + * @ret rc Return status code + / +static int rndis_tx_initialise ( struct rndis_device rndis, unsigned int id ) { + struct io_buffer iobuf; + struct rndis_initialise_message msg; + int rc; + + /* Allocate I/O buffer / + iobuf = rndis_alloc_iob ( sizeof ( msg ) ); + if ( ! iobuf ) { + rc = -ENOMEM; + goto err_alloc; + } + + /* Construct message / + msg = iob_put ( iobuf, sizeof ( msg ) ); + memset ( msg, 0, sizeof ( msg ) ); + msg->id = id; / Non-endian / + msg->major = cpu_to_le32 ( RNDIS_VERSION_MAJOR ); + msg->minor = cpu_to_le32 ( RNDIS_VERSION_MINOR ); + msg->mtu = cpu_to_le32 ( RNDIS_MTU ); + + / Transmit message / + if ( ( rc = rndis_tx_message ( rndis, iobuf, + RNDIS_INITIALISE_MSG ) ) != 0 ) + goto err_tx; + + return 0; + + err_tx: + free_iob ( iobuf ); + err_alloc: + return rc; +} + +/* + * Receive initialisation completion + * + * @v rndis RNDIS device + * @v iobuf I/O buffer + / +static void rndis_rx_initialise ( struct rndis_device rndis, + struct io_buffer iobuf ) { + struct rndis_initialise_completion cmplt; + size_t len = iob_len ( iobuf ); + unsigned int id; + int rc; + + /* Sanity check / + if ( len < sizeof ( cmplt ) ) { + DBGC ( rndis, "RNDIS %s received underlength initialisation " + "completion:\n", rndis->name ); + DBGC_HDA ( rndis, 0, iobuf->data, len ); + rc = -EINVAL; + goto err_len; + } + cmplt = iobuf->data; + + /* Extract request ID / + id = cmplt->id; / Non-endian / + + / Check status / + if ( cmplt->status ) { + DBGC ( rndis, "RNDIS %s received initialisation completion " + "failure %#08x\n", rndis->name, + le32_to_cpu ( cmplt->status ) ); + rc = -EIO; + goto err_status; + } + + / Success / + rc = 0; + + err_status: + / Record completion result if applicable / + if ( id == rndis->wait_id ) { + rndis->wait_id = 0; + rndis->wait_rc = rc; + } + err_len: + free_iob ( iobuf ); +} + +/* + * Initialise RNDIS + * + * @v rndis RNDIS device + * @ret rc Return status code + / +static int rndis_initialise ( struct rndis_device rndis ) { + int rc; + + /* Transmit initialisation message / + if ( ( rc = rndis_tx_initialise ( rndis, RNDIS_INIT_ID ) ) != 0 ) + return rc; + + / Wait for response / + if ( ( rc = rndis_wait ( rndis, RNDIS_INIT_ID ) ) != 0 ) + return rc; + + return 0; +} + +/* + * Transmit halt message + * + * @v rndis RNDIS device + * @ret rc Return status code + / +static int rndis_tx_halt ( struct rndis_device rndis ) { + struct io_buffer iobuf; + struct rndis_halt_message msg; + int rc; + + /* Allocate I/O buffer / + iobuf = rndis_alloc_iob ( sizeof ( msg ) ); + if ( ! iobuf ) { + rc = -ENOMEM; + goto err_alloc; + } + + /* Construct message / + msg = iob_put ( iobuf, sizeof ( msg ) ); + memset ( msg, 0, sizeof ( msg ) ); + + / Transmit message / + if ( ( rc = rndis_tx_message ( rndis, iobuf, RNDIS_HALT_MSG ) ) != 0 ) + goto err_tx; + + return 0; + + err_tx: + free_iob ( iobuf ); + err_alloc: + return rc; +} + +/* + * Halt RNDIS + * + * @v rndis RNDIS device + * @ret rc Return status code + / +static int rndis_halt ( struct rndis_device rndis ) { + int rc; + + /* Transmit halt message / + if ( ( rc = rndis_tx_halt ( rndis ) ) != 0 ) + return rc; + + return 0; +} + +/* + * Transmit OID message + * + * @v rndis RNDIS device + * @v oid Object ID + * @v data New OID value (or NULL to query current value) + * @v len Length of new OID value + * @ret rc Return status code + / +static int rndis_tx_oid ( struct rndis_device rndis, unsigned int oid, + const void data, size_t len ) { + struct io_buffer iobuf; + struct rndis_oid_message msg; + unsigned int type; + int rc; + + / Allocate I/O buffer / + iobuf = rndis_alloc_iob ( sizeof ( msg ) + len ); + if ( ! iobuf ) { + rc = -ENOMEM; + goto err_alloc; + } + + /* Construct message. We use the OID as the request ID. / + msg = iob_put ( iobuf, sizeof ( msg ) ); + memset ( msg, 0, sizeof ( msg ) ); + msg->id = oid; / Non-endian / + msg->oid = cpu_to_le32 ( oid ); + msg->offset = cpu_to_le32 ( sizeof ( msg ) ); + msg->len = cpu_to_le32 ( len ); + memcpy ( iob_put ( iobuf, len ), data, len ); + + /* Transmit message / + type = ( data ? RNDIS_SET_MSG : RNDIS_QUERY_MSG ); + if ( ( rc = rndis_tx_message ( rndis, iobuf, type ) ) != 0 ) + goto err_tx; + + return 0; + + err_tx: + free_iob ( iobuf ); + err_alloc: + return rc; +} + +/* + * Receive query OID completion + * + * @v rndis RNDIS device + * @v iobuf I/O buffer + / +static void rndis_rx_query_oid ( struct rndis_device rndis, + struct io_buffer iobuf ) { + struct net_device netdev = rndis->netdev; + struct rndis_query_completion cmplt; + size_t len = iob_len ( iobuf ); + size_t info_offset; + size_t info_len; + unsigned int id; + void info; + uint32_t link_status; + int rc; + + / Sanity check / + if ( len < sizeof ( cmplt ) ) { + DBGC ( rndis, "RNDIS %s received underlength query " + "completion:\n", rndis->name ); + DBGC_HDA ( rndis, 0, iobuf->data, len ); + rc = -EINVAL; + goto err_len; + } + cmplt = iobuf->data; + + /* Extract request ID / + id = cmplt->id; / Non-endian / + + / Check status / + if ( cmplt->status ) { + DBGC ( rndis, "RNDIS %s received query completion failure " + "%#08x\n", rndis->name, le32_to_cpu ( cmplt->status ) ); + DBGC_HDA ( rndis, 0, iobuf->data, len ); + rc = -EIO; + goto err_status; + } + + / Locate and sanity check information buffer / + info_offset = le32_to_cpu ( cmplt->offset ); + info_len = le32_to_cpu ( cmplt->len ); + if ( ( info_offset > len ) \|\| ( info_len > ( len - info_offset ) ) ) { + DBGC ( rndis, "RNDIS %s query completion information exceeds " + "packet:\n", rndis->name ); + DBGC_HDA ( rndis, 0, iobuf->data, len ); + rc = -EINVAL; + goto err_info; + } + info = ( ( ( void ) cmplt ) + info_offset ); + + /* Handle OID / + switch ( id ) { + + case RNDIS_OID_802_3_PERMANENT_ADDRESS: + if ( info_len > sizeof ( netdev->hw_addr ) ) + info_len = sizeof ( netdev->hw_addr ); + memcpy ( netdev->hw_addr, info, info_len ); + break; + + case RNDIS_OID_802_3_CURRENT_ADDRESS: + if ( info_len > sizeof ( netdev->ll_addr ) ) + info_len = sizeof ( netdev->ll_addr ); + memcpy ( netdev->ll_addr, info, info_len ); + break; + + case RNDIS_OID_GEN_MEDIA_CONNECT_STATUS: + if ( info_len != sizeof ( link_status ) ) { + DBGC ( rndis, "RNDIS %s invalid link status:\n", + rndis->name ); + DBGC_HDA ( rndis, 0, iobuf->data, len ); + rc = -EPROTO; + goto err_link_status; + } + link_status = info; + if ( link_status == 0 ) { + DBGC ( rndis, "RNDIS %s link is up\n", rndis->name ); + netdev_link_up ( netdev ); + } else { + DBGC ( rndis, "RNDIS %s link is down: %#08x\n", + rndis->name, le32_to_cpu ( link_status ) ); + netdev_link_down ( netdev ); + } + break; + + default: + DBGC ( rndis, "RNDIS %s unexpected query completion ID %#08x\n", + rndis->name, id ); + DBGC_HDA ( rndis, 0, iobuf->data, len ); + rc = -EPROTO; + goto err_id; + } + + /* Success / + rc = 0; + + err_id: + err_link_status: + err_info: + err_status: + / Record completion result if applicable / + if ( id == rndis->wait_id ) { + rndis->wait_id = 0; + rndis->wait_rc = rc; + } + err_len: + / Free I/O buffer / + free_iob ( iobuf ); +} + +/* + * Receive set OID completion + * + * @v rndis RNDIS device + * @v iobuf I/O buffer + / +static void rndis_rx_set_oid ( struct rndis_device rndis, + struct io_buffer iobuf ) { + struct rndis_set_completion cmplt; + size_t len = iob_len ( iobuf ); + unsigned int id; + int rc; + + /* Sanity check / + if ( len < sizeof ( cmplt ) ) { + DBGC ( rndis, "RNDIS %s received underlength set completion:\n", + rndis->name ); + DBGC_HDA ( rndis, 0, iobuf->data, len ); + rc = -EINVAL; + goto err_len; + } + cmplt = iobuf->data; + + /* Extract request ID / + id = cmplt->id; / Non-endian / + + / Check status / + if ( cmplt->status ) { + DBGC ( rndis, "RNDIS %s received set completion failure " + "%#08x\n", rndis->name, le32_to_cpu ( cmplt->status ) ); + DBGC_HDA ( rndis, 0, iobuf->data, len ); + rc = -EIO; + goto err_status; + } + + / Success / + rc = 0; + + err_status: + / Record completion result if applicable / + if ( id == rndis->wait_id ) { + rndis->wait_id = 0; + rndis->wait_rc = rc; + } + err_len: + / Free I/O buffer / + free_iob ( iobuf ); +} + +/* + * Query or set OID + * + * @v rndis RNDIS device + * @v oid Object ID + * @v data New OID value (or NULL to query current value) + * @v len Length of new OID value + * @ret rc Return status code + / +static int rndis_oid ( struct rndis_device rndis, unsigned int oid, + const void data, size_t len ) { + int rc; + + / Transmit query / + if ( ( rc = rndis_tx_oid ( rndis, oid, data, len ) ) != 0 ) + return rc; + + / Wait for response / + if ( ( rc = rndis_wait ( rndis, oid ) ) != 0 ) + return rc; + + return 0; +} + +/* + * Receive indicate status message + * + * @v rndis RNDIS device + * @v iobuf I/O buffer + / +static void rndis_rx_status ( struct rndis_device rndis, + struct io_buffer iobuf ) { + struct net_device netdev = rndis->netdev; + struct rndis_indicate_status_message msg; + size_t len = iob_len ( iobuf ); + unsigned int status; + int rc; + + / Sanity check / + if ( len < sizeof ( msg ) ) { + DBGC ( rndis, "RNDIS %s received underlength status message:\n", + rndis->name ); + DBGC_HDA ( rndis, 0, iobuf->data, len ); + rc = -EINVAL; + goto err_len; + } + msg = iobuf->data; + + /* Extract status / + status = le32_to_cpu ( msg->status ); + + / Handle status / + switch ( msg->status ) { + + case RNDIS_STATUS_MEDIA_CONNECT: + DBGC ( rndis, "RNDIS %s link is up\n", rndis->name ); + netdev_link_up ( netdev ); + break; + + case RNDIS_STATUS_MEDIA_DISCONNECT: + DBGC ( rndis, "RNDIS %s link is down\n", rndis->name ); + netdev_link_down ( netdev ); + break; + + case RNDIS_STATUS_WTF_WORLD: + / Ignore / + break; + + default: + DBGC ( rndis, "RNDIS %s unexpected status %#08x:\n", + rndis->name, status ); + DBGC_HDA ( rndis, 0, iobuf->data, len ); + rc = -ENOTSUP; + goto err_status; + } + + / Free I/O buffer / + free_iob ( iobuf ); + + return; + + err_status: + err_len: + / Report error via network device statistics / + netdev_rx_err ( netdev, iobuf, rc ); +} + +/* + * Receive RNDIS message + * + * @v rndis RNDIS device + * @v iobuf I/O buffer + * @v type Message type + / +static void rndis_rx_message ( struct rndis_device rndis, + struct io_buffer iobuf, unsigned int type ) { + struct net_device netdev = rndis->netdev; + int rc; + + /* Handle packet / + switch ( type ) { + + case RNDIS_PACKET_MSG: + rndis_rx_data ( rndis, iob_disown ( iobuf ) ); + break; + + case RNDIS_INITIALISE_CMPLT: + rndis_rx_initialise ( rndis, iob_disown ( iobuf ) ); + break; + + case RNDIS_QUERY_CMPLT: + rndis_rx_query_oid ( rndis, iob_disown ( iobuf ) ); + break; + + case RNDIS_SET_CMPLT: + rndis_rx_set_oid ( rndis, iob_disown ( iobuf ) ); + break; + + case RNDIS_INDICATE_STATUS_MSG: + rndis_rx_status ( rndis, iob_disown ( iobuf ) ); + break; + + default: + DBGC ( rndis, "RNDIS %s received unexpected type %#08x\n", + rndis->name, type ); + DBGC_HDA ( rndis, 0, iobuf->data, iob_len ( iobuf ) ); + rc = -EPROTO; + goto err_type; + } + + return; + + err_type: + / Report error via network device statistics / + netdev_rx_err ( netdev, iobuf, rc ); +} + +/* + * Receive packet from underlying transport layer + * + * @v rndis RNDIS device + * @v iobuf I/O buffer + / +void rndis_rx ( struct rndis_device rndis, struct io_buffer iobuf ) { + struct net_device netdev = rndis->netdev; + struct rndis_header header; + unsigned int type; + int rc; + + / Sanity check / + if ( iob_len ( iobuf ) < sizeof ( header ) ) { + DBGC ( rndis, "RNDIS %s received underlength packet:\n", + rndis->name ); + DBGC_HDA ( rndis, 0, iobuf->data, iob_len ( iobuf ) ); + rc = -EINVAL; + goto drop; + } + header = iobuf->data; + + /* Parse and strip header / + type = le32_to_cpu ( header->type ); + iob_pull ( iobuf, sizeof ( header ) ); + + /* Handle message / + rndis_rx_message ( rndis, iob_disown ( iobuf ), type ); + + return; + + drop: + / Record error / + netdev_rx_err ( netdev, iob_disown ( iobuf ), rc ); +} + +/* + * Set receive filter + * + * @v rndis RNDIS device + * @v filter Receive filter + * @ret rc Return status code + / +static int rndis_filter ( struct rndis_device rndis, unsigned int filter ) { + uint32_t value = cpu_to_le32 ( filter ); + int rc; + + /* Set receive filter / + if ( ( rc = rndis_oid ( rndis, RNDIS_OID_GEN_CURRENT_PACKET_FILTER, + &value, sizeof ( value ) ) ) != 0 ) { + DBGC ( rndis, "RNDIS %s could not set receive filter to %#08x: " + "%s\n", rndis->name, filter, strerror ( rc ) ); + return rc; + } + + return 0; +} + +/* + * Open network device + * + * @v netdev Network device + * @ret rc Return status code + / +static int rndis_open ( struct net_device netdev ) { + struct rndis_device rndis = netdev->priv; + int rc; + + / Open RNDIS device / + if ( ( rc = rndis->op->open ( rndis ) ) != 0 ) { + DBGC ( rndis, "RNDIS %s could not open: %s\n", + rndis->name, strerror ( rc ) ); + goto err_open; + } + + / Initialise RNDIS / + if ( ( rc = rndis_initialise ( rndis ) ) != 0 ) + goto err_initialise; + + / Set receive filter / + if ( ( rc = rndis_filter ( rndis, ( RNDIS_FILTER_UNICAST \| + RNDIS_FILTER_MULTICAST \| + RNDIS_FILTER_ALL_MULTICAST \| + RNDIS_FILTER_BROADCAST \| + RNDIS_FILTER_PROMISCUOUS ) ) ) != 0) + goto err_set_filter; + + / Update link status / + if ( ( rc = rndis_oid ( rndis, RNDIS_OID_GEN_MEDIA_CONNECT_STATUS, + NULL, 0 ) ) != 0 ) + goto err_query_link; + + return 0; + + err_query_link: + err_set_filter: + rndis_halt ( rndis ); + err_initialise: + rndis->op->close ( rndis ); + err_open: + return rc; +} + +/* + * Close network device + * + * @v netdev Network device + / +static void rndis_close ( struct net_device netdev ) { + struct rndis_device rndis = netdev->priv; + + / Clear receive filter / + rndis_filter ( rndis, 0 ); + + / Halt RNDIS device / + rndis_halt ( rndis ); + + / Close RNDIS device / + rndis->op->close ( rndis ); +} + +/* + * Transmit packet + * + * @v netdev Network device + * @v iobuf I/O buffer + * @ret rc Return status code + / +static int rndis_transmit ( struct net_device netdev, + struct io_buffer iobuf ) { + struct rndis_device rndis = netdev->priv; + + /* Transmit data packet / + return rndis_tx_data ( rndis, iobuf ); +} + +/* + * Poll for completed and received packets + * + * @v netdev Network device + / +static void rndis_poll ( struct net_device netdev ) { + struct rndis_device rndis = netdev->priv; + + / Poll RNDIS device / + rndis->op->poll ( rndis ); +} + +/* Network device operations / +static struct net_device_operations rndis_operations = { + .open = rndis_open, + .close = rndis_close, + .transmit = rndis_transmit, + .poll = rndis_poll, +}; + +/* + * Allocate RNDIS device + * + * @v priv_len Length of private data + * @ret rndis RNDIS device, or NULL on allocation failure + / +struct rndis_device alloc_rndis ( size_t priv_len ) { + struct net_device netdev; + struct rndis_device rndis; + + /* Allocate and initialise structure / + netdev = alloc_etherdev ( sizeof ( rndis ) + priv_len ); + if ( ! netdev ) + return NULL; + netdev_init ( netdev, &rndis_operations ); + rndis = netdev->priv; + rndis->netdev = netdev; + rndis->priv = ( ( ( void * ) rndis ) + sizeof ( rndis ) ); + + return rndis; +} + +/* + * Register RNDIS device + * + * @v rndis RNDIS device + * @ret rc Return status code + * + * Note that this routine will open and use the RNDIS device in order + * to query the MAC address. The device must be immediately ready for + * use prior to registration. + / +int register_rndis ( struct rndis_device rndis ) { + struct net_device netdev = rndis->netdev; + int rc; + + / Assign device name (for debugging) / + rndis->name = netdev->dev->name; + + / Register network device / + if ( ( rc = register_netdev ( netdev ) ) != 0 ) { + DBGC ( rndis, "RNDIS %s could not register: %s\n", + rndis->name, strerror ( rc ) ); + goto err_register; + } + + / Open RNDIS device to read MAC addresses / + if ( ( rc = rndis->op->open ( rndis ) ) != 0 ) { + DBGC ( rndis, "RNDIS %s could not open: %s\n", + rndis->name, strerror ( rc ) ); + goto err_open; + } + + / Initialise RNDIS / + if ( ( rc = rndis_initialise ( rndis ) ) != 0 ) + goto err_initialise; + + / Query permanent MAC address / + if ( ( rc = rndis_oid ( rndis, RNDIS_OID_802_3_PERMANENT_ADDRESS, + NULL, 0 ) ) != 0 ) + goto err_query_permanent; + + / Query current MAC address / + if ( ( rc = rndis_oid ( rndis, RNDIS_OID_802_3_CURRENT_ADDRESS, + NULL, 0 ) ) != 0 ) + goto err_query_current; + + / Get link status / + if ( ( rc = rndis_oid ( rndis, RNDIS_OID_GEN_MEDIA_CONNECT_STATUS, + NULL, 0 ) ) != 0 ) + goto err_query_link; + + / Halt RNDIS device / + rndis_halt ( rndis ); + + / Close RNDIS device / + rndis->op->close ( rndis ); + + return 0; + + err_query_link: + err_query_current: + err_query_permanent: + rndis_halt ( rndis ); + err_initialise: + rndis->op->close ( rndis ); + err_open: + unregister_netdev ( netdev ); + err_register: + return rc; +} + +/* + * Unregister RNDIS device + * + * @v rndis RNDIS device + / +void unregister_rndis ( struct rndis_device rndis ) { + struct net_device netdev = rndis->netdev; + + / Unregister network device / + unregister_netdev ( netdev ); +} + +/* + * Free RNDIS device + * + * @v rndis RNDIS device + / +void free_rndis ( struct rndis_device rndis ) { + struct net_device netdev = rndis->netdev; + + / Free network device */ + netdev_nullify ( netdev ); + netdev_put ( netdev ); +}
[-] [+]	Changed	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/tests/ocsp_test.c ^
@@ -825,6 +825,253 @@ 0x1c, 0xec, 0xc2, 0x1c, 0xc5, 0xc2, 0xf5, 0x67, 0x48, 0xa7, 0x11, 0x01, 0x69, 0x83, 0xfd, 0x8e ) ); +/* + * subject RapidSSL SHA256 CA - G3 + * issuer GeoTrust Global CA + / +CERTIFICATE ( rapidssl_crt, + DATA ( 0x30, 0x82, 0x04, 0x25, 0x30, 0x82, 0x03, 0x0d, 0xa0, 0x03, + 0x02, 0x01, 0x02, 0x02, 0x03, 0x02, 0x3a, 0x77, 0x30, 0x0d, + 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, + 0x0b, 0x05, 0x00, 0x30, 0x42, 0x31, 0x0b, 0x30, 0x09, 0x06, + 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x55, 0x53, 0x31, 0x16, + 0x30, 0x14, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x13, 0x0d, 0x47, + 0x65, 0x6f, 0x54, 0x72, 0x75, 0x73, 0x74, 0x20, 0x49, 0x6e, + 0x63, 0x2e, 0x31, 0x1b, 0x30, 0x19, 0x06, 0x03, 0x55, 0x04, + 0x03, 0x13, 0x12, 0x47, 0x65, 0x6f, 0x54, 0x72, 0x75, 0x73, + 0x74, 0x20, 0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x20, 0x43, + 0x41, 0x30, 0x1e, 0x17, 0x0d, 0x31, 0x34, 0x30, 0x38, 0x32, + 0x39, 0x32, 0x31, 0x33, 0x39, 0x33, 0x32, 0x5a, 0x17, 0x0d, + 0x32, 0x32, 0x30, 0x35, 0x32, 0x30, 0x32, 0x31, 0x33, 0x39, + 0x33, 0x32, 0x5a, 0x30, 0x47, 0x31, 0x0b, 0x30, 0x09, 0x06, + 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x55, 0x53, 0x31, 0x16, + 0x30, 0x14, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x13, 0x0d, 0x47, + 0x65, 0x6f, 0x54, 0x72, 0x75, 0x73, 0x74, 0x20, 0x49, 0x6e, + 0x63, 0x2e, 0x31, 0x20, 0x30, 0x1e, 0x06, 0x03, 0x55, 0x04, + 0x03, 0x13, 0x17, 0x52, 0x61, 0x70, 0x69, 0x64, 0x53, 0x53, + 0x4c, 0x20, 0x53, 0x48, 0x41, 0x32, 0x35, 0x36, 0x20, 0x43, + 0x41, 0x20, 0x2d, 0x20, 0x47, 0x33, 0x30, 0x82, 0x01, 0x22, + 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, + 0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x82, 0x01, 0x0f, 0x00, + 0x30, 0x82, 0x01, 0x0a, 0x02, 0x82, 0x01, 0x01, 0x00, 0xaf, + 0x54, 0x9b, 0xd9, 0x58, 0x5d, 0x1e, 0x2c, 0x56, 0xc6, 0xd5, + 0xe8, 0x7f, 0xf4, 0x7d, 0x16, 0x03, 0xff, 0xd0, 0x8b, 0x5a, + 0xe4, 0x8e, 0xa7, 0xdd, 0x54, 0x2e, 0xd4, 0x04, 0xc0, 0x5d, + 0x98, 0x9c, 0x8d, 0x90, 0x0f, 0xbc, 0x10, 0x65, 0x5f, 0xda, + 0x9a, 0xd6, 0x44, 0x7c, 0xc0, 0x9f, 0xb5, 0xe9, 0x4a, 0x8c, + 0x0b, 0x06, 0x43, 0x04, 0xbb, 0xf4, 0x96, 0xe2, 0x26, 0xf6, + 0x61, 0x01, 0x91, 0x66, 0x31, 0x22, 0xc3, 0x34, 0x34, 0x5f, + 0x3f, 0x3f, 0x91, 0x2f, 0x44, 0x5f, 0xdc, 0xc7, 0x14, 0xb6, + 0x03, 0x9f, 0x86, 0x4b, 0x0e, 0xa3, 0xff, 0xa0, 0x80, 0x02, + 0x83, 0xc3, 0xd3, 0x1f, 0x69, 0x52, 0xd6, 0x9d, 0x64, 0x0f, + 0xc9, 0x83, 0xe7, 0x1b, 0xc4, 0x70, 0xac, 0x94, 0xe7, 0xc3, + 0xa4, 0x6a, 0x2c, 0xbd, 0xb8, 0x9e, 0x69, 0xd8, 0xbe, 0x0a, + 0x8f, 0x16, 0x63, 0x5a, 0x68, 0x71, 0x80, 0x7b, 0x30, 0xde, + 0x15, 0x04, 0xbf, 0xcc, 0xd3, 0xbf, 0x3e, 0x48, 0x05, 0x55, + 0x7a, 0xb3, 0xd7, 0x10, 0x0c, 0x03, 0xfc, 0x9b, 0xfd, 0x08, + 0xa7, 0x8c, 0x8c, 0xdb, 0xa7, 0x8e, 0xf1, 0x1e, 0x63, 0xdc, + 0xb3, 0x01, 0x2f, 0x7f, 0xaf, 0x57, 0xc3, 0x3c, 0x48, 0xa7, + 0x83, 0x68, 0x21, 0xa7, 0x2f, 0xe7, 0xa7, 0x3f, 0xf0, 0xb5, + 0x0c, 0xfc, 0xf5, 0x84, 0xd1, 0x53, 0xbc, 0x0e, 0x72, 0x4f, + 0x60, 0x0c, 0x42, 0xb8, 0x98, 0xad, 0x19, 0x88, 0x57, 0xd7, + 0x04, 0xec, 0x87, 0xbf, 0x7e, 0x87, 0x4e, 0xa3, 0x21, 0xf9, + 0x53, 0xfd, 0x36, 0x98, 0x48, 0x8d, 0xd6, 0xf8, 0xbb, 0x48, + 0xf2, 0x29, 0xc8, 0x64, 0xd1, 0xcc, 0x54, 0x48, 0x53, 0x8b, + 0xaf, 0xb7, 0x65, 0x1e, 0xbf, 0x29, 0x33, 0x29, 0xd9, 0x29, + 0x60, 0x48, 0xf8, 0xff, 0x91, 0xbc, 0x57, 0x58, 0xe5, 0x35, + 0x2e, 0xbb, 0x69, 0xb6, 0x59, 0x02, 0x03, 0x01, 0x00, 0x01, + 0xa3, 0x82, 0x01, 0x1d, 0x30, 0x82, 0x01, 0x19, 0x30, 0x1f, + 0x06, 0x03, 0x55, 0x1d, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80, + 0x14, 0xc0, 0x7a, 0x98, 0x68, 0x8d, 0x89, 0xfb, 0xab, 0x05, + 0x64, 0x0c, 0x11, 0x7d, 0xaa, 0x7d, 0x65, 0xb8, 0xca, 0xcc, + 0x4e, 0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d, 0x0e, 0x04, 0x16, + 0x04, 0x14, 0xc3, 0x9c, 0xf3, 0xfc, 0xd3, 0x46, 0x08, 0x34, + 0xbb, 0xce, 0x46, 0x7f, 0xa0, 0x7c, 0x5b, 0xf3, 0xe2, 0x08, + 0xcb, 0x59, 0x30, 0x12, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, + 0x01, 0xff, 0x04, 0x08, 0x30, 0x06, 0x01, 0x01, 0xff, 0x02, + 0x01, 0x00, 0x30, 0x0e, 0x06, 0x03, 0x55, 0x1d, 0x0f, 0x01, + 0x01, 0xff, 0x04, 0x04, 0x03, 0x02, 0x01, 0x06, 0x30, 0x35, + 0x06, 0x03, 0x55, 0x1d, 0x1f, 0x04, 0x2e, 0x30, 0x2c, 0x30, + 0x2a, 0xa0, 0x28, 0xa0, 0x26, 0x86, 0x24, 0x68, 0x74, 0x74, + 0x70, 0x3a, 0x2f, 0x2f, 0x67, 0x2e, 0x73, 0x79, 0x6d, 0x63, + 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x63, 0x72, 0x6c, 0x73, + 0x2f, 0x67, 0x74, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x2e, + 0x63, 0x72, 0x6c, 0x30, 0x2e, 0x06, 0x08, 0x2b, 0x06, 0x01, + 0x05, 0x05, 0x07, 0x01, 0x01, 0x04, 0x22, 0x30, 0x20, 0x30, + 0x1e, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x30, + 0x01, 0x86, 0x12, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, + 0x67, 0x2e, 0x73, 0x79, 0x6d, 0x63, 0x64, 0x2e, 0x63, 0x6f, + 0x6d, 0x30, 0x4c, 0x06, 0x03, 0x55, 0x1d, 0x20, 0x04, 0x45, + 0x30, 0x43, 0x30, 0x41, 0x06, 0x0a, 0x60, 0x86, 0x48, 0x01, + 0x86, 0xf8, 0x45, 0x01, 0x07, 0x36, 0x30, 0x33, 0x30, 0x31, + 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x02, 0x01, + 0x16, 0x25, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, + 0x77, 0x77, 0x2e, 0x67, 0x65, 0x6f, 0x74, 0x72, 0x75, 0x73, + 0x74, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x72, 0x65, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x73, 0x2f, 0x63, 0x70, 0x73, 0x30, + 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, + 0x01, 0x0b, 0x05, 0x00, 0x03, 0x82, 0x01, 0x01, 0x00, 0xa3, + 0x58, 0x1e, 0xc6, 0x43, 0x32, 0xac, 0xac, 0x2f, 0x93, 0x78, + 0xb7, 0xea, 0xae, 0x54, 0x40, 0x47, 0x2d, 0x7e, 0x78, 0x8d, + 0x50, 0xf6, 0xf8, 0x66, 0xac, 0xd6, 0x4f, 0x73, 0xd6, 0x44, + 0xef, 0xaf, 0x0b, 0xcc, 0x5b, 0xc1, 0xf4, 0x4f, 0x9a, 0x8f, + 0x49, 0x7e, 0x60, 0xaf, 0xc2, 0x27, 0xc7, 0x16, 0xf1, 0xfb, + 0x93, 0x81, 0x90, 0xa9, 0x7c, 0xef, 0x6f, 0x7e, 0x6e, 0x45, + 0x94, 0x16, 0x84, 0xbd, 0xec, 0x49, 0xf1, 0xc4, 0x0e, 0xf4, + 0xaf, 0x04, 0x59, 0x83, 0x87, 0x0f, 0x2c, 0x3b, 0x97, 0xc3, + 0x5a, 0x12, 0x9b, 0x7b, 0x04, 0x35, 0x7b, 0xa3, 0x95, 0x33, + 0x08, 0x7b, 0x93, 0x71, 0x22, 0x42, 0xb3, 0xa9, 0xd9, 0x6f, + 0x4f, 0x81, 0x92, 0xfc, 0x07, 0xb6, 0x79, 0xbc, 0x84, 0x4a, + 0x9d, 0x77, 0x09, 0xf1, 0xc5, 0x89, 0xf2, 0xf0, 0xb4, 0x9c, + 0x54, 0xaa, 0x12, 0x7b, 0x0d, 0xba, 0x4f, 0xef, 0x93, 0x19, + 0xec, 0xef, 0x7d, 0x4e, 0x61, 0xa3, 0x8e, 0x76, 0x9c, 0x59, + 0xcf, 0x8c, 0x94, 0xb1, 0x84, 0x97, 0xf7, 0x1a, 0xb9, 0x07, + 0xb8, 0xb2, 0xc6, 0x4f, 0x13, 0x79, 0xdb, 0xbf, 0x4f, 0x51, + 0x1b, 0x7f, 0x69, 0x0d, 0x51, 0x2a, 0xc1, 0xd6, 0x15, 0xff, + 0x37, 0x51, 0x34, 0x65, 0x51, 0xf4, 0x1e, 0xbe, 0x38, 0x6a, + 0xec, 0x0e, 0xab, 0xbf, 0x3d, 0x7b, 0x39, 0x05, 0x7b, 0xf4, + 0xf3, 0xfb, 0x1a, 0xa1, 0xd0, 0xc8, 0x7e, 0x4e, 0x64, 0x8d, + 0xcd, 0x8c, 0x61, 0x55, 0x90, 0xfe, 0x3a, 0xca, 0x5d, 0x25, + 0x0f, 0xf8, 0x1d, 0xa3, 0x4a, 0x74, 0x56, 0x4f, 0x1a, 0x55, + 0x40, 0x70, 0x75, 0x25, 0xa6, 0x33, 0x2e, 0xba, 0x4b, 0xa5, + 0x5d, 0x53, 0x9a, 0x0d, 0x30, 0xe1, 0x8d, 0x5f, 0x61, 0x2c, + 0xaf, 0xcc, 0xef, 0xb0, 0x99, 0xa1, 0x80, 0xff, 0x0b, 0xf2, + 0x62, 0x4c, 0x70, 0x26, 0x98 ), + FINGERPRINT ( 0xbc, 0x3f, 0x03, 0xa4, 0x36, 0x24, 0x0e, 0xdb, + 0xa5, 0xf8, 0x37, 0x14, 0xf6, 0xf6, 0x77, 0xe3, + 0x4b, 0x37, 0xf9, 0xb1, 0xf0, 0xc0, 0x8c, 0x1e, + 0x55, 0x8d, 0x98, 0x1e, 0x27, 0x9e, 0x82, 0x09 ) ); + +/ + * subject .vultr.com + issuer RapidSSL SHA256 CA - G3 + / +CERTIFICATE ( vultr_crt, + DATA ( 0x30, 0x82, 0x04, 0xa8, 0x30, 0x82, 0x03, 0x90, 0xa0, 0x03, + 0x02, 0x01, 0x02, 0x02, 0x03, 0x00, 0x95, 0x4d, 0x30, 0x0d, + 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, + 0x0b, 0x05, 0x00, 0x30, 0x47, 0x31, 0x0b, 0x30, 0x09, 0x06, + 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x55, 0x53, 0x31, 0x16, + 0x30, 0x14, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x13, 0x0d, 0x47, + 0x65, 0x6f, 0x54, 0x72, 0x75, 0x73, 0x74, 0x20, 0x49, 0x6e, + 0x63, 0x2e, 0x31, 0x20, 0x30, 0x1e, 0x06, 0x03, 0x55, 0x04, + 0x03, 0x13, 0x17, 0x52, 0x61, 0x70, 0x69, 0x64, 0x53, 0x53, + 0x4c, 0x20, 0x53, 0x48, 0x41, 0x32, 0x35, 0x36, 0x20, 0x43, + 0x41, 0x20, 0x2d, 0x20, 0x47, 0x33, 0x30, 0x1e, 0x17, 0x0d, + 0x31, 0x34, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x33, 0x31, + 0x32, 0x38, 0x5a, 0x17, 0x0d, 0x31, 0x37, 0x31, 0x32, 0x32, + 0x32, 0x31, 0x39, 0x32, 0x39, 0x31, 0x30, 0x5a, 0x30, 0x81, + 0x8f, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x0b, + 0x13, 0x0a, 0x47, 0x54, 0x36, 0x32, 0x30, 0x37, 0x39, 0x37, + 0x32, 0x31, 0x31, 0x31, 0x30, 0x2f, 0x06, 0x03, 0x55, 0x04, + 0x0b, 0x13, 0x28, 0x53, 0x65, 0x65, 0x20, 0x77, 0x77, 0x77, + 0x2e, 0x72, 0x61, 0x70, 0x69, 0x64, 0x73, 0x73, 0x6c, 0x2e, + 0x63, 0x6f, 0x6d, 0x2f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x73, 0x2f, 0x63, 0x70, 0x73, 0x20, 0x28, 0x63, + 0x29, 0x31, 0x33, 0x31, 0x2f, 0x30, 0x2d, 0x06, 0x03, 0x55, + 0x04, 0x0b, 0x13, 0x26, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, + 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x20, 0x56, + 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x64, 0x20, 0x2d, + 0x20, 0x52, 0x61, 0x70, 0x69, 0x64, 0x53, 0x53, 0x4c, 0x28, + 0x52, 0x29, 0x31, 0x14, 0x30, 0x12, 0x06, 0x03, 0x55, 0x04, + 0x03, 0x0c, 0x0b, 0x2a, 0x2e, 0x76, 0x75, 0x6c, 0x74, 0x72, + 0x2e, 0x63, 0x6f, 0x6d, 0x30, 0x82, 0x01, 0x22, 0x30, 0x0d, + 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, + 0x01, 0x05, 0x00, 0x03, 0x82, 0x01, 0x0f, 0x00, 0x30, 0x82, + 0x01, 0x0a, 0x02, 0x82, 0x01, 0x01, 0x00, 0x9f, 0xa8, 0x2e, + 0x65, 0x41, 0x05, 0xec, 0xef, 0x69, 0x92, 0xf6, 0xd3, 0x53, + 0x4f, 0xd4, 0x8e, 0xd3, 0x49, 0x8c, 0xc7, 0x85, 0x6d, 0xb0, + 0x71, 0xe0, 0x28, 0x04, 0x80, 0x85, 0x82, 0x3e, 0x3f, 0xdb, + 0x0c, 0xed, 0xcd, 0x2b, 0x04, 0xc8, 0x67, 0x15, 0x8c, 0x25, + 0xd6, 0x7a, 0x54, 0x67, 0x94, 0xbe, 0x33, 0x12, 0x33, 0x88, + 0xfe, 0x5d, 0x1d, 0x36, 0x62, 0x4e, 0xbc, 0x1e, 0x7e, 0xd3, + 0x3e, 0x7c, 0x3c, 0x59, 0x4a, 0x99, 0x0b, 0xca, 0x9b, 0x1e, + 0xc7, 0xf7, 0xe7, 0x6d, 0xdc, 0x57, 0xbe, 0x3a, 0xab, 0xc2, + 0x0b, 0xb1, 0xbe, 0x90, 0xa1, 0x54, 0x07, 0xc5, 0x48, 0x65, + 0xc1, 0x32, 0x99, 0x92, 0x26, 0x97, 0x90, 0x3e, 0x68, 0x6b, + 0xac, 0xbd, 0x4f, 0x0e, 0x88, 0x38, 0xd3, 0xdc, 0x80, 0x9e, + 0xb9, 0x66, 0x5d, 0xeb, 0x19, 0xfd, 0x85, 0xff, 0xba, 0xf0, + 0x89, 0x20, 0x08, 0xea, 0xd8, 0x01, 0x76, 0x29, 0xdc, 0xf0, + 0x1c, 0xfa, 0xbf, 0x6f, 0x7b, 0x67, 0xf4, 0xc4, 0xee, 0xe3, + 0xde, 0x95, 0xa2, 0x76, 0x65, 0x98, 0xc5, 0x21, 0xdc, 0xe9, + 0x95, 0xee, 0x83, 0x97, 0xae, 0xdd, 0xab, 0xdb, 0xc0, 0x47, + 0xc8, 0x68, 0x00, 0xb3, 0xab, 0x11, 0x4f, 0x81, 0xf5, 0x45, + 0x01, 0xd1, 0x64, 0xfd, 0x53, 0xbf, 0x86, 0xef, 0x87, 0xca, + 0x8e, 0x55, 0xa0, 0x27, 0x27, 0xe5, 0x9e, 0xc1, 0x69, 0x28, + 0x2a, 0x9f, 0x2d, 0xe2, 0x2c, 0x25, 0xef, 0x74, 0x1b, 0x52, + 0xe4, 0x81, 0xf4, 0xc2, 0x71, 0x0a, 0x48, 0xff, 0x47, 0xa5, + 0xea, 0x0a, 0xf5, 0xb1, 0x6d, 0xae, 0x09, 0x2b, 0xf9, 0x23, + 0x6a, 0x28, 0x58, 0x3d, 0xbb, 0x9f, 0x80, 0xb2, 0x81, 0x03, + 0xae, 0xe5, 0xea, 0xbe, 0x97, 0xae, 0xec, 0x3c, 0x33, 0xc7, + 0x68, 0xf0, 0x6c, 0x89, 0x9d, 0x01, 0x2a, 0x1e, 0x2b, 0xd7, + 0x93, 0x5a, 0xa9, 0x02, 0x03, 0x01, 0x00, 0x01, 0xa3, 0x82, + 0x01, 0x52, 0x30, 0x82, 0x01, 0x4e, 0x30, 0x1f, 0x06, 0x03, + 0x55, 0x1d, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14, 0xc3, + 0x9c, 0xf3, 0xfc, 0xd3, 0x46, 0x08, 0x34, 0xbb, 0xce, 0x46, + 0x7f, 0xa0, 0x7c, 0x5b, 0xf3, 0xe2, 0x08, 0xcb, 0x59, 0x30, + 0x57, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x01, + 0x01, 0x04, 0x4b, 0x30, 0x49, 0x30, 0x1f, 0x06, 0x08, 0x2b, + 0x06, 0x01, 0x05, 0x05, 0x07, 0x30, 0x01, 0x86, 0x13, 0x68, + 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x67, 0x76, 0x2e, 0x73, + 0x79, 0x6d, 0x63, 0x64, 0x2e, 0x63, 0x6f, 0x6d, 0x30, 0x26, + 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x30, 0x02, + 0x86, 0x1a, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x67, + 0x76, 0x2e, 0x73, 0x79, 0x6d, 0x63, 0x62, 0x2e, 0x63, 0x6f, + 0x6d, 0x2f, 0x67, 0x76, 0x2e, 0x63, 0x72, 0x74, 0x30, 0x0e, + 0x06, 0x03, 0x55, 0x1d, 0x0f, 0x01, 0x01, 0xff, 0x04, 0x04, + 0x03, 0x02, 0x05, 0xa0, 0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d, + 0x25, 0x04, 0x16, 0x30, 0x14, 0x06, 0x08, 0x2b, 0x06, 0x01, + 0x05, 0x05, 0x07, 0x03, 0x01, 0x06, 0x08, 0x2b, 0x06, 0x01, + 0x05, 0x05, 0x07, 0x03, 0x02, 0x30, 0x21, 0x06, 0x03, 0x55, + 0x1d, 0x11, 0x04, 0x1a, 0x30, 0x18, 0x82, 0x0b, 0x2a, 0x2e, + 0x76, 0x75, 0x6c, 0x74, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x82, + 0x09, 0x76, 0x75, 0x6c, 0x74, 0x72, 0x2e, 0x63, 0x6f, 0x6d, + 0x30, 0x2b, 0x06, 0x03, 0x55, 0x1d, 0x1f, 0x04, 0x24, 0x30, + 0x22, 0x30, 0x20, 0xa0, 0x1e, 0xa0, 0x1c, 0x86, 0x1a, 0x68, + 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x67, 0x76, 0x2e, 0x73, + 0x79, 0x6d, 0x63, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, + 0x76, 0x2e, 0x63, 0x72, 0x6c, 0x30, 0x0c, 0x06, 0x03, 0x55, + 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04, 0x02, 0x30, 0x00, 0x30, + 0x45, 0x06, 0x03, 0x55, 0x1d, 0x20, 0x04, 0x3e, 0x30, 0x3c, + 0x30, 0x3a, 0x06, 0x0a, 0x60, 0x86, 0x48, 0x01, 0x86, 0xf8, + 0x45, 0x01, 0x07, 0x36, 0x30, 0x2c, 0x30, 0x2a, 0x06, 0x08, + 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x02, 0x01, 0x16, 0x1e, + 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x77, 0x77, + 0x77, 0x2e, 0x72, 0x61, 0x70, 0x69, 0x64, 0x73, 0x73, 0x6c, + 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6c, 0x65, 0x67, 0x61, 0x6c, + 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, + 0x01, 0x01, 0x0b, 0x05, 0x00, 0x03, 0x82, 0x01, 0x01, 0x00, + 0x93, 0x63, 0x02, 0x6a, 0xa1, 0x2a, 0xf3, 0xbe, 0x64, 0x2b, + 0x36, 0xaf, 0x66, 0x16, 0x49, 0x29, 0x56, 0x6c, 0xc7, 0x75, + 0x74, 0xf3, 0x69, 0xd8, 0x85, 0xce, 0x50, 0x3b, 0x43, 0x89, + 0xaf, 0x74, 0x99, 0x26, 0x34, 0xa4, 0x27, 0xa8, 0xfa, 0xfe, + 0x45, 0xaf, 0xbe, 0x75, 0x22, 0x3d, 0x15, 0xca, 0xa6, 0x38, + 0xc9, 0x2b, 0x3c, 0xf4, 0x11, 0x9f, 0x96, 0xa7, 0x69, 0x3e, + 0xf8, 0xf0, 0x88, 0xd8, 0xd2, 0x9c, 0x1c, 0x0e, 0x4c, 0xfd, + 0xf3, 0x3b, 0x48, 0x25, 0x68, 0xb3, 0x8d, 0x7e, 0x26, 0x73, + 0x73, 0xcb, 0x3a, 0x41, 0x92, 0x16, 0x55, 0xe1, 0xff, 0x00, + 0x07, 0xa2, 0xfe, 0xfe, 0x25, 0xfc, 0x86, 0x0f, 0x49, 0xff, + 0x96, 0x78, 0x02, 0x65, 0xd7, 0xad, 0xcd, 0x0c, 0x82, 0x35, + 0x56, 0xfe, 0x12, 0x25, 0xa9, 0x8f, 0xc2, 0xa4, 0xe9, 0x43, + 0xbb, 0x85, 0x62, 0x21, 0x62, 0x5d, 0x70, 0x76, 0x79, 0x75, + 0xeb, 0xd6, 0x82, 0x53, 0x0d, 0xde, 0x77, 0x95, 0x56, 0x87, + 0x44, 0x13, 0x82, 0x7d, 0xa9, 0x9a, 0x94, 0x7e, 0x1c, 0x6d, + 0x7f, 0x72, 0xef, 0x04, 0x84, 0xdf, 0x65, 0x98, 0x17, 0xb4, + 0xbe, 0xfe, 0x30, 0x0f, 0xfa, 0x8d, 0x9f, 0x29, 0x1d, 0xbd, + 0x99, 0xa7, 0xe3, 0x09, 0x1d, 0x13, 0x21, 0xfd, 0x9e, 0x03, + 0x17, 0xb9, 0x9e, 0x48, 0x35, 0x66, 0xe5, 0x86, 0x0a, 0x0f, + 0x04, 0xfd, 0xcd, 0x3b, 0x13, 0x59, 0xd6, 0x0c, 0x05, 0x8c, + 0xd2, 0x6b, 0x5c, 0x45, 0x33, 0x43, 0x91, 0xac, 0xb8, 0xdd, + 0xe3, 0xbe, 0xdf, 0x7b, 0x5c, 0x94, 0xa9, 0xfd, 0xc0, 0xf8, + 0xa9, 0xd2, 0x82, 0xcd, 0xbf, 0x60, 0xd7, 0xf8, 0x3d, 0x53, + 0xf7, 0x6a, 0xdc, 0x46, 0xc4, 0x22, 0x84, 0x98, 0x6a, 0x32, + 0xf2, 0xdf, 0x43, 0xd9, 0x5a, 0xdb, 0x97, 0x20, 0x05, 0x0b, + 0x3e, 0x06, 0x38, 0x13, 0x3a, 0x21 ), + FINGERPRINT ( 0x2c, 0x58, 0x63, 0x6e, 0xf1, 0xab, 0x8f, 0xff, + 0x86, 0x5d, 0x4f, 0x8d, 0x3f, 0xa9, 0x4d, 0x63, + 0xe7, 0xe6, 0xc6, 0x03, 0x1e, 0xc9, 0x0e, 0xfb, + 0xe8, 0xaa, 0xa6, 0xf4, 0x6f, 0x21, 0xc7, 0x7b ) ); + OCSP ( barclays_ocsp, &barclays_crt, &verisign_crt, DATA ( 0x30, 0x51, 0x30, 0x4f, 0x30, 0x4d, 0x30, 0x4b, 0x30, 0x49, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03, 0x02, 0x1a, 0x05, @@ -1301,12 +1548,164 @@ 0x8c, 0x3e, 0xb4, 0x66, 0x76, 0x67, 0x34, 0x70, 0x00, 0x63, 0xcf, 0x9e, 0xc8, 0xc5, 0x5f, 0x48, 0x06, 0x53, 0x26, 0x55 ) ); +OCSP ( vultr_ocsp, &vultr_crt, &rapidssl_crt, + DATA ( 0x30, 0x44, 0x30, 0x42, 0x30, 0x40, 0x30, 0x3e, 0x30, 0x3c, + 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03, 0x02, 0x1a, 0x05, + 0x00, 0x04, 0x14, 0x40, 0x0b, 0x46, 0x7a, 0xf1, 0xe6, 0xb2, + 0xd3, 0x09, 0x83, 0xba, 0x0d, 0x60, 0x7e, 0x7e, 0x59, 0x37, + 0x48, 0x24, 0xc4, 0x04, 0x14, 0xc3, 0x9c, 0xf3, 0xfc, 0xd3, + 0x46, 0x08, 0x34, 0xbb, 0xce, 0x46, 0x7f, 0xa0, 0x7c, 0x5b, + 0xf3, 0xe2, 0x08, 0xcb, 0x59, 0x02, 0x03, 0x00, 0x95, 0x4d ), + DATA ( 0x30, 0x82, 0x05, 0x70, 0x0a, 0x01, 0x00, 0xa0, 0x82, 0x05, + 0x69, 0x30, 0x82, 0x05, 0x65, 0x06, 0x09, 0x2b, 0x06, 0x01, + 0x05, 0x05, 0x07, 0x30, 0x01, 0x01, 0x04, 0x82, 0x05, 0x56, + 0x30, 0x82, 0x05, 0x52, 0x30, 0x81, 0x91, 0xa2, 0x16, 0x04, + 0x14, 0xfa, 0x58, 0xdb, 0x09, 0x53, 0xbc, 0x19, 0xc5, 0xe7, + 0xb5, 0x8b, 0xf6, 0x10, 0xf8, 0x1e, 0x84, 0x6d, 0x3a, 0x8f, + 0xd8, 0x18, 0x0f, 0x32, 0x30, 0x31, 0x34, 0x31, 0x31, 0x32, + 0x32, 0x32, 0x33, 0x30, 0x38, 0x35, 0x36, 0x5a, 0x30, 0x66, + 0x30, 0x64, 0x30, 0x3c, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, + 0x03, 0x02, 0x1a, 0x05, 0x00, 0x04, 0x14, 0x40, 0x0b, 0x46, + 0x7a, 0xf1, 0xe6, 0xb2, 0xd3, 0x09, 0x83, 0xba, 0x0d, 0x60, + 0x7e, 0x7e, 0x59, 0x37, 0x48, 0x24, 0xc4, 0x04, 0x14, 0xc3, + 0x9c, 0xf3, 0xfc, 0xd3, 0x46, 0x08, 0x34, 0xbb, 0xce, 0x46, + 0x7f, 0xa0, 0x7c, 0x5b, 0xf3, 0xe2, 0x08, 0xcb, 0x59, 0x02, + 0x03, 0x00, 0x95, 0x4d, 0x80, 0x00, 0x18, 0x0f, 0x32, 0x30, + 0x31, 0x34, 0x31, 0x31, 0x32, 0x32, 0x32, 0x33, 0x30, 0x38, + 0x35, 0x36, 0x5a, 0xa0, 0x11, 0x18, 0x0f, 0x32, 0x30, 0x31, + 0x34, 0x31, 0x31, 0x32, 0x39, 0x32, 0x33, 0x30, 0x38, 0x35, + 0x36, 0x5a, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, + 0xf7, 0x0d, 0x01, 0x01, 0x05, 0x05, 0x00, 0x03, 0x82, 0x01, + 0x01, 0x00, 0x6a, 0x71, 0x8f, 0x84, 0x66, 0xb5, 0x75, 0xe6, + 0x97, 0xa4, 0xb9, 0xc6, 0xa0, 0x37, 0x6f, 0x23, 0x76, 0x3c, + 0x59, 0x4c, 0x1c, 0x2d, 0x9f, 0x70, 0xab, 0x83, 0xbf, 0xa9, + 0xbf, 0x79, 0x31, 0x69, 0xdd, 0x78, 0xd5, 0x59, 0x90, 0x68, + 0xbe, 0x25, 0xb7, 0x53, 0x7d, 0x8b, 0xcf, 0x66, 0x3b, 0xcd, + 0xe0, 0xd2, 0x40, 0x1d, 0xc8, 0x29, 0xe4, 0x37, 0xbf, 0x20, + 0x7e, 0x64, 0x8d, 0x0d, 0xc7, 0xed, 0x0d, 0x08, 0x05, 0x36, + 0x27, 0x4f, 0xb8, 0xe3, 0x19, 0xec, 0xf0, 0x96, 0xe8, 0x48, + 0x9b, 0x8b, 0x2c, 0x18, 0xdb, 0x1e, 0x68, 0x11, 0xf3, 0xfb, + 0x9c, 0x68, 0xad, 0xcc, 0x15, 0xe0, 0x25, 0x08, 0x98, 0xd2, + 0xbf, 0xd0, 0x57, 0xe6, 0x4c, 0x73, 0x5a, 0x2c, 0xc8, 0x89, + 0xd6, 0xe4, 0xd0, 0x47, 0x6d, 0x8c, 0xc7, 0x75, 0xb1, 0x4e, + 0x10, 0x34, 0xe5, 0x40, 0xa3, 0xb1, 0x50, 0x07, 0x3d, 0x7d, + 0xad, 0xeb, 0x1d, 0x91, 0x7f, 0x77, 0x2e, 0x0d, 0x9a, 0xa7, + 0xbb, 0x68, 0x89, 0xd2, 0x05, 0x58, 0x16, 0xf1, 0x5e, 0x1d, + 0x05, 0xf6, 0x9e, 0xe9, 0x89, 0x52, 0x35, 0xb7, 0x29, 0x7a, + 0x68, 0x02, 0x6f, 0xc7, 0x20, 0x30, 0xc8, 0xde, 0x97, 0x3f, + 0xb7, 0x28, 0x38, 0x39, 0xd1, 0x4b, 0x4b, 0x90, 0x71, 0xe5, + 0x58, 0xa4, 0xa3, 0xbd, 0x78, 0x95, 0xb5, 0x54, 0xdd, 0xf7, + 0x4f, 0x8e, 0x78, 0x73, 0x86, 0xbf, 0x28, 0xb0, 0xdd, 0xc0, + 0xe9, 0x4a, 0xf5, 0x9f, 0x02, 0x8e, 0x63, 0x8f, 0x59, 0xf1, + 0x93, 0xf0, 0x45, 0x97, 0x30, 0xdb, 0x0a, 0x04, 0x3e, 0x81, + 0x99, 0x20, 0x7a, 0xb2, 0xe6, 0x8c, 0x8f, 0x2a, 0x4c, 0x31, + 0xf1, 0x64, 0xbc, 0xb7, 0xec, 0xb1, 0xf9, 0x69, 0x1f, 0x99, + 0x89, 0x3e, 0x3e, 0xa0, 0xf4, 0xde, 0x79, 0xa7, 0xae, 0xa3, + 0x23, 0xbd, 0x16, 0xbb, 0x6d, 0x0f, 0x15, 0x68, 0xa0, 0x82, + 0x03, 0xa6, 0x30, 0x82, 0x03, 0xa2, 0x30, 0x82, 0x03, 0x9e, + 0x30, 0x82, 0x02, 0x86, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, + 0x01, 0x04, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, + 0xf7, 0x0d, 0x01, 0x01, 0x0b, 0x05, 0x00, 0x30, 0x47, 0x31, + 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, + 0x55, 0x53, 0x31, 0x16, 0x30, 0x14, 0x06, 0x03, 0x55, 0x04, + 0x0a, 0x13, 0x0d, 0x47, 0x65, 0x6f, 0x54, 0x72, 0x75, 0x73, + 0x74, 0x20, 0x49, 0x6e, 0x63, 0x2e, 0x31, 0x20, 0x30, 0x1e, + 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x17, 0x52, 0x61, 0x70, + 0x69, 0x64, 0x53, 0x53, 0x4c, 0x20, 0x53, 0x48, 0x41, 0x32, + 0x35, 0x36, 0x20, 0x43, 0x41, 0x20, 0x2d, 0x20, 0x47, 0x33, + 0x30, 0x1e, 0x17, 0x0d, 0x31, 0x34, 0x30, 0x38, 0x32, 0x39, + 0x32, 0x33, 0x33, 0x39, 0x33, 0x30, 0x5a, 0x17, 0x0d, 0x31, + 0x35, 0x30, 0x35, 0x32, 0x32, 0x32, 0x33, 0x33, 0x39, 0x33, + 0x30, 0x5a, 0x30, 0x31, 0x31, 0x2f, 0x30, 0x2d, 0x06, 0x03, + 0x55, 0x04, 0x03, 0x13, 0x26, 0x52, 0x61, 0x70, 0x69, 0x64, + 0x53, 0x53, 0x4c, 0x20, 0x53, 0x48, 0x41, 0x32, 0x35, 0x36, + 0x20, 0x43, 0x41, 0x20, 0x2d, 0x20, 0x47, 0x33, 0x20, 0x4f, + 0x43, 0x53, 0x50, 0x20, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x64, 0x65, 0x72, 0x30, 0x82, 0x01, 0x22, 0x30, 0x0d, 0x06, + 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, + 0x05, 0x00, 0x03, 0x82, 0x01, 0x0f, 0x00, 0x30, 0x82, 0x01, + 0x0a, 0x02, 0x82, 0x01, 0x01, 0x00, 0x9b, 0xf2, 0x8e, 0xe9, + 0x57, 0x3e, 0xa8, 0x5c, 0xfd, 0x00, 0x14, 0x21, 0xe7, 0xe4, + 0x57, 0xbb, 0x55, 0xc8, 0xa8, 0x50, 0x93, 0xdc, 0xbf, 0xfc, + 0xde, 0x46, 0x8a, 0x53, 0x9f, 0x12, 0xaa, 0x7c, 0xf1, 0xdd, + 0x89, 0x9e, 0x02, 0x27, 0x9c, 0x1a, 0xa0, 0x94, 0xf5, 0xec, + 0x06, 0xa3, 0xdb, 0xf3, 0x3f, 0x6d, 0xfd, 0x30, 0x6d, 0xab, + 0xcb, 0xc3, 0x72, 0xa9, 0x25, 0x35, 0x69, 0x67, 0x07, 0xaf, + 0x9c, 0x91, 0x3a, 0x24, 0x03, 0x74, 0x59, 0xfd, 0x69, 0xa6, + 0xfe, 0x23, 0xa4, 0x6c, 0x2f, 0xbe, 0x44, 0x56, 0x47, 0xee, + 0xdb, 0x07, 0xc3, 0x72, 0x3f, 0x14, 0xdc, 0x16, 0xb9, 0x66, + 0x48, 0x7c, 0x6e, 0x69, 0x6f, 0xa1, 0x05, 0xc6, 0x36, 0x08, + 0x01, 0xdd, 0x1c, 0xb8, 0x52, 0xf4, 0x86, 0x96, 0x85, 0x39, + 0x89, 0xb0, 0x31, 0x67, 0x62, 0xc5, 0x52, 0x91, 0x72, 0xd7, + 0x96, 0x8c, 0xe1, 0x0a, 0x02, 0x6a, 0xfe, 0x82, 0xca, 0xc0, + 0x34, 0xc9, 0xbc, 0x45, 0xa7, 0xc0, 0x4b, 0xa0, 0x7c, 0x7c, + 0xcc, 0x29, 0xe5, 0x8c, 0xf6, 0x91, 0x65, 0x33, 0xf1, 0x7b, + 0xda, 0x55, 0x69, 0x93, 0x2d, 0x4e, 0xb9, 0xb4, 0x7f, 0x56, + 0xe6, 0x80, 0xbe, 0x23, 0x4a, 0x4a, 0x65, 0xa6, 0xab, 0xa2, + 0x40, 0xb1, 0x75, 0x62, 0x13, 0xc1, 0xfd, 0x52, 0xe1, 0xbb, + 0x7b, 0xb1, 0x7f, 0x8a, 0x0c, 0x27, 0x35, 0xec, 0x27, 0x3b, + 0xa5, 0xe7, 0x75, 0xb8, 0xe3, 0xc4, 0xcf, 0x4d, 0x8a, 0x02, + 0x57, 0x57, 0x16, 0xa2, 0x8e, 0x9d, 0x87, 0x5a, 0x32, 0xb6, + 0xf6, 0x1d, 0xf5, 0xe3, 0xd7, 0xcf, 0x79, 0xc8, 0x77, 0x74, + 0xdc, 0xe5, 0xba, 0xde, 0x5c, 0x22, 0xad, 0xc0, 0xfa, 0x67, + 0xf3, 0x26, 0xbf, 0xcc, 0xd4, 0x88, 0xd5, 0xda, 0x87, 0x4d, + 0x9d, 0x99, 0xc1, 0xce, 0xa4, 0x9a, 0xda, 0x99, 0xa5, 0xa2, + 0xe1, 0xc5, 0x02, 0x03, 0x01, 0x00, 0x01, 0xa3, 0x81, 0xaa, + 0x30, 0x81, 0xa7, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23, + 0x04, 0x18, 0x30, 0x16, 0x80, 0x14, 0xc3, 0x9c, 0xf3, 0xfc, + 0xd3, 0x46, 0x08, 0x34, 0xbb, 0xce, 0x46, 0x7f, 0xa0, 0x7c, + 0x5b, 0xf3, 0xe2, 0x08, 0xcb, 0x59, 0x30, 0x0f, 0x06, 0x09, + 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x30, 0x01, 0x05, 0x04, + 0x02, 0x05, 0x00, 0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d, 0x0e, + 0x04, 0x16, 0x04, 0x14, 0xfa, 0x58, 0xdb, 0x09, 0x53, 0xbc, + 0x19, 0xc5, 0xe7, 0xb5, 0x8b, 0xf6, 0x10, 0xf8, 0x1e, 0x84, + 0x6d, 0x3a, 0x8f, 0xd8, 0x30, 0x13, 0x06, 0x03, 0x55, 0x1d, + 0x25, 0x04, 0x0c, 0x30, 0x0a, 0x06, 0x08, 0x2b, 0x06, 0x01, + 0x05, 0x05, 0x07, 0x03, 0x09, 0x30, 0x0c, 0x06, 0x03, 0x55, + 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04, 0x02, 0x30, 0x00, 0x30, + 0x0e, 0x06, 0x03, 0x55, 0x1d, 0x0f, 0x01, 0x01, 0xff, 0x04, + 0x04, 0x03, 0x02, 0x07, 0x80, 0x30, 0x21, 0x06, 0x03, 0x55, + 0x1d, 0x11, 0x04, 0x1a, 0x30, 0x18, 0xa4, 0x16, 0x30, 0x14, + 0x31, 0x12, 0x30, 0x10, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, + 0x09, 0x54, 0x47, 0x56, 0x2d, 0x42, 0x2d, 0x32, 0x31, 0x34, + 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, + 0x01, 0x01, 0x0b, 0x05, 0x00, 0x03, 0x82, 0x01, 0x01, 0x00, + 0x3e, 0x45, 0xce, 0x3d, 0x53, 0x8c, 0x88, 0xcd, 0xde, 0xf1, + 0x38, 0x0c, 0x00, 0x7a, 0x7e, 0x22, 0xe7, 0x1a, 0xa5, 0xbe, + 0xee, 0x1c, 0x17, 0x20, 0xc3, 0x65, 0x68, 0x86, 0x27, 0x83, + 0x62, 0xd7, 0xdc, 0x1d, 0x6c, 0xfa, 0x24, 0x2e, 0x66, 0x50, + 0xe5, 0xe0, 0x42, 0xa5, 0x73, 0x67, 0x2a, 0xea, 0x5a, 0x17, + 0x20, 0x3b, 0x14, 0xd4, 0x74, 0x14, 0xbd, 0x18, 0x60, 0xbe, + 0xa6, 0x46, 0xb1, 0xc2, 0x82, 0xc9, 0xb6, 0x99, 0x67, 0x56, + 0xbe, 0x17, 0xda, 0x78, 0x05, 0x48, 0x65, 0x9d, 0x48, 0xb5, + 0xda, 0x1d, 0x52, 0x59, 0x2a, 0xac, 0x09, 0x2d, 0x29, 0x18, + 0x96, 0xc1, 0x58, 0x79, 0xfc, 0x73, 0x0b, 0x70, 0x4d, 0x31, + 0x61, 0x80, 0xc7, 0x77, 0x02, 0xf1, 0x12, 0xb3, 0x80, 0x6f, + 0xb9, 0x05, 0x69, 0xcf, 0x4f, 0x80, 0x7d, 0xf5, 0x06, 0xe6, + 0x2e, 0xc7, 0x53, 0x99, 0x8b, 0x07, 0xc7, 0x7a, 0xe6, 0xf3, + 0x12, 0x86, 0xd1, 0xbb, 0x8a, 0x8a, 0xfb, 0x9d, 0xd1, 0x0b, + 0xe7, 0x9f, 0x12, 0x06, 0xfb, 0x7d, 0x8e, 0xe7, 0xb7, 0x39, + 0xe0, 0x3c, 0xd0, 0xe8, 0x35, 0x44, 0x28, 0xb7, 0xcb, 0xee, + 0xef, 0xa7, 0x14, 0xfa, 0x0e, 0x34, 0xaf, 0x78, 0x59, 0x1e, + 0x91, 0xd9, 0xe0, 0x9b, 0x3c, 0x9e, 0x3a, 0xbf, 0xf5, 0xf5, + 0x11, 0x5b, 0x04, 0x48, 0xcd, 0x3a, 0x3f, 0xee, 0x46, 0x6d, + 0x69, 0x68, 0x39, 0xc1, 0x4d, 0x54, 0xfd, 0x6c, 0x27, 0x1e, + 0x5b, 0x58, 0x00, 0xbb, 0x4f, 0x1b, 0x12, 0xd3, 0xbb, 0x46, + 0xf4, 0x7c, 0x4a, 0x44, 0xb5, 0xcb, 0x4f, 0xf2, 0x3d, 0xc3, + 0x51, 0xfc, 0x7a, 0x2c, 0x59, 0xd0, 0x82, 0x73, 0xe3, 0x88, + 0xfc, 0x25, 0x4c, 0x35, 0x6f, 0x88, 0x85, 0xff, 0xad, 0x8c, + 0x83, 0xc4, 0x76, 0x58, 0x6b, 0xfa, 0xf2, 0xed, 0x5b, 0x95, + 0xd9, 0x07, 0x55, 0x58, 0xfe, 0x08 ) ); + /* Time at which OCSP responses are valid / static time_t test_time = 1337062083ULL; / Tue 15 May 2012 06:08:03 / /* Time at which OCSP responses are not valid / static time_t test_stale = 1375573111ULL; / Sat Aug 3 23:38:31 2013 / +/* Time at which "vultr" OCSP response (generated more recently) is valid / +static time_t test_vultr = 1416697736ULL; / Sat 22 Nov 23:08:56 2014 / + /* * Report certificate parsing test result * @@ -1398,12 +1797,15 @@ ocsp_certificate_ok ( &verisign_crt ); ocsp_certificate_ok ( &thawte_crt ); ocsp_certificate_ok ( &startssl_crt ); + ocsp_certificate_ok ( &rapidssl_crt ); + ocsp_certificate_ok ( &vultr_crt ); /* Parse OCSP checks / ocsp_check_ok ( &barclays_ocsp ); ocsp_check_ok ( &google_ocsp ); ocsp_check_ok ( &unauthorized_ocsp ); ocsp_check_ok ( &unknown_ocsp ); + ocsp_check_ok ( &vultr_ocsp ); / "barclays" test / ocsp_request_ok ( &barclays_ocsp ); @@ -1425,13 +1827,22 @@ ocsp_request_ok ( &unknown_ocsp ); ocsp_response_fail_ok ( &unknown_ocsp ); + / "vultr" test / + ocsp_request_ok ( &vultr_ocsp ); + ocsp_response_ok ( &vultr_ocsp ); + ocsp_validate_ok ( &vultr_ocsp, test_vultr ); + ocsp_validate_fail_ok ( &vultr_ocsp, test_stale ); + / Drop OCSP check references / ocsp_put ( unknown_ocsp.ocsp ); ocsp_put ( unauthorized_ocsp.ocsp ); ocsp_put ( google_ocsp.ocsp ); ocsp_put ( barclays_ocsp.ocsp ); + ocsp_put ( vultr_ocsp.ocsp ); / Drop certificate references */ + x509_put ( vultr_crt.cert ); + x509_put ( rapidssl_crt.cert ); x509_put ( startssl_crt.cert ); x509_put ( thawte_crt.cert ); x509_put ( verisign_crt.cert );
[-] [+]	Changed	_service:recompress:tar_scm:ipxe.git-1.0.0git.tar.gz/src/usr/pingmgmt.c ^
@@ -36,7 +36,7 @@ /** * Display ping result * - * @v src Source socket address + * @v src Source socket address, or NULL * @v sequence Sequence number * @v len Payload length * @v rc Status code @@ -46,7 +46,7 @@ /* Display ping response / printf ( "%zd bytes from %s: seq=%d", - len, sock_ntoa ( peer ), sequence ); + len, ( peer ? sock_ntoa ( peer ) : "<none>" ), sequence ); if ( rc != 0 ) printf ( ": %s", strerror ( rc ) ); printf ( "\n" ); @@ -58,21 +58,25 @@ @v hostname Hostname * @v timeout Timeout between pings, in ticks * @v len Payload length + * @v count Number of packets to send (or zero for no limit) + * @v quiet Inhibit output * @ret rc Return status code / -int ping ( const char hostname, unsigned long timeout, size_t len ) { +int ping ( const char hostname, unsigned long timeout, size_t len, + unsigned int count, int quiet ) { int rc; / Create pinger / - if ( ( rc = create_pinger ( &monojob, hostname, timeout, - len, ping_callback ) ) != 0 ) { + if ( ( rc = create_pinger ( &monojob, hostname, timeout, len, count, + ( quiet ? NULL : ping_callback ) ) ) != 0 ){ printf ( "Could not start ping: %s\n", strerror ( rc ) ); return rc; } / Wait for ping to complete */ if ( ( rc = monojob_wait ( NULL, 0 ) ) != 0 ) { - printf ( "Finished: %s\n", strerror ( rc ) ); + if ( ! quiet ) + printf ( "Finished: %s\n", strerror ( rc ) ); return rc; }