/* * Copyright (c) 2009, Microsoft Corporation. * * This program is free software; you can redistribute it and/or modify it * under the terms and conditions of the GNU General Public License, * version 2, as published by the Free Software Foundation. * * This program is distributed in the hope 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., 59 Temple * Place - Suite 330, Boston, MA 02111-1307 USA. * * Authors: * Haiyang Zhang * Hank Janssen */ #include #include #include #include #include #include #include #include #include #include #include "version_info.h" #include "hv_api.h" #include "logging.h" #include "vmbus.h" #include "channel.h" #include "vmbus_private.h" /* FIXME! We need to do this dynamically for PIC and APIC system */ #define VMBUS_IRQ 0x5 #define VMBUS_IRQ_VECTOR IRQ5_VECTOR /* Main vmbus driver data structure */ struct vmbus_driver_context { struct bus_type bus; struct tasklet_struct msg_dpc; struct tasklet_struct event_dpc; /* The bus root device */ struct hv_device device_ctx; }; static int vmbus_match(struct device *device, struct device_driver *driver); static int vmbus_probe(struct device *device); static int vmbus_remove(struct device *device); static void vmbus_shutdown(struct device *device); static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env); static irqreturn_t vmbus_isr(int irq, void *dev_id); static void vmbus_device_release(struct device *device); static void vmbus_bus_release(struct device *device); static ssize_t vmbus_show_device_attr(struct device *dev, struct device_attribute *dev_attr, char *buf); unsigned int vmbus_loglevel = (ALL_MODULES << 16 | INFO_LVL); EXPORT_SYMBOL(vmbus_loglevel); /* (ALL_MODULES << 16 | DEBUG_LVL_ENTEREXIT); */ /* (((VMBUS | VMBUS_DRV)<<16) | DEBUG_LVL_ENTEREXIT); */ static int vmbus_irq = VMBUS_IRQ; /* Set up per device attributes in /sys/bus/vmbus/devices/ */ static struct device_attribute vmbus_device_attrs[] = { __ATTR(id, S_IRUGO, vmbus_show_device_attr, NULL), __ATTR(state, S_IRUGO, vmbus_show_device_attr, NULL), __ATTR(class_id, S_IRUGO, vmbus_show_device_attr, NULL), __ATTR(device_id, S_IRUGO, vmbus_show_device_attr, NULL), __ATTR(monitor_id, S_IRUGO, vmbus_show_device_attr, NULL), __ATTR(server_monitor_pending, S_IRUGO, vmbus_show_device_attr, NULL), __ATTR(server_monitor_latency, S_IRUGO, vmbus_show_device_attr, NULL), __ATTR(server_monitor_conn_id, S_IRUGO, vmbus_show_device_attr, NULL), __ATTR(client_monitor_pending, S_IRUGO, vmbus_show_device_attr, NULL), __ATTR(client_monitor_latency, S_IRUGO, vmbus_show_device_attr, NULL), __ATTR(client_monitor_conn_id, S_IRUGO, vmbus_show_device_attr, NULL), __ATTR(out_intr_mask, S_IRUGO, vmbus_show_device_attr, NULL), __ATTR(out_read_index, S_IRUGO, vmbus_show_device_attr, NULL), __ATTR(out_write_index, S_IRUGO, vmbus_show_device_attr, NULL), __ATTR(out_read_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL), __ATTR(out_write_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL), __ATTR(in_intr_mask, S_IRUGO, vmbus_show_device_attr, NULL), __ATTR(in_read_index, S_IRUGO, vmbus_show_device_attr, NULL), __ATTR(in_write_index, S_IRUGO, vmbus_show_device_attr, NULL), __ATTR(in_read_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL), __ATTR(in_write_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL), __ATTR_NULL }; /* The one and only one */ static struct vmbus_driver_context vmbus_drv = { .bus.name = "vmbus", .bus.match = vmbus_match, .bus.shutdown = vmbus_shutdown, .bus.remove = vmbus_remove, .bus.probe = vmbus_probe, .bus.uevent = vmbus_uevent, .bus.dev_attrs = vmbus_device_attrs, }; static const char *driver_name = "hyperv"; /* * Windows vmbus does not defined this. * We defined this to be consistent with other devices */ /* {c5295816-f63a-4d5f-8d1a-4daf999ca185} */ static const struct hv_guid device_type = { .data = { 0x16, 0x58, 0x29, 0xc5, 0x3a, 0xf6, 0x5f, 0x4d, 0x8d, 0x1a, 0x4d, 0xaf, 0x99, 0x9c, 0xa1, 0x85 } }; /* {ac3760fc-9adf-40aa-9427-a70ed6de95c5} */ static const struct hv_guid device_id = { .data = { 0xfc, 0x60, 0x37, 0xac, 0xdf, 0x9a, 0xaa, 0x40, 0x94, 0x27, 0xa7, 0x0e, 0xd6, 0xde, 0x95, 0xc5 } }; static struct hv_device *vmbus_device; /* vmbus root device */ /* * vmbus_dev_add - Callback when the root bus device is added */ static int vmbus_dev_add(struct hv_device *dev, void *info) { u32 *irqvector = info; int ret; vmbus_device = dev; memcpy(&vmbus_device->dev_type, &device_type, sizeof(struct hv_guid)); memcpy(&vmbus_device->dev_instance, &device_id, sizeof(struct hv_guid)); /* strcpy(dev->name, "vmbus"); */ /* SynIC setup... */ on_each_cpu(hv_synic_init, (void *)irqvector, 1); /* Connect to VMBus in the root partition */ ret = vmbus_connect(); /* VmbusSendEvent(device->localPortId+1); */ return ret; } struct onmessage_work_context { struct work_struct work; struct hv_message msg; }; static void vmbus_onmessage_work(struct work_struct *work) { struct onmessage_work_context *ctx; ctx = container_of(work, struct onmessage_work_context, work); vmbus_onmessage(&ctx->msg); kfree(ctx); } /* * vmbus_on_msg_dpc - DPC routine to handle messages from the hypervisior */ static void vmbus_on_msg_dpc(unsigned long data) { int cpu = smp_processor_id(); void *page_addr = hv_context.synic_message_page[cpu]; struct hv_message *msg = (struct hv_message *)page_addr + VMBUS_MESSAGE_SINT; struct onmessage_work_context *ctx; while (1) { if (msg->header.message_type == HVMSG_NONE) { /* no msg */ break; } else { ctx = kmalloc(sizeof(*ctx), GFP_ATOMIC); if (ctx == NULL) continue; INIT_WORK(&ctx->work, vmbus_onmessage_work); memcpy(&ctx->msg, msg, sizeof(*msg)); queue_work(vmbus_connection.work_queue, &ctx->work); } msg->header.message_type = HVMSG_NONE; /* * Make sure the write to MessageType (ie set to * HVMSG_NONE) happens before we read the * MessagePending and EOMing. Otherwise, the EOMing * will not deliver any more messages since there is * no empty slot */ mb(); if (msg->header.message_flags.msg_pending) { /* * This will cause message queue rescan to * possibly deliver another msg from the * hypervisor */ wrmsrl(HV_X64_MSR_EOM, 0); } } } /* * vmbus_on_isr - ISR routine */ static int vmbus_on_isr(void) { int ret = 0; int cpu = smp_processor_id(); void *page_addr; struct hv_message *msg; union hv_synic_event_flags *event; page_addr = hv_context.synic_message_page[cpu]; msg = (struct hv_message *)page_addr + VMBUS_MESSAGE_SINT; /* Check if there are actual msgs to be process */ if (msg->header.message_type != HVMSG_NONE) { DPRINT_DBG(VMBUS, "received msg type %d size %d", msg->header.message_type, msg->header.payload_size); ret |= 0x1; } /* TODO: Check if there are events to be process */ page_addr = hv_context.synic_event_page[cpu]; event = (union hv_synic_event_flags *)page_addr + VMBUS_MESSAGE_SINT; /* Since we are a child, we only need to check bit 0 */ if (test_and_clear_bit(0, (unsigned long *) &event->flags32[0])) { DPRINT_DBG(VMBUS, "received event %d", event->flags32[0]); ret |= 0x2; } return ret; } static void get_channel_info(struct hv_device *device, struct hv_device_info *info) { struct vmbus_channel_debug_info debug_info; if (!device->channel) return; vmbus_get_debug_info(device->channel, &debug_info); info->chn_id = debug_info.relid; info->chn_state = debug_info.state; memcpy(&info->chn_type, &debug_info.interfacetype, sizeof(struct hv_guid)); memcpy(&info->chn_instance, &debug_info.interface_instance, sizeof(struct hv_guid)); info->monitor_id = debug_info.monitorid; info->server_monitor_pending = debug_info.servermonitor_pending; info->server_monitor_latency = debug_info.servermonitor_latency; info->server_monitor_conn_id = debug_info.servermonitor_connectionid; info->client_monitor_pending = debug_info.clientmonitor_pending; info->client_monitor_latency = debug_info.clientmonitor_latency; info->client_monitor_conn_id = debug_info.clientmonitor_connectionid; info->inbound.int_mask = debug_info.inbound.current_interrupt_mask; info->inbound.read_idx = debug_info.inbound.current_read_index; info->inbound.write_idx = debug_info.inbound.current_write_index; info->inbound.bytes_avail_toread = debug_info.inbound.bytes_avail_toread; info->inbound.bytes_avail_towrite = debug_info.inbound.bytes_avail_towrite; info->outbound.int_mask = debug_info.outbound.current_interrupt_mask; info->outbound.read_idx = debug_info.outbound.current_read_index; info->outbound.write_idx = debug_info.outbound.current_write_index; info->outbound.bytes_avail_toread = debug_info.outbound.bytes_avail_toread; info->outbound.bytes_avail_towrite = debug_info.outbound.bytes_avail_towrite; } /* * vmbus_show_device_attr - Show the device attribute in sysfs. * * This is invoked when user does a * "cat /sys/bus/vmbus/devices//" */ static ssize_t vmbus_show_device_attr(struct device *dev, struct device_attribute *dev_attr, char *buf) { struct hv_device *device_ctx = device_to_hv_device(dev); struct hv_device_info device_info; memset(&device_info, 0, sizeof(struct hv_device_info)); get_channel_info(device_ctx, &device_info); if (!strcmp(dev_attr->attr.name, "class_id")) { return sprintf(buf, "{%02x%02x%02x%02x-%02x%02x-%02x%02x-" "%02x%02x%02x%02x%02x%02x%02x%02x}\n", device_info.chn_type.data[3], device_info.chn_type.data[2], device_info.chn_type.data[1], device_info.chn_type.data[0], device_info.chn_type.data[5], device_info.chn_type.data[4], device_info.chn_type.data[7], device_info.chn_type.data[6], device_info.chn_type.data[8], device_info.chn_type.data[9], device_info.chn_type.data[10], device_info.chn_type.data[11], device_info.chn_type.data[12], device_info.chn_type.data[13], device_info.chn_type.data[14], device_info.chn_type.data[15]); } else if (!strcmp(dev_attr->attr.name, "device_id")) { return sprintf(buf, "{%02x%02x%02x%02x-%02x%02x-%02x%02x-" "%02x%02x%02x%02x%02x%02x%02x%02x}\n", device_info.chn_instance.data[3], device_info.chn_instance.data[2], device_info.chn_instance.data[1], device_info.chn_instance.data[0], device_info.chn_instance.data[5], device_info.chn_instance.data[4], device_info.chn_instance.data[7], device_info.chn_instance.data[6], device_info.chn_instance.data[8], device_info.chn_instance.data[9], device_info.chn_instance.data[10], device_info.chn_instance.data[11], device_info.chn_instance.data[12], device_info.chn_instance.data[13], device_info.chn_instance.data[14], device_info.chn_instance.data[15]); } else if (!strcmp(dev_attr->attr.name, "state")) { return sprintf(buf, "%d\n", device_info.chn_state); } else if (!strcmp(dev_attr->attr.name, "id")) { return sprintf(buf, "%d\n", device_info.chn_id); } else if (!strcmp(dev_attr->attr.name, "out_intr_mask")) { return sprintf(buf, "%d\n", device_info.outbound.int_mask); } else if (!strcmp(dev_attr->attr.name, "out_read_index")) { return sprintf(buf, "%d\n", device_info.outbound.read_idx); } else if (!strcmp(dev_attr->attr.name, "out_write_index")) { return sprintf(buf, "%d\n", device_info.outbound.write_idx); } else if (!strcmp(dev_attr->attr.name, "out_read_bytes_avail")) { return sprintf(buf, "%d\n", device_info.outbound.bytes_avail_toread); } else if (!strcmp(dev_attr->attr.name, "out_write_bytes_avail")) { return sprintf(buf, "%d\n", device_info.outbound.bytes_avail_towrite); } else if (!strcmp(dev_attr->attr.name, "in_intr_mask")) { return sprintf(buf, "%d\n", device_info.inbound.int_mask); } else if (!strcmp(dev_attr->attr.name, "in_read_index")) { return sprintf(buf, "%d\n", device_info.inbound.read_idx); } else if (!strcmp(dev_attr->attr.name, "in_write_index")) { return sprintf(buf, "%d\n", device_info.inbound.write_idx); } else if (!strcmp(dev_attr->attr.name, "in_read_bytes_avail")) { return sprintf(buf, "%d\n", device_info.inbound.bytes_avail_toread); } else if (!strcmp(dev_attr->attr.name, "in_write_bytes_avail")) { return sprintf(buf, "%d\n", device_info.inbound.bytes_avail_towrite); } else if (!strcmp(dev_attr->attr.name, "monitor_id")) { return sprintf(buf, "%d\n", device_info.monitor_id); } else if (!strcmp(dev_attr->attr.name, "server_monitor_pending")) { return sprintf(buf, "%d\n", device_info.server_monitor_pending); } else if (!strcmp(dev_attr->attr.name, "server_monitor_latency")) { return sprintf(buf, "%d\n", device_info.server_monitor_latency); } else if (!strcmp(dev_attr->attr.name, "server_monitor_conn_id")) { return sprintf(buf, "%d\n", device_info.server_monitor_conn_id); } else if (!strcmp(dev_attr->attr.name, "client_monitor_pending")) { return sprintf(buf, "%d\n", device_info.client_monitor_pending); } else if (!strcmp(dev_attr->attr.name, "client_monitor_latency")) { return sprintf(buf, "%d\n", device_info.client_monitor_latency); } else if (!strcmp(dev_attr->attr.name, "client_monitor_conn_id")) { return sprintf(buf, "%d\n", device_info.client_monitor_conn_id); } else { return 0; } } /* * vmbus_bus_init -Main vmbus driver initialization routine. * * Here, we * - initialize the vmbus driver context * - setup various driver entry points * - invoke the vmbus hv main init routine * - get the irq resource * - invoke the vmbus to add the vmbus root device * - setup the vmbus root device * - retrieve the channel offers */ static int vmbus_bus_init(void) { struct vmbus_driver_context *vmbus_drv_ctx = &vmbus_drv; struct hv_device *dev_ctx = &vmbus_drv.device_ctx; int ret; unsigned int vector; DPRINT_INFO(VMBUS, "+++++++ HV Driver version = %s +++++++", HV_DRV_VERSION); DPRINT_INFO(VMBUS, "+++++++ Vmbus supported version = %d +++++++", VMBUS_REVISION_NUMBER); DPRINT_INFO(VMBUS, "+++++++ Vmbus using SINT %d +++++++", VMBUS_MESSAGE_SINT); DPRINT_DBG(VMBUS, "sizeof(vmbus_channel_packet_page_buffer)=%zd, " "sizeof(VMBUS_CHANNEL_PACKET_MULITPAGE_BUFFER)=%zd", sizeof(struct vmbus_channel_packet_page_buffer), sizeof(struct vmbus_channel_packet_multipage_buffer)); /* Hypervisor initialization...setup hypercall page..etc */ ret = hv_init(); if (ret != 0) { DPRINT_ERR(VMBUS, "Unable to initialize the hypervisor - 0x%x", ret); goto cleanup; } vmbus_drv_ctx->bus.name = driver_name; /* Initialize the bus context */ tasklet_init(&vmbus_drv_ctx->msg_dpc, vmbus_on_msg_dpc, (unsigned long)NULL); tasklet_init(&vmbus_drv_ctx->event_dpc, vmbus_on_event, (unsigned long)NULL); /* Now, register the bus with LDM */ ret = bus_register(&vmbus_drv_ctx->bus); if (ret) { ret = -1; goto cleanup; } /* Get the interrupt resource */ ret = request_irq(vmbus_irq, vmbus_isr, IRQF_SAMPLE_RANDOM, driver_name, NULL); if (ret != 0) { DPRINT_ERR(VMBUS_DRV, "ERROR - Unable to request IRQ %d", vmbus_irq); bus_unregister(&vmbus_drv_ctx->bus); ret = -1; goto cleanup; } vector = VMBUS_IRQ_VECTOR; DPRINT_INFO(VMBUS_DRV, "irq 0x%x vector 0x%x", vmbus_irq, vector); /* Add the root device */ memset(dev_ctx, 0, sizeof(struct hv_device)); ret = vmbus_dev_add(dev_ctx, &vector); if (ret != 0) { DPRINT_ERR(VMBUS_DRV, "ERROR - Unable to add vmbus root device"); free_irq(vmbus_irq, NULL); bus_unregister(&vmbus_drv_ctx->bus); ret = -1; goto cleanup; } /* strcpy(dev_ctx->device.bus_id, dev_ctx->device_obj.name); */ dev_set_name(&dev_ctx->device, "vmbus_0_0"); /* No need to bind a driver to the root device. */ dev_ctx->device.parent = NULL; /* NULL; vmbus_remove() does not get invoked */ dev_ctx->device.bus = &vmbus_drv_ctx->bus; /* Setup the device dispatch table */ dev_ctx->device.release = vmbus_bus_release; /* register the root device */ ret = device_register(&dev_ctx->device); if (ret) { DPRINT_ERR(VMBUS_DRV, "ERROR - Unable to register vmbus root device"); free_irq(vmbus_irq, NULL); bus_unregister(&vmbus_drv_ctx->bus); ret = -1; goto cleanup; } vmbus_request_offers(); wait_for_completion(&hv_channel_ready); cleanup: return ret; } /* * vmbus_bus_exit - Terminate the vmbus driver. * * This routine is opposite of vmbus_bus_init() */ static void vmbus_bus_exit(void) { struct vmbus_driver_context *vmbus_drv_ctx = &vmbus_drv; struct hv_device *dev_ctx = &vmbus_drv.device_ctx; vmbus_release_unattached_channels(); vmbus_disconnect(); on_each_cpu(hv_synic_cleanup, NULL, 1); hv_cleanup(); /* Unregister the root bus device */ device_unregister(&dev_ctx->device); bus_unregister(&vmbus_drv_ctx->bus); free_irq(vmbus_irq, NULL); tasklet_kill(&vmbus_drv_ctx->msg_dpc); tasklet_kill(&vmbus_drv_ctx->event_dpc); } /** * vmbus_child_driver_register() - Register a vmbus's child driver * @drv: Pointer to driver structure you want to register * * * Registers the given driver with Linux through the 'driver_register()' call * And sets up the hyper-v vmbus handling for this driver. * It will return the state of the 'driver_register()' call. * * Mainly used by Hyper-V drivers. */ int vmbus_child_driver_register(struct device_driver *drv) { int ret; DPRINT_INFO(VMBUS_DRV, "child driver (%p) registering - name %s", drv, drv->name); /* The child driver on this vmbus */ drv->bus = &vmbus_drv.bus; ret = driver_register(drv); vmbus_request_offers(); return ret; } EXPORT_SYMBOL(vmbus_child_driver_register); /** * vmbus_child_driver_unregister() - Unregister a vmbus's child driver * @drv: Pointer to driver structure you want to un-register * * * Un-register the given driver with Linux through the 'driver_unregister()' * call. And ungegisters the driver from the Hyper-V vmbus handler. * * Mainly used by Hyper-V drivers. */ void vmbus_child_driver_unregister(struct device_driver *drv) { DPRINT_INFO(VMBUS_DRV, "child driver (%p) unregistering - name %s", drv, drv->name); driver_unregister(drv); drv->bus = NULL; } EXPORT_SYMBOL(vmbus_child_driver_unregister); /* * vmbus_child_device_create - Creates and registers a new child device * on the vmbus. */ struct hv_device *vmbus_child_device_create(struct hv_guid *type, struct hv_guid *instance, struct vmbus_channel *channel) { struct hv_device *child_device_obj; /* Allocate the new child device */ child_device_obj = kzalloc(sizeof(struct hv_device), GFP_KERNEL); if (!child_device_obj) { DPRINT_ERR(VMBUS_DRV, "unable to allocate device_context for child device"); return NULL; } DPRINT_DBG(VMBUS_DRV, "child device (%p) allocated - " "type {%02x%02x%02x%02x-%02x%02x-%02x%02x-" "%02x%02x%02x%02x%02x%02x%02x%02x}," "id {%02x%02x%02x%02x-%02x%02x-%02x%02x-" "%02x%02x%02x%02x%02x%02x%02x%02x}", &child_device_obj->device, type->data[3], type->data[2], type->data[1], type->data[0], type->data[5], type->data[4], type->data[7], type->data[6], type->data[8], type->data[9], type->data[10], type->data[11], type->data[12], type->data[13], type->data[14], type->data[15], instance->data[3], instance->data[2], instance->data[1], instance->data[0], instance->data[5], instance->data[4], instance->data[7], instance->data[6], instance->data[8], instance->data[9], instance->data[10], instance->data[11], instance->data[12], instance->data[13], instance->data[14], instance->data[15]); child_device_obj->channel = channel; memcpy(&child_device_obj->dev_type, type, sizeof(struct hv_guid)); memcpy(&child_device_obj->dev_instance, instance, sizeof(struct hv_guid)); return child_device_obj; } /* * vmbus_child_device_register - Register the child device */ int vmbus_child_device_register(struct hv_device *child_device_obj) { int ret = 0; static atomic_t device_num = ATOMIC_INIT(0); DPRINT_DBG(VMBUS_DRV, "child device (%p) registering", child_device_obj); /* Set the device name. Otherwise, device_register() will fail. */ dev_set_name(&child_device_obj->device, "vmbus_0_%d", atomic_inc_return(&device_num)); /* The new device belongs to this bus */ child_device_obj->device.bus = &vmbus_drv.bus; /* device->dev.bus; */ child_device_obj->device.parent = &vmbus_device->device; child_device_obj->device.release = vmbus_device_release; /* * Register with the LDM. This will kick off the driver/device * binding...which will eventually call vmbus_match() and vmbus_probe() */ ret = device_register(&child_device_obj->device); /* vmbus_probe() error does not get propergate to device_register(). */ ret = child_device_obj->probe_error; if (ret) DPRINT_ERR(VMBUS_DRV, "unable to register child device (%p)", &child_device_obj->device); else DPRINT_INFO(VMBUS_DRV, "child device (%p) registered", &child_device_obj->device); return ret; } /* * vmbus_child_device_unregister - Remove the specified child device * from the vmbus. */ void vmbus_child_device_unregister(struct hv_device *device_obj) { DPRINT_INFO(VMBUS_DRV, "unregistering child device (%p)", &device_obj->device); /* * Kick off the process of unregistering the device. * This will call vmbus_remove() and eventually vmbus_device_release() */ device_unregister(&device_obj->device); DPRINT_INFO(VMBUS_DRV, "child device (%p) unregistered", &device_obj->device); } /* * vmbus_uevent - add uevent for our device * * This routine is invoked when a device is added or removed on the vmbus to * generate a uevent to udev in the userspace. The udev will then look at its * rule and the uevent generated here to load the appropriate driver */ static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env) { struct hv_device *dev = device_to_hv_device(device); int ret; DPRINT_INFO(VMBUS_DRV, "generating uevent - VMBUS_DEVICE_CLASS_GUID={" "%02x%02x%02x%02x-%02x%02x-%02x%02x-" "%02x%02x%02x%02x%02x%02x%02x%02x}", dev->dev_type.data[3], dev->dev_type.data[2], dev->dev_type.data[1], dev->dev_type.data[0], dev->dev_type.data[5], dev->dev_type.data[4], dev->dev_type.data[7], dev->dev_type.data[6], dev->dev_type.data[8], dev->dev_type.data[9], dev->dev_type.data[10], dev->dev_type.data[11], dev->dev_type.data[12], dev->dev_type.data[13], dev->dev_type.data[14], dev->dev_type.data[15]); ret = add_uevent_var(env, "VMBUS_DEVICE_CLASS_GUID={" "%02x%02x%02x%02x-%02x%02x-%02x%02x-" "%02x%02x%02x%02x%02x%02x%02x%02x}", dev->dev_type.data[3], dev->dev_type.data[2], dev->dev_type.data[1], dev->dev_type.data[0], dev->dev_type.data[5], dev->dev_type.data[4], dev->dev_type.data[7], dev->dev_type.data[6], dev->dev_type.data[8], dev->dev_type.data[9], dev->dev_type.data[10], dev->dev_type.data[11], dev->dev_type.data[12], dev->dev_type.data[13], dev->dev_type.data[14], dev->dev_type.data[15]); if (ret) return ret; ret = add_uevent_var(env, "VMBUS_DEVICE_DEVICE_GUID={" "%02x%02x%02x%02x-%02x%02x-%02x%02x-" "%02x%02x%02x%02x%02x%02x%02x%02x}", dev->dev_instance.data[3], dev->dev_instance.data[2], dev->dev_instance.data[1], dev->dev_instance.data[0], dev->dev_instance.data[5], dev->dev_instance.data[4], dev->dev_instance.data[7], dev->dev_instance.data[6], dev->dev_instance.data[8], dev->dev_instance.data[9], dev->dev_instance.data[10], dev->dev_instance.data[11], dev->dev_instance.data[12], dev->dev_instance.data[13], dev->dev_instance.data[14], dev->dev_instance.data[15]); if (ret) return ret; return 0; } /* * vmbus_match - Attempt to match the specified device to the specified driver */ static int vmbus_match(struct device *device, struct device_driver *driver) { int match = 0; struct hv_driver *drv = drv_to_hv_drv(driver); struct hv_device *device_ctx = device_to_hv_device(device); /* We found our driver ? */ if (memcmp(&device_ctx->dev_type, &drv->dev_type, sizeof(struct hv_guid)) == 0) { device_ctx->drv = drv->priv; DPRINT_INFO(VMBUS_DRV, "device object (%p) set to driver object (%p)", &device_ctx, device_ctx->drv); match = 1; } return match; } /* * vmbus_probe_failed_cb - Callback when a driver probe failed in vmbus_probe() * * We need a callback because we cannot invoked device_unregister() inside * vmbus_probe() since vmbus_probe() may be invoked inside device_register() * i.e. we cannot call device_unregister() inside device_register() */ static void vmbus_probe_failed_cb(struct work_struct *context) { struct hv_device *device_ctx = (struct hv_device *)context; /* * Kick off the process of unregistering the device. * This will call vmbus_remove() and eventually vmbus_device_release() */ device_unregister(&device_ctx->device); /* put_device(&device_ctx->device); */ } /* * vmbus_probe - Add the new vmbus's child device */ static int vmbus_probe(struct device *child_device) { int ret = 0; struct hv_driver *drv = drv_to_hv_drv(child_device->driver); struct hv_device *dev = device_to_hv_device(child_device); /* Let the specific open-source driver handles the probe if it can */ if (drv->driver.probe) { ret = dev->probe_error = drv->driver.probe(child_device); if (ret != 0) { DPRINT_ERR(VMBUS_DRV, "probe() failed for device %s " "(%p) on driver %s (%d)...", dev_name(child_device), child_device, child_device->driver->name, ret); INIT_WORK(&dev->probe_failed_work_item, vmbus_probe_failed_cb); schedule_work(&dev->probe_failed_work_item); } } else { DPRINT_ERR(VMBUS_DRV, "probe() method not set for driver - %s", child_device->driver->name); ret = -1; } return ret; } /* * vmbus_remove - Remove a vmbus device */ static int vmbus_remove(struct device *child_device) { int ret; struct hv_driver *drv; /* Special case root bus device */ if (child_device->parent == NULL) { /* * No-op since it is statically defined and handle in * vmbus_bus_exit() */ return 0; } if (child_device->driver) { drv = drv_to_hv_drv(child_device->driver); /* * Let the specific open-source driver handles the removal if * it can */ if (drv->driver.remove) { ret = drv->driver.remove(child_device); } else { DPRINT_ERR(VMBUS_DRV, "remove() method not set for driver - %s", child_device->driver->name); ret = -1; } } return 0; } /* * vmbus_shutdown - Shutdown a vmbus device */ static void vmbus_shutdown(struct device *child_device) { struct hv_driver *drv; /* Special case root bus device */ if (child_device->parent == NULL) { /* * No-op since it is statically defined and handle in * vmbus_bus_exit() */ return; } /* The device may not be attached yet */ if (!child_device->driver) return; drv = drv_to_hv_drv(child_device->driver); /* Let the specific open-source driver handles the removal if it can */ if (drv->driver.shutdown) drv->driver.shutdown(child_device); return; } /* * vmbus_bus_release - Final callback release of the vmbus root device */ static void vmbus_bus_release(struct device *device) { /* FIXME */ /* Empty release functions are a bug, or a major sign * of a problem design, this MUST BE FIXED! */ dev_err(device, "%s needs to be fixed!\n", __func__); WARN_ON(1); } /* * vmbus_device_release - Final callback release of the vmbus child device */ static void vmbus_device_release(struct device *device) { struct hv_device *device_ctx = device_to_hv_device(device); kfree(device_ctx); /* !!DO NOT REFERENCE device_ctx anymore at this point!! */ } static irqreturn_t vmbus_isr(int irq, void *dev_id) { int ret; ret = vmbus_on_isr(); /* Schedules a dpc if necessary */ if (ret > 0) { if (test_bit(0, (unsigned long *)&ret)) tasklet_schedule(&vmbus_drv.msg_dpc); if (test_bit(1, (unsigned long *)&ret)) tasklet_schedule(&vmbus_drv.event_dpc); return IRQ_HANDLED; } else { return IRQ_NONE; } } static struct dmi_system_id __initdata microsoft_hv_dmi_table[] = { { .ident = "Hyper-V", .matches = { DMI_MATCH(DMI_SYS_VENDOR, "Microsoft Corporation"), DMI_MATCH(DMI_PRODUCT_NAME, "Virtual Machine"), DMI_MATCH(DMI_BOARD_NAME, "Virtual Machine"), }, }, { }, }; MODULE_DEVICE_TABLE(dmi, microsoft_hv_dmi_table); static int __init vmbus_init(void) { DPRINT_INFO(VMBUS_DRV, "Vmbus initializing.... current log level 0x%x (%x,%x)", vmbus_loglevel, HIWORD(vmbus_loglevel), LOWORD(vmbus_loglevel)); /* Todo: it is used for loglevel, to be ported to new kernel. */ if (!dmi_check_system(microsoft_hv_dmi_table)) return -ENODEV; return vmbus_bus_init(); } static void __exit vmbus_exit(void) { vmbus_bus_exit(); /* Todo: it is used for loglevel, to be ported to new kernel. */ } /* * We use a PCI table to determine if we should autoload this driver This is * needed by distro tools to determine if the hyperv drivers should be * installed and/or configured. We don't do anything else with the table, but * it needs to be present. */ static const struct pci_device_id microsoft_hv_pci_table[] = { { PCI_DEVICE(0x1414, 0x5353) }, /* VGA compatible controller */ { 0 } }; MODULE_DEVICE_TABLE(pci, microsoft_hv_pci_table); MODULE_LICENSE("GPL"); MODULE_VERSION(HV_DRV_VERSION); module_param(vmbus_irq, int, S_IRUGO); module_param(vmbus_loglevel, int, S_IRUGO); module_init(vmbus_init); module_exit(vmbus_exit);