Version:  2.6.34 2.6.35 2.6.36 2.6.37 2.6.38 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14

Linux/drivers/hv/vmbus_drv.c

  1 /*
  2  * Copyright (c) 2009, Microsoft Corporation.
  3  *
  4  * This program is free software; you can redistribute it and/or modify it
  5  * under the terms and conditions of the GNU General Public License,
  6  * version 2, as published by the Free Software Foundation.
  7  *
  8  * This program is distributed in the hope it will be useful, but WITHOUT
  9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 11  * more details.
 12  *
 13  * You should have received a copy of the GNU General Public License along with
 14  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
 15  * Place - Suite 330, Boston, MA 02111-1307 USA.
 16  *
 17  * Authors:
 18  *   Haiyang Zhang <haiyangz@microsoft.com>
 19  *   Hank Janssen  <hjanssen@microsoft.com>
 20  *   K. Y. Srinivasan <kys@microsoft.com>
 21  *
 22  */
 23 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 24 
 25 #include <linux/init.h>
 26 #include <linux/module.h>
 27 #include <linux/device.h>
 28 #include <linux/irq.h>
 29 #include <linux/interrupt.h>
 30 #include <linux/sysctl.h>
 31 #include <linux/slab.h>
 32 #include <linux/acpi.h>
 33 #include <linux/completion.h>
 34 #include <linux/hyperv.h>
 35 #include <linux/kernel_stat.h>
 36 #include <asm/hyperv.h>
 37 #include <asm/hypervisor.h>
 38 #include <asm/mshyperv.h>
 39 #include "hyperv_vmbus.h"
 40 
 41 static struct acpi_device  *hv_acpi_dev;
 42 
 43 static struct tasklet_struct msg_dpc;
 44 static struct completion probe_event;
 45 static int irq;
 46 
 47 static int vmbus_exists(void)
 48 {
 49         if (hv_acpi_dev == NULL)
 50                 return -ENODEV;
 51 
 52         return 0;
 53 }
 54 
 55 #define VMBUS_ALIAS_LEN ((sizeof((struct hv_vmbus_device_id *)0)->guid) * 2)
 56 static void print_alias_name(struct hv_device *hv_dev, char *alias_name)
 57 {
 58         int i;
 59         for (i = 0; i < VMBUS_ALIAS_LEN; i += 2)
 60                 sprintf(&alias_name[i], "%02x", hv_dev->dev_type.b[i/2]);
 61 }
 62 
 63 static u8 channel_monitor_group(struct vmbus_channel *channel)
 64 {
 65         return (u8)channel->offermsg.monitorid / 32;
 66 }
 67 
 68 static u8 channel_monitor_offset(struct vmbus_channel *channel)
 69 {
 70         return (u8)channel->offermsg.monitorid % 32;
 71 }
 72 
 73 static u32 channel_pending(struct vmbus_channel *channel,
 74                            struct hv_monitor_page *monitor_page)
 75 {
 76         u8 monitor_group = channel_monitor_group(channel);
 77         return monitor_page->trigger_group[monitor_group].pending;
 78 }
 79 
 80 static u32 channel_latency(struct vmbus_channel *channel,
 81                            struct hv_monitor_page *monitor_page)
 82 {
 83         u8 monitor_group = channel_monitor_group(channel);
 84         u8 monitor_offset = channel_monitor_offset(channel);
 85         return monitor_page->latency[monitor_group][monitor_offset];
 86 }
 87 
 88 static u32 channel_conn_id(struct vmbus_channel *channel,
 89                            struct hv_monitor_page *monitor_page)
 90 {
 91         u8 monitor_group = channel_monitor_group(channel);
 92         u8 monitor_offset = channel_monitor_offset(channel);
 93         return monitor_page->parameter[monitor_group][monitor_offset].connectionid.u.id;
 94 }
 95 
 96 static ssize_t id_show(struct device *dev, struct device_attribute *dev_attr,
 97                        char *buf)
 98 {
 99         struct hv_device *hv_dev = device_to_hv_device(dev);
100 
101         if (!hv_dev->channel)
102                 return -ENODEV;
103         return sprintf(buf, "%d\n", hv_dev->channel->offermsg.child_relid);
104 }
105 static DEVICE_ATTR_RO(id);
106 
107 static ssize_t state_show(struct device *dev, struct device_attribute *dev_attr,
108                           char *buf)
109 {
110         struct hv_device *hv_dev = device_to_hv_device(dev);
111 
112         if (!hv_dev->channel)
113                 return -ENODEV;
114         return sprintf(buf, "%d\n", hv_dev->channel->state);
115 }
116 static DEVICE_ATTR_RO(state);
117 
118 static ssize_t monitor_id_show(struct device *dev,
119                                struct device_attribute *dev_attr, char *buf)
120 {
121         struct hv_device *hv_dev = device_to_hv_device(dev);
122 
123         if (!hv_dev->channel)
124                 return -ENODEV;
125         return sprintf(buf, "%d\n", hv_dev->channel->offermsg.monitorid);
126 }
127 static DEVICE_ATTR_RO(monitor_id);
128 
129 static ssize_t class_id_show(struct device *dev,
130                                struct device_attribute *dev_attr, char *buf)
131 {
132         struct hv_device *hv_dev = device_to_hv_device(dev);
133 
134         if (!hv_dev->channel)
135                 return -ENODEV;
136         return sprintf(buf, "{%pUl}\n",
137                        hv_dev->channel->offermsg.offer.if_type.b);
138 }
139 static DEVICE_ATTR_RO(class_id);
140 
141 static ssize_t device_id_show(struct device *dev,
142                               struct device_attribute *dev_attr, char *buf)
143 {
144         struct hv_device *hv_dev = device_to_hv_device(dev);
145 
146         if (!hv_dev->channel)
147                 return -ENODEV;
148         return sprintf(buf, "{%pUl}\n",
149                        hv_dev->channel->offermsg.offer.if_instance.b);
150 }
151 static DEVICE_ATTR_RO(device_id);
152 
153 static ssize_t modalias_show(struct device *dev,
154                              struct device_attribute *dev_attr, char *buf)
155 {
156         struct hv_device *hv_dev = device_to_hv_device(dev);
157         char alias_name[VMBUS_ALIAS_LEN + 1];
158 
159         print_alias_name(hv_dev, alias_name);
160         return sprintf(buf, "vmbus:%s\n", alias_name);
161 }
162 static DEVICE_ATTR_RO(modalias);
163 
164 static ssize_t server_monitor_pending_show(struct device *dev,
165                                            struct device_attribute *dev_attr,
166                                            char *buf)
167 {
168         struct hv_device *hv_dev = device_to_hv_device(dev);
169 
170         if (!hv_dev->channel)
171                 return -ENODEV;
172         return sprintf(buf, "%d\n",
173                        channel_pending(hv_dev->channel,
174                                        vmbus_connection.monitor_pages[1]));
175 }
176 static DEVICE_ATTR_RO(server_monitor_pending);
177 
178 static ssize_t client_monitor_pending_show(struct device *dev,
179                                            struct device_attribute *dev_attr,
180                                            char *buf)
181 {
182         struct hv_device *hv_dev = device_to_hv_device(dev);
183 
184         if (!hv_dev->channel)
185                 return -ENODEV;
186         return sprintf(buf, "%d\n",
187                        channel_pending(hv_dev->channel,
188                                        vmbus_connection.monitor_pages[1]));
189 }
190 static DEVICE_ATTR_RO(client_monitor_pending);
191 
192 static ssize_t server_monitor_latency_show(struct device *dev,
193                                            struct device_attribute *dev_attr,
194                                            char *buf)
195 {
196         struct hv_device *hv_dev = device_to_hv_device(dev);
197 
198         if (!hv_dev->channel)
199                 return -ENODEV;
200         return sprintf(buf, "%d\n",
201                        channel_latency(hv_dev->channel,
202                                        vmbus_connection.monitor_pages[0]));
203 }
204 static DEVICE_ATTR_RO(server_monitor_latency);
205 
206 static ssize_t client_monitor_latency_show(struct device *dev,
207                                            struct device_attribute *dev_attr,
208                                            char *buf)
209 {
210         struct hv_device *hv_dev = device_to_hv_device(dev);
211 
212         if (!hv_dev->channel)
213                 return -ENODEV;
214         return sprintf(buf, "%d\n",
215                        channel_latency(hv_dev->channel,
216                                        vmbus_connection.monitor_pages[1]));
217 }
218 static DEVICE_ATTR_RO(client_monitor_latency);
219 
220 static ssize_t server_monitor_conn_id_show(struct device *dev,
221                                            struct device_attribute *dev_attr,
222                                            char *buf)
223 {
224         struct hv_device *hv_dev = device_to_hv_device(dev);
225 
226         if (!hv_dev->channel)
227                 return -ENODEV;
228         return sprintf(buf, "%d\n",
229                        channel_conn_id(hv_dev->channel,
230                                        vmbus_connection.monitor_pages[0]));
231 }
232 static DEVICE_ATTR_RO(server_monitor_conn_id);
233 
234 static ssize_t client_monitor_conn_id_show(struct device *dev,
235                                            struct device_attribute *dev_attr,
236                                            char *buf)
237 {
238         struct hv_device *hv_dev = device_to_hv_device(dev);
239 
240         if (!hv_dev->channel)
241                 return -ENODEV;
242         return sprintf(buf, "%d\n",
243                        channel_conn_id(hv_dev->channel,
244                                        vmbus_connection.monitor_pages[1]));
245 }
246 static DEVICE_ATTR_RO(client_monitor_conn_id);
247 
248 static ssize_t out_intr_mask_show(struct device *dev,
249                                   struct device_attribute *dev_attr, char *buf)
250 {
251         struct hv_device *hv_dev = device_to_hv_device(dev);
252         struct hv_ring_buffer_debug_info outbound;
253 
254         if (!hv_dev->channel)
255                 return -ENODEV;
256         hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
257         return sprintf(buf, "%d\n", outbound.current_interrupt_mask);
258 }
259 static DEVICE_ATTR_RO(out_intr_mask);
260 
261 static ssize_t out_read_index_show(struct device *dev,
262                                    struct device_attribute *dev_attr, char *buf)
263 {
264         struct hv_device *hv_dev = device_to_hv_device(dev);
265         struct hv_ring_buffer_debug_info outbound;
266 
267         if (!hv_dev->channel)
268                 return -ENODEV;
269         hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
270         return sprintf(buf, "%d\n", outbound.current_read_index);
271 }
272 static DEVICE_ATTR_RO(out_read_index);
273 
274 static ssize_t out_write_index_show(struct device *dev,
275                                     struct device_attribute *dev_attr,
276                                     char *buf)
277 {
278         struct hv_device *hv_dev = device_to_hv_device(dev);
279         struct hv_ring_buffer_debug_info outbound;
280 
281         if (!hv_dev->channel)
282                 return -ENODEV;
283         hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
284         return sprintf(buf, "%d\n", outbound.current_write_index);
285 }
286 static DEVICE_ATTR_RO(out_write_index);
287 
288 static ssize_t out_read_bytes_avail_show(struct device *dev,
289                                          struct device_attribute *dev_attr,
290                                          char *buf)
291 {
292         struct hv_device *hv_dev = device_to_hv_device(dev);
293         struct hv_ring_buffer_debug_info outbound;
294 
295         if (!hv_dev->channel)
296                 return -ENODEV;
297         hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
298         return sprintf(buf, "%d\n", outbound.bytes_avail_toread);
299 }
300 static DEVICE_ATTR_RO(out_read_bytes_avail);
301 
302 static ssize_t out_write_bytes_avail_show(struct device *dev,
303                                           struct device_attribute *dev_attr,
304                                           char *buf)
305 {
306         struct hv_device *hv_dev = device_to_hv_device(dev);
307         struct hv_ring_buffer_debug_info outbound;
308 
309         if (!hv_dev->channel)
310                 return -ENODEV;
311         hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
312         return sprintf(buf, "%d\n", outbound.bytes_avail_towrite);
313 }
314 static DEVICE_ATTR_RO(out_write_bytes_avail);
315 
316 static ssize_t in_intr_mask_show(struct device *dev,
317                                  struct device_attribute *dev_attr, char *buf)
318 {
319         struct hv_device *hv_dev = device_to_hv_device(dev);
320         struct hv_ring_buffer_debug_info inbound;
321 
322         if (!hv_dev->channel)
323                 return -ENODEV;
324         hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
325         return sprintf(buf, "%d\n", inbound.current_interrupt_mask);
326 }
327 static DEVICE_ATTR_RO(in_intr_mask);
328 
329 static ssize_t in_read_index_show(struct device *dev,
330                                   struct device_attribute *dev_attr, char *buf)
331 {
332         struct hv_device *hv_dev = device_to_hv_device(dev);
333         struct hv_ring_buffer_debug_info inbound;
334 
335         if (!hv_dev->channel)
336                 return -ENODEV;
337         hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
338         return sprintf(buf, "%d\n", inbound.current_read_index);
339 }
340 static DEVICE_ATTR_RO(in_read_index);
341 
342 static ssize_t in_write_index_show(struct device *dev,
343                                    struct device_attribute *dev_attr, char *buf)
344 {
345         struct hv_device *hv_dev = device_to_hv_device(dev);
346         struct hv_ring_buffer_debug_info inbound;
347 
348         if (!hv_dev->channel)
349                 return -ENODEV;
350         hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
351         return sprintf(buf, "%d\n", inbound.current_write_index);
352 }
353 static DEVICE_ATTR_RO(in_write_index);
354 
355 static ssize_t in_read_bytes_avail_show(struct device *dev,
356                                         struct device_attribute *dev_attr,
357                                         char *buf)
358 {
359         struct hv_device *hv_dev = device_to_hv_device(dev);
360         struct hv_ring_buffer_debug_info inbound;
361 
362         if (!hv_dev->channel)
363                 return -ENODEV;
364         hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
365         return sprintf(buf, "%d\n", inbound.bytes_avail_toread);
366 }
367 static DEVICE_ATTR_RO(in_read_bytes_avail);
368 
369 static ssize_t in_write_bytes_avail_show(struct device *dev,
370                                          struct device_attribute *dev_attr,
371                                          char *buf)
372 {
373         struct hv_device *hv_dev = device_to_hv_device(dev);
374         struct hv_ring_buffer_debug_info inbound;
375 
376         if (!hv_dev->channel)
377                 return -ENODEV;
378         hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
379         return sprintf(buf, "%d\n", inbound.bytes_avail_towrite);
380 }
381 static DEVICE_ATTR_RO(in_write_bytes_avail);
382 
383 /* Set up per device attributes in /sys/bus/vmbus/devices/<bus device> */
384 static struct attribute *vmbus_attrs[] = {
385         &dev_attr_id.attr,
386         &dev_attr_state.attr,
387         &dev_attr_monitor_id.attr,
388         &dev_attr_class_id.attr,
389         &dev_attr_device_id.attr,
390         &dev_attr_modalias.attr,
391         &dev_attr_server_monitor_pending.attr,
392         &dev_attr_client_monitor_pending.attr,
393         &dev_attr_server_monitor_latency.attr,
394         &dev_attr_client_monitor_latency.attr,
395         &dev_attr_server_monitor_conn_id.attr,
396         &dev_attr_client_monitor_conn_id.attr,
397         &dev_attr_out_intr_mask.attr,
398         &dev_attr_out_read_index.attr,
399         &dev_attr_out_write_index.attr,
400         &dev_attr_out_read_bytes_avail.attr,
401         &dev_attr_out_write_bytes_avail.attr,
402         &dev_attr_in_intr_mask.attr,
403         &dev_attr_in_read_index.attr,
404         &dev_attr_in_write_index.attr,
405         &dev_attr_in_read_bytes_avail.attr,
406         &dev_attr_in_write_bytes_avail.attr,
407         NULL,
408 };
409 ATTRIBUTE_GROUPS(vmbus);
410 
411 /*
412  * vmbus_uevent - add uevent for our device
413  *
414  * This routine is invoked when a device is added or removed on the vmbus to
415  * generate a uevent to udev in the userspace. The udev will then look at its
416  * rule and the uevent generated here to load the appropriate driver
417  *
418  * The alias string will be of the form vmbus:guid where guid is the string
419  * representation of the device guid (each byte of the guid will be
420  * represented with two hex characters.
421  */
422 static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env)
423 {
424         struct hv_device *dev = device_to_hv_device(device);
425         int ret;
426         char alias_name[VMBUS_ALIAS_LEN + 1];
427 
428         print_alias_name(dev, alias_name);
429         ret = add_uevent_var(env, "MODALIAS=vmbus:%s", alias_name);
430         return ret;
431 }
432 
433 static uuid_le null_guid;
434 
435 static inline bool is_null_guid(const __u8 *guid)
436 {
437         if (memcmp(guid, &null_guid, sizeof(uuid_le)))
438                 return false;
439         return true;
440 }
441 
442 /*
443  * Return a matching hv_vmbus_device_id pointer.
444  * If there is no match, return NULL.
445  */
446 static const struct hv_vmbus_device_id *hv_vmbus_get_id(
447                                         const struct hv_vmbus_device_id *id,
448                                         __u8 *guid)
449 {
450         for (; !is_null_guid(id->guid); id++)
451                 if (!memcmp(&id->guid, guid, sizeof(uuid_le)))
452                         return id;
453 
454         return NULL;
455 }
456 
457 
458 
459 /*
460  * vmbus_match - Attempt to match the specified device to the specified driver
461  */
462 static int vmbus_match(struct device *device, struct device_driver *driver)
463 {
464         struct hv_driver *drv = drv_to_hv_drv(driver);
465         struct hv_device *hv_dev = device_to_hv_device(device);
466 
467         if (hv_vmbus_get_id(drv->id_table, hv_dev->dev_type.b))
468                 return 1;
469 
470         return 0;
471 }
472 
473 /*
474  * vmbus_probe - Add the new vmbus's child device
475  */
476 static int vmbus_probe(struct device *child_device)
477 {
478         int ret = 0;
479         struct hv_driver *drv =
480                         drv_to_hv_drv(child_device->driver);
481         struct hv_device *dev = device_to_hv_device(child_device);
482         const struct hv_vmbus_device_id *dev_id;
483 
484         dev_id = hv_vmbus_get_id(drv->id_table, dev->dev_type.b);
485         if (drv->probe) {
486                 ret = drv->probe(dev, dev_id);
487                 if (ret != 0)
488                         pr_err("probe failed for device %s (%d)\n",
489                                dev_name(child_device), ret);
490 
491         } else {
492                 pr_err("probe not set for driver %s\n",
493                        dev_name(child_device));
494                 ret = -ENODEV;
495         }
496         return ret;
497 }
498 
499 /*
500  * vmbus_remove - Remove a vmbus device
501  */
502 static int vmbus_remove(struct device *child_device)
503 {
504         struct hv_driver *drv = drv_to_hv_drv(child_device->driver);
505         struct hv_device *dev = device_to_hv_device(child_device);
506 
507         if (drv->remove)
508                 drv->remove(dev);
509         else
510                 pr_err("remove not set for driver %s\n",
511                         dev_name(child_device));
512 
513         return 0;
514 }
515 
516 
517 /*
518  * vmbus_shutdown - Shutdown a vmbus device
519  */
520 static void vmbus_shutdown(struct device *child_device)
521 {
522         struct hv_driver *drv;
523         struct hv_device *dev = device_to_hv_device(child_device);
524 
525 
526         /* The device may not be attached yet */
527         if (!child_device->driver)
528                 return;
529 
530         drv = drv_to_hv_drv(child_device->driver);
531 
532         if (drv->shutdown)
533                 drv->shutdown(dev);
534 
535         return;
536 }
537 
538 
539 /*
540  * vmbus_device_release - Final callback release of the vmbus child device
541  */
542 static void vmbus_device_release(struct device *device)
543 {
544         struct hv_device *hv_dev = device_to_hv_device(device);
545 
546         kfree(hv_dev);
547 
548 }
549 
550 /* The one and only one */
551 static struct bus_type  hv_bus = {
552         .name =         "vmbus",
553         .match =                vmbus_match,
554         .shutdown =             vmbus_shutdown,
555         .remove =               vmbus_remove,
556         .probe =                vmbus_probe,
557         .uevent =               vmbus_uevent,
558         .dev_groups =           vmbus_groups,
559 };
560 
561 static const char *driver_name = "hyperv";
562 
563 
564 struct onmessage_work_context {
565         struct work_struct work;
566         struct hv_message msg;
567 };
568 
569 static void vmbus_onmessage_work(struct work_struct *work)
570 {
571         struct onmessage_work_context *ctx;
572 
573         ctx = container_of(work, struct onmessage_work_context,
574                            work);
575         vmbus_onmessage(&ctx->msg);
576         kfree(ctx);
577 }
578 
579 static void vmbus_on_msg_dpc(unsigned long data)
580 {
581         int cpu = smp_processor_id();
582         void *page_addr = hv_context.synic_message_page[cpu];
583         struct hv_message *msg = (struct hv_message *)page_addr +
584                                   VMBUS_MESSAGE_SINT;
585         struct onmessage_work_context *ctx;
586 
587         while (1) {
588                 if (msg->header.message_type == HVMSG_NONE) {
589                         /* no msg */
590                         break;
591                 } else {
592                         ctx = kmalloc(sizeof(*ctx), GFP_ATOMIC);
593                         if (ctx == NULL)
594                                 continue;
595                         INIT_WORK(&ctx->work, vmbus_onmessage_work);
596                         memcpy(&ctx->msg, msg, sizeof(*msg));
597                         queue_work(vmbus_connection.work_queue, &ctx->work);
598                 }
599 
600                 msg->header.message_type = HVMSG_NONE;
601 
602                 /*
603                  * Make sure the write to MessageType (ie set to
604                  * HVMSG_NONE) happens before we read the
605                  * MessagePending and EOMing. Otherwise, the EOMing
606                  * will not deliver any more messages since there is
607                  * no empty slot
608                  */
609                 mb();
610 
611                 if (msg->header.message_flags.msg_pending) {
612                         /*
613                          * This will cause message queue rescan to
614                          * possibly deliver another msg from the
615                          * hypervisor
616                          */
617                         wrmsrl(HV_X64_MSR_EOM, 0);
618                 }
619         }
620 }
621 
622 static irqreturn_t vmbus_isr(int irq, void *dev_id)
623 {
624         int cpu = smp_processor_id();
625         void *page_addr;
626         struct hv_message *msg;
627         union hv_synic_event_flags *event;
628         bool handled = false;
629 
630         page_addr = hv_context.synic_event_page[cpu];
631         if (page_addr == NULL)
632                 return IRQ_NONE;
633 
634         event = (union hv_synic_event_flags *)page_addr +
635                                          VMBUS_MESSAGE_SINT;
636         /*
637          * Check for events before checking for messages. This is the order
638          * in which events and messages are checked in Windows guests on
639          * Hyper-V, and the Windows team suggested we do the same.
640          */
641 
642         if ((vmbus_proto_version == VERSION_WS2008) ||
643                 (vmbus_proto_version == VERSION_WIN7)) {
644 
645                 /* Since we are a child, we only need to check bit 0 */
646                 if (sync_test_and_clear_bit(0,
647                         (unsigned long *) &event->flags32[0])) {
648                         handled = true;
649                 }
650         } else {
651                 /*
652                  * Our host is win8 or above. The signaling mechanism
653                  * has changed and we can directly look at the event page.
654                  * If bit n is set then we have an interrup on the channel
655                  * whose id is n.
656                  */
657                 handled = true;
658         }
659 
660         if (handled)
661                 tasklet_schedule(hv_context.event_dpc[cpu]);
662 
663 
664         page_addr = hv_context.synic_message_page[cpu];
665         msg = (struct hv_message *)page_addr + VMBUS_MESSAGE_SINT;
666 
667         /* Check if there are actual msgs to be processed */
668         if (msg->header.message_type != HVMSG_NONE) {
669                 handled = true;
670                 tasklet_schedule(&msg_dpc);
671         }
672 
673         if (handled)
674                 return IRQ_HANDLED;
675         else
676                 return IRQ_NONE;
677 }
678 
679 /*
680  * vmbus interrupt flow handler:
681  * vmbus interrupts can concurrently occur on multiple CPUs and
682  * can be handled concurrently.
683  */
684 
685 static void vmbus_flow_handler(unsigned int irq, struct irq_desc *desc)
686 {
687         kstat_incr_irqs_this_cpu(irq, desc);
688 
689         desc->action->handler(irq, desc->action->dev_id);
690 }
691 
692 /*
693  * vmbus_bus_init -Main vmbus driver initialization routine.
694  *
695  * Here, we
696  *      - initialize the vmbus driver context
697  *      - invoke the vmbus hv main init routine
698  *      - get the irq resource
699  *      - retrieve the channel offers
700  */
701 static int vmbus_bus_init(int irq)
702 {
703         int ret;
704 
705         /* Hypervisor initialization...setup hypercall page..etc */
706         ret = hv_init();
707         if (ret != 0) {
708                 pr_err("Unable to initialize the hypervisor - 0x%x\n", ret);
709                 return ret;
710         }
711 
712         tasklet_init(&msg_dpc, vmbus_on_msg_dpc, 0);
713 
714         ret = bus_register(&hv_bus);
715         if (ret)
716                 goto err_cleanup;
717 
718         ret = request_irq(irq, vmbus_isr, 0, driver_name, hv_acpi_dev);
719 
720         if (ret != 0) {
721                 pr_err("Unable to request IRQ %d\n",
722                            irq);
723                 goto err_unregister;
724         }
725 
726         /*
727          * Vmbus interrupts can be handled concurrently on
728          * different CPUs. Establish an appropriate interrupt flow
729          * handler that can support this model.
730          */
731         irq_set_handler(irq, vmbus_flow_handler);
732 
733         /*
734          * Register our interrupt handler.
735          */
736         hv_register_vmbus_handler(irq, vmbus_isr);
737 
738         ret = hv_synic_alloc();
739         if (ret)
740                 goto err_alloc;
741         /*
742          * Initialize the per-cpu interrupt state and
743          * connect to the host.
744          */
745         on_each_cpu(hv_synic_init, NULL, 1);
746         ret = vmbus_connect();
747         if (ret)
748                 goto err_alloc;
749 
750         vmbus_request_offers();
751 
752         return 0;
753 
754 err_alloc:
755         hv_synic_free();
756         free_irq(irq, hv_acpi_dev);
757 
758 err_unregister:
759         bus_unregister(&hv_bus);
760 
761 err_cleanup:
762         hv_cleanup();
763 
764         return ret;
765 }
766 
767 /**
768  * __vmbus_child_driver_register - Register a vmbus's driver
769  * @drv: Pointer to driver structure you want to register
770  * @owner: owner module of the drv
771  * @mod_name: module name string
772  *
773  * Registers the given driver with Linux through the 'driver_register()' call
774  * and sets up the hyper-v vmbus handling for this driver.
775  * It will return the state of the 'driver_register()' call.
776  *
777  */
778 int __vmbus_driver_register(struct hv_driver *hv_driver, struct module *owner, const char *mod_name)
779 {
780         int ret;
781 
782         pr_info("registering driver %s\n", hv_driver->name);
783 
784         ret = vmbus_exists();
785         if (ret < 0)
786                 return ret;
787 
788         hv_driver->driver.name = hv_driver->name;
789         hv_driver->driver.owner = owner;
790         hv_driver->driver.mod_name = mod_name;
791         hv_driver->driver.bus = &hv_bus;
792 
793         ret = driver_register(&hv_driver->driver);
794 
795         return ret;
796 }
797 EXPORT_SYMBOL_GPL(__vmbus_driver_register);
798 
799 /**
800  * vmbus_driver_unregister() - Unregister a vmbus's driver
801  * @drv: Pointer to driver structure you want to un-register
802  *
803  * Un-register the given driver that was previous registered with a call to
804  * vmbus_driver_register()
805  */
806 void vmbus_driver_unregister(struct hv_driver *hv_driver)
807 {
808         pr_info("unregistering driver %s\n", hv_driver->name);
809 
810         if (!vmbus_exists())
811                 driver_unregister(&hv_driver->driver);
812 }
813 EXPORT_SYMBOL_GPL(vmbus_driver_unregister);
814 
815 /*
816  * vmbus_device_create - Creates and registers a new child device
817  * on the vmbus.
818  */
819 struct hv_device *vmbus_device_create(uuid_le *type,
820                                             uuid_le *instance,
821                                             struct vmbus_channel *channel)
822 {
823         struct hv_device *child_device_obj;
824 
825         child_device_obj = kzalloc(sizeof(struct hv_device), GFP_KERNEL);
826         if (!child_device_obj) {
827                 pr_err("Unable to allocate device object for child device\n");
828                 return NULL;
829         }
830 
831         child_device_obj->channel = channel;
832         memcpy(&child_device_obj->dev_type, type, sizeof(uuid_le));
833         memcpy(&child_device_obj->dev_instance, instance,
834                sizeof(uuid_le));
835 
836 
837         return child_device_obj;
838 }
839 
840 /*
841  * vmbus_device_register - Register the child device
842  */
843 int vmbus_device_register(struct hv_device *child_device_obj)
844 {
845         int ret = 0;
846 
847         static atomic_t device_num = ATOMIC_INIT(0);
848 
849         dev_set_name(&child_device_obj->device, "vmbus_0_%d",
850                      atomic_inc_return(&device_num));
851 
852         child_device_obj->device.bus = &hv_bus;
853         child_device_obj->device.parent = &hv_acpi_dev->dev;
854         child_device_obj->device.release = vmbus_device_release;
855 
856         /*
857          * Register with the LDM. This will kick off the driver/device
858          * binding...which will eventually call vmbus_match() and vmbus_probe()
859          */
860         ret = device_register(&child_device_obj->device);
861 
862         if (ret)
863                 pr_err("Unable to register child device\n");
864         else
865                 pr_debug("child device %s registered\n",
866                         dev_name(&child_device_obj->device));
867 
868         return ret;
869 }
870 
871 /*
872  * vmbus_device_unregister - Remove the specified child device
873  * from the vmbus.
874  */
875 void vmbus_device_unregister(struct hv_device *device_obj)
876 {
877         pr_debug("child device %s unregistered\n",
878                 dev_name(&device_obj->device));
879 
880         /*
881          * Kick off the process of unregistering the device.
882          * This will call vmbus_remove() and eventually vmbus_device_release()
883          */
884         device_unregister(&device_obj->device);
885 }
886 
887 
888 /*
889  * VMBUS is an acpi enumerated device. Get the the IRQ information
890  * from DSDT.
891  */
892 
893 static acpi_status vmbus_walk_resources(struct acpi_resource *res, void *irq)
894 {
895 
896         if (res->type == ACPI_RESOURCE_TYPE_IRQ) {
897                 struct acpi_resource_irq *irqp;
898                 irqp = &res->data.irq;
899 
900                 *((unsigned int *)irq) = irqp->interrupts[0];
901         }
902 
903         return AE_OK;
904 }
905 
906 static int vmbus_acpi_add(struct acpi_device *device)
907 {
908         acpi_status result;
909 
910         hv_acpi_dev = device;
911 
912         result = acpi_walk_resources(device->handle, METHOD_NAME__CRS,
913                                         vmbus_walk_resources, &irq);
914 
915         if (ACPI_FAILURE(result)) {
916                 complete(&probe_event);
917                 return -ENODEV;
918         }
919         complete(&probe_event);
920         return 0;
921 }
922 
923 static const struct acpi_device_id vmbus_acpi_device_ids[] = {
924         {"VMBUS", 0},
925         {"VMBus", 0},
926         {"", 0},
927 };
928 MODULE_DEVICE_TABLE(acpi, vmbus_acpi_device_ids);
929 
930 static struct acpi_driver vmbus_acpi_driver = {
931         .name = "vmbus",
932         .ids = vmbus_acpi_device_ids,
933         .ops = {
934                 .add = vmbus_acpi_add,
935         },
936 };
937 
938 static int __init hv_acpi_init(void)
939 {
940         int ret, t;
941 
942         if (x86_hyper != &x86_hyper_ms_hyperv)
943                 return -ENODEV;
944 
945         init_completion(&probe_event);
946 
947         /*
948          * Get irq resources first.
949          */
950 
951         ret = acpi_bus_register_driver(&vmbus_acpi_driver);
952 
953         if (ret)
954                 return ret;
955 
956         t = wait_for_completion_timeout(&probe_event, 5*HZ);
957         if (t == 0) {
958                 ret = -ETIMEDOUT;
959                 goto cleanup;
960         }
961 
962         if (irq <= 0) {
963                 ret = -ENODEV;
964                 goto cleanup;
965         }
966 
967         ret = vmbus_bus_init(irq);
968         if (ret)
969                 goto cleanup;
970 
971         return 0;
972 
973 cleanup:
974         acpi_bus_unregister_driver(&vmbus_acpi_driver);
975         hv_acpi_dev = NULL;
976         return ret;
977 }
978 
979 static void __exit vmbus_exit(void)
980 {
981 
982         free_irq(irq, hv_acpi_dev);
983         vmbus_free_channels();
984         bus_unregister(&hv_bus);
985         hv_cleanup();
986         acpi_bus_unregister_driver(&vmbus_acpi_driver);
987 }
988 
989 
990 MODULE_LICENSE("GPL");
991 
992 subsys_initcall(hv_acpi_init);
993 module_exit(vmbus_exit);
994 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us