Version:  2.0.40 2.2.26 2.4.37 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4

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/interrupt.h>
 29 #include <linux/sysctl.h>
 30 #include <linux/slab.h>
 31 #include <linux/acpi.h>
 32 #include <linux/completion.h>
 33 #include <linux/hyperv.h>
 34 #include <linux/kernel_stat.h>
 35 #include <linux/clockchips.h>
 36 #include <linux/cpu.h>
 37 #include <asm/hyperv.h>
 38 #include <asm/hypervisor.h>
 39 #include <asm/mshyperv.h>
 40 #include <linux/notifier.h>
 41 #include <linux/ptrace.h>
 42 #include <linux/screen_info.h>
 43 #include <linux/kdebug.h>
 44 #include "hyperv_vmbus.h"
 45 
 46 static struct acpi_device  *hv_acpi_dev;
 47 
 48 static struct tasklet_struct msg_dpc;
 49 static struct completion probe_event;
 50 static int irq;
 51 
 52 
 53 static void hyperv_report_panic(struct pt_regs *regs)
 54 {
 55         static bool panic_reported;
 56 
 57         /*
 58          * We prefer to report panic on 'die' chain as we have proper
 59          * registers to report, but if we miss it (e.g. on BUG()) we need
 60          * to report it on 'panic'.
 61          */
 62         if (panic_reported)
 63                 return;
 64         panic_reported = true;
 65 
 66         wrmsrl(HV_X64_MSR_CRASH_P0, regs->ip);
 67         wrmsrl(HV_X64_MSR_CRASH_P1, regs->ax);
 68         wrmsrl(HV_X64_MSR_CRASH_P2, regs->bx);
 69         wrmsrl(HV_X64_MSR_CRASH_P3, regs->cx);
 70         wrmsrl(HV_X64_MSR_CRASH_P4, regs->dx);
 71 
 72         /*
 73          * Let Hyper-V know there is crash data available
 74          */
 75         wrmsrl(HV_X64_MSR_CRASH_CTL, HV_CRASH_CTL_CRASH_NOTIFY);
 76 }
 77 
 78 static int hyperv_panic_event(struct notifier_block *nb, unsigned long val,
 79                               void *args)
 80 {
 81         struct pt_regs *regs;
 82 
 83         regs = current_pt_regs();
 84 
 85         hyperv_report_panic(regs);
 86         return NOTIFY_DONE;
 87 }
 88 
 89 static int hyperv_die_event(struct notifier_block *nb, unsigned long val,
 90                             void *args)
 91 {
 92         struct die_args *die = (struct die_args *)args;
 93         struct pt_regs *regs = die->regs;
 94 
 95         hyperv_report_panic(regs);
 96         return NOTIFY_DONE;
 97 }
 98 
 99 static struct notifier_block hyperv_die_block = {
100         .notifier_call = hyperv_die_event,
101 };
102 static struct notifier_block hyperv_panic_block = {
103         .notifier_call = hyperv_panic_event,
104 };
105 
106 struct resource *hyperv_mmio;
107 
108 static int vmbus_exists(void)
109 {
110         if (hv_acpi_dev == NULL)
111                 return -ENODEV;
112 
113         return 0;
114 }
115 
116 #define VMBUS_ALIAS_LEN ((sizeof((struct hv_vmbus_device_id *)0)->guid) * 2)
117 static void print_alias_name(struct hv_device *hv_dev, char *alias_name)
118 {
119         int i;
120         for (i = 0; i < VMBUS_ALIAS_LEN; i += 2)
121                 sprintf(&alias_name[i], "%02x", hv_dev->dev_type.b[i/2]);
122 }
123 
124 static u8 channel_monitor_group(struct vmbus_channel *channel)
125 {
126         return (u8)channel->offermsg.monitorid / 32;
127 }
128 
129 static u8 channel_monitor_offset(struct vmbus_channel *channel)
130 {
131         return (u8)channel->offermsg.monitorid % 32;
132 }
133 
134 static u32 channel_pending(struct vmbus_channel *channel,
135                            struct hv_monitor_page *monitor_page)
136 {
137         u8 monitor_group = channel_monitor_group(channel);
138         return monitor_page->trigger_group[monitor_group].pending;
139 }
140 
141 static u32 channel_latency(struct vmbus_channel *channel,
142                            struct hv_monitor_page *monitor_page)
143 {
144         u8 monitor_group = channel_monitor_group(channel);
145         u8 monitor_offset = channel_monitor_offset(channel);
146         return monitor_page->latency[monitor_group][monitor_offset];
147 }
148 
149 static u32 channel_conn_id(struct vmbus_channel *channel,
150                            struct hv_monitor_page *monitor_page)
151 {
152         u8 monitor_group = channel_monitor_group(channel);
153         u8 monitor_offset = channel_monitor_offset(channel);
154         return monitor_page->parameter[monitor_group][monitor_offset].connectionid.u.id;
155 }
156 
157 static ssize_t id_show(struct device *dev, struct device_attribute *dev_attr,
158                        char *buf)
159 {
160         struct hv_device *hv_dev = device_to_hv_device(dev);
161 
162         if (!hv_dev->channel)
163                 return -ENODEV;
164         return sprintf(buf, "%d\n", hv_dev->channel->offermsg.child_relid);
165 }
166 static DEVICE_ATTR_RO(id);
167 
168 static ssize_t state_show(struct device *dev, struct device_attribute *dev_attr,
169                           char *buf)
170 {
171         struct hv_device *hv_dev = device_to_hv_device(dev);
172 
173         if (!hv_dev->channel)
174                 return -ENODEV;
175         return sprintf(buf, "%d\n", hv_dev->channel->state);
176 }
177 static DEVICE_ATTR_RO(state);
178 
179 static ssize_t monitor_id_show(struct device *dev,
180                                struct device_attribute *dev_attr, 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", hv_dev->channel->offermsg.monitorid);
187 }
188 static DEVICE_ATTR_RO(monitor_id);
189 
190 static ssize_t class_id_show(struct device *dev,
191                                struct device_attribute *dev_attr, char *buf)
192 {
193         struct hv_device *hv_dev = device_to_hv_device(dev);
194 
195         if (!hv_dev->channel)
196                 return -ENODEV;
197         return sprintf(buf, "{%pUl}\n",
198                        hv_dev->channel->offermsg.offer.if_type.b);
199 }
200 static DEVICE_ATTR_RO(class_id);
201 
202 static ssize_t device_id_show(struct device *dev,
203                               struct device_attribute *dev_attr, char *buf)
204 {
205         struct hv_device *hv_dev = device_to_hv_device(dev);
206 
207         if (!hv_dev->channel)
208                 return -ENODEV;
209         return sprintf(buf, "{%pUl}\n",
210                        hv_dev->channel->offermsg.offer.if_instance.b);
211 }
212 static DEVICE_ATTR_RO(device_id);
213 
214 static ssize_t modalias_show(struct device *dev,
215                              struct device_attribute *dev_attr, char *buf)
216 {
217         struct hv_device *hv_dev = device_to_hv_device(dev);
218         char alias_name[VMBUS_ALIAS_LEN + 1];
219 
220         print_alias_name(hv_dev, alias_name);
221         return sprintf(buf, "vmbus:%s\n", alias_name);
222 }
223 static DEVICE_ATTR_RO(modalias);
224 
225 static ssize_t server_monitor_pending_show(struct device *dev,
226                                            struct device_attribute *dev_attr,
227                                            char *buf)
228 {
229         struct hv_device *hv_dev = device_to_hv_device(dev);
230 
231         if (!hv_dev->channel)
232                 return -ENODEV;
233         return sprintf(buf, "%d\n",
234                        channel_pending(hv_dev->channel,
235                                        vmbus_connection.monitor_pages[1]));
236 }
237 static DEVICE_ATTR_RO(server_monitor_pending);
238 
239 static ssize_t client_monitor_pending_show(struct device *dev,
240                                            struct device_attribute *dev_attr,
241                                            char *buf)
242 {
243         struct hv_device *hv_dev = device_to_hv_device(dev);
244 
245         if (!hv_dev->channel)
246                 return -ENODEV;
247         return sprintf(buf, "%d\n",
248                        channel_pending(hv_dev->channel,
249                                        vmbus_connection.monitor_pages[1]));
250 }
251 static DEVICE_ATTR_RO(client_monitor_pending);
252 
253 static ssize_t server_monitor_latency_show(struct device *dev,
254                                            struct device_attribute *dev_attr,
255                                            char *buf)
256 {
257         struct hv_device *hv_dev = device_to_hv_device(dev);
258 
259         if (!hv_dev->channel)
260                 return -ENODEV;
261         return sprintf(buf, "%d\n",
262                        channel_latency(hv_dev->channel,
263                                        vmbus_connection.monitor_pages[0]));
264 }
265 static DEVICE_ATTR_RO(server_monitor_latency);
266 
267 static ssize_t client_monitor_latency_show(struct device *dev,
268                                            struct device_attribute *dev_attr,
269                                            char *buf)
270 {
271         struct hv_device *hv_dev = device_to_hv_device(dev);
272 
273         if (!hv_dev->channel)
274                 return -ENODEV;
275         return sprintf(buf, "%d\n",
276                        channel_latency(hv_dev->channel,
277                                        vmbus_connection.monitor_pages[1]));
278 }
279 static DEVICE_ATTR_RO(client_monitor_latency);
280 
281 static ssize_t server_monitor_conn_id_show(struct device *dev,
282                                            struct device_attribute *dev_attr,
283                                            char *buf)
284 {
285         struct hv_device *hv_dev = device_to_hv_device(dev);
286 
287         if (!hv_dev->channel)
288                 return -ENODEV;
289         return sprintf(buf, "%d\n",
290                        channel_conn_id(hv_dev->channel,
291                                        vmbus_connection.monitor_pages[0]));
292 }
293 static DEVICE_ATTR_RO(server_monitor_conn_id);
294 
295 static ssize_t client_monitor_conn_id_show(struct device *dev,
296                                            struct device_attribute *dev_attr,
297                                            char *buf)
298 {
299         struct hv_device *hv_dev = device_to_hv_device(dev);
300 
301         if (!hv_dev->channel)
302                 return -ENODEV;
303         return sprintf(buf, "%d\n",
304                        channel_conn_id(hv_dev->channel,
305                                        vmbus_connection.monitor_pages[1]));
306 }
307 static DEVICE_ATTR_RO(client_monitor_conn_id);
308 
309 static ssize_t out_intr_mask_show(struct device *dev,
310                                   struct device_attribute *dev_attr, char *buf)
311 {
312         struct hv_device *hv_dev = device_to_hv_device(dev);
313         struct hv_ring_buffer_debug_info outbound;
314 
315         if (!hv_dev->channel)
316                 return -ENODEV;
317         hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
318         return sprintf(buf, "%d\n", outbound.current_interrupt_mask);
319 }
320 static DEVICE_ATTR_RO(out_intr_mask);
321 
322 static ssize_t out_read_index_show(struct device *dev,
323                                    struct device_attribute *dev_attr, char *buf)
324 {
325         struct hv_device *hv_dev = device_to_hv_device(dev);
326         struct hv_ring_buffer_debug_info outbound;
327 
328         if (!hv_dev->channel)
329                 return -ENODEV;
330         hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
331         return sprintf(buf, "%d\n", outbound.current_read_index);
332 }
333 static DEVICE_ATTR_RO(out_read_index);
334 
335 static ssize_t out_write_index_show(struct device *dev,
336                                     struct device_attribute *dev_attr,
337                                     char *buf)
338 {
339         struct hv_device *hv_dev = device_to_hv_device(dev);
340         struct hv_ring_buffer_debug_info outbound;
341 
342         if (!hv_dev->channel)
343                 return -ENODEV;
344         hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
345         return sprintf(buf, "%d\n", outbound.current_write_index);
346 }
347 static DEVICE_ATTR_RO(out_write_index);
348 
349 static ssize_t out_read_bytes_avail_show(struct device *dev,
350                                          struct device_attribute *dev_attr,
351                                          char *buf)
352 {
353         struct hv_device *hv_dev = device_to_hv_device(dev);
354         struct hv_ring_buffer_debug_info outbound;
355 
356         if (!hv_dev->channel)
357                 return -ENODEV;
358         hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
359         return sprintf(buf, "%d\n", outbound.bytes_avail_toread);
360 }
361 static DEVICE_ATTR_RO(out_read_bytes_avail);
362 
363 static ssize_t out_write_bytes_avail_show(struct device *dev,
364                                           struct device_attribute *dev_attr,
365                                           char *buf)
366 {
367         struct hv_device *hv_dev = device_to_hv_device(dev);
368         struct hv_ring_buffer_debug_info outbound;
369 
370         if (!hv_dev->channel)
371                 return -ENODEV;
372         hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
373         return sprintf(buf, "%d\n", outbound.bytes_avail_towrite);
374 }
375 static DEVICE_ATTR_RO(out_write_bytes_avail);
376 
377 static ssize_t in_intr_mask_show(struct device *dev,
378                                  struct device_attribute *dev_attr, char *buf)
379 {
380         struct hv_device *hv_dev = device_to_hv_device(dev);
381         struct hv_ring_buffer_debug_info inbound;
382 
383         if (!hv_dev->channel)
384                 return -ENODEV;
385         hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
386         return sprintf(buf, "%d\n", inbound.current_interrupt_mask);
387 }
388 static DEVICE_ATTR_RO(in_intr_mask);
389 
390 static ssize_t in_read_index_show(struct device *dev,
391                                   struct device_attribute *dev_attr, char *buf)
392 {
393         struct hv_device *hv_dev = device_to_hv_device(dev);
394         struct hv_ring_buffer_debug_info inbound;
395 
396         if (!hv_dev->channel)
397                 return -ENODEV;
398         hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
399         return sprintf(buf, "%d\n", inbound.current_read_index);
400 }
401 static DEVICE_ATTR_RO(in_read_index);
402 
403 static ssize_t in_write_index_show(struct device *dev,
404                                    struct device_attribute *dev_attr, char *buf)
405 {
406         struct hv_device *hv_dev = device_to_hv_device(dev);
407         struct hv_ring_buffer_debug_info inbound;
408 
409         if (!hv_dev->channel)
410                 return -ENODEV;
411         hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
412         return sprintf(buf, "%d\n", inbound.current_write_index);
413 }
414 static DEVICE_ATTR_RO(in_write_index);
415 
416 static ssize_t in_read_bytes_avail_show(struct device *dev,
417                                         struct device_attribute *dev_attr,
418                                         char *buf)
419 {
420         struct hv_device *hv_dev = device_to_hv_device(dev);
421         struct hv_ring_buffer_debug_info inbound;
422 
423         if (!hv_dev->channel)
424                 return -ENODEV;
425         hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
426         return sprintf(buf, "%d\n", inbound.bytes_avail_toread);
427 }
428 static DEVICE_ATTR_RO(in_read_bytes_avail);
429 
430 static ssize_t in_write_bytes_avail_show(struct device *dev,
431                                          struct device_attribute *dev_attr,
432                                          char *buf)
433 {
434         struct hv_device *hv_dev = device_to_hv_device(dev);
435         struct hv_ring_buffer_debug_info inbound;
436 
437         if (!hv_dev->channel)
438                 return -ENODEV;
439         hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
440         return sprintf(buf, "%d\n", inbound.bytes_avail_towrite);
441 }
442 static DEVICE_ATTR_RO(in_write_bytes_avail);
443 
444 static ssize_t channel_vp_mapping_show(struct device *dev,
445                                        struct device_attribute *dev_attr,
446                                        char *buf)
447 {
448         struct hv_device *hv_dev = device_to_hv_device(dev);
449         struct vmbus_channel *channel = hv_dev->channel, *cur_sc;
450         unsigned long flags;
451         int buf_size = PAGE_SIZE, n_written, tot_written;
452         struct list_head *cur;
453 
454         if (!channel)
455                 return -ENODEV;
456 
457         tot_written = snprintf(buf, buf_size, "%u:%u\n",
458                 channel->offermsg.child_relid, channel->target_cpu);
459 
460         spin_lock_irqsave(&channel->lock, flags);
461 
462         list_for_each(cur, &channel->sc_list) {
463                 if (tot_written >= buf_size - 1)
464                         break;
465 
466                 cur_sc = list_entry(cur, struct vmbus_channel, sc_list);
467                 n_written = scnprintf(buf + tot_written,
468                                      buf_size - tot_written,
469                                      "%u:%u\n",
470                                      cur_sc->offermsg.child_relid,
471                                      cur_sc->target_cpu);
472                 tot_written += n_written;
473         }
474 
475         spin_unlock_irqrestore(&channel->lock, flags);
476 
477         return tot_written;
478 }
479 static DEVICE_ATTR_RO(channel_vp_mapping);
480 
481 /* Set up per device attributes in /sys/bus/vmbus/devices/<bus device> */
482 static struct attribute *vmbus_attrs[] = {
483         &dev_attr_id.attr,
484         &dev_attr_state.attr,
485         &dev_attr_monitor_id.attr,
486         &dev_attr_class_id.attr,
487         &dev_attr_device_id.attr,
488         &dev_attr_modalias.attr,
489         &dev_attr_server_monitor_pending.attr,
490         &dev_attr_client_monitor_pending.attr,
491         &dev_attr_server_monitor_latency.attr,
492         &dev_attr_client_monitor_latency.attr,
493         &dev_attr_server_monitor_conn_id.attr,
494         &dev_attr_client_monitor_conn_id.attr,
495         &dev_attr_out_intr_mask.attr,
496         &dev_attr_out_read_index.attr,
497         &dev_attr_out_write_index.attr,
498         &dev_attr_out_read_bytes_avail.attr,
499         &dev_attr_out_write_bytes_avail.attr,
500         &dev_attr_in_intr_mask.attr,
501         &dev_attr_in_read_index.attr,
502         &dev_attr_in_write_index.attr,
503         &dev_attr_in_read_bytes_avail.attr,
504         &dev_attr_in_write_bytes_avail.attr,
505         &dev_attr_channel_vp_mapping.attr,
506         NULL,
507 };
508 ATTRIBUTE_GROUPS(vmbus);
509 
510 /*
511  * vmbus_uevent - add uevent for our device
512  *
513  * This routine is invoked when a device is added or removed on the vmbus to
514  * generate a uevent to udev in the userspace. The udev will then look at its
515  * rule and the uevent generated here to load the appropriate driver
516  *
517  * The alias string will be of the form vmbus:guid where guid is the string
518  * representation of the device guid (each byte of the guid will be
519  * represented with two hex characters.
520  */
521 static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env)
522 {
523         struct hv_device *dev = device_to_hv_device(device);
524         int ret;
525         char alias_name[VMBUS_ALIAS_LEN + 1];
526 
527         print_alias_name(dev, alias_name);
528         ret = add_uevent_var(env, "MODALIAS=vmbus:%s", alias_name);
529         return ret;
530 }
531 
532 static const uuid_le null_guid;
533 
534 static inline bool is_null_guid(const __u8 *guid)
535 {
536         if (memcmp(guid, &null_guid, sizeof(uuid_le)))
537                 return false;
538         return true;
539 }
540 
541 /*
542  * Return a matching hv_vmbus_device_id pointer.
543  * If there is no match, return NULL.
544  */
545 static const struct hv_vmbus_device_id *hv_vmbus_get_id(
546                                         const struct hv_vmbus_device_id *id,
547                                         const __u8 *guid)
548 {
549         for (; !is_null_guid(id->guid); id++)
550                 if (!memcmp(&id->guid, guid, sizeof(uuid_le)))
551                         return id;
552 
553         return NULL;
554 }
555 
556 
557 
558 /*
559  * vmbus_match - Attempt to match the specified device to the specified driver
560  */
561 static int vmbus_match(struct device *device, struct device_driver *driver)
562 {
563         struct hv_driver *drv = drv_to_hv_drv(driver);
564         struct hv_device *hv_dev = device_to_hv_device(device);
565 
566         if (hv_vmbus_get_id(drv->id_table, hv_dev->dev_type.b))
567                 return 1;
568 
569         return 0;
570 }
571 
572 /*
573  * vmbus_probe - Add the new vmbus's child device
574  */
575 static int vmbus_probe(struct device *child_device)
576 {
577         int ret = 0;
578         struct hv_driver *drv =
579                         drv_to_hv_drv(child_device->driver);
580         struct hv_device *dev = device_to_hv_device(child_device);
581         const struct hv_vmbus_device_id *dev_id;
582 
583         dev_id = hv_vmbus_get_id(drv->id_table, dev->dev_type.b);
584         if (drv->probe) {
585                 ret = drv->probe(dev, dev_id);
586                 if (ret != 0)
587                         pr_err("probe failed for device %s (%d)\n",
588                                dev_name(child_device), ret);
589 
590         } else {
591                 pr_err("probe not set for driver %s\n",
592                        dev_name(child_device));
593                 ret = -ENODEV;
594         }
595         return ret;
596 }
597 
598 /*
599  * vmbus_remove - Remove a vmbus device
600  */
601 static int vmbus_remove(struct device *child_device)
602 {
603         struct hv_driver *drv;
604         struct hv_device *dev = device_to_hv_device(child_device);
605         u32 relid = dev->channel->offermsg.child_relid;
606 
607         if (child_device->driver) {
608                 drv = drv_to_hv_drv(child_device->driver);
609                 if (drv->remove)
610                         drv->remove(dev);
611                 else {
612                         hv_process_channel_removal(dev->channel, relid);
613                         pr_err("remove not set for driver %s\n",
614                                 dev_name(child_device));
615                 }
616         } else {
617                 /*
618                  * We don't have a driver for this device; deal with the
619                  * rescind message by removing the channel.
620                  */
621                 hv_process_channel_removal(dev->channel, relid);
622         }
623 
624         return 0;
625 }
626 
627 
628 /*
629  * vmbus_shutdown - Shutdown a vmbus device
630  */
631 static void vmbus_shutdown(struct device *child_device)
632 {
633         struct hv_driver *drv;
634         struct hv_device *dev = device_to_hv_device(child_device);
635 
636 
637         /* The device may not be attached yet */
638         if (!child_device->driver)
639                 return;
640 
641         drv = drv_to_hv_drv(child_device->driver);
642 
643         if (drv->shutdown)
644                 drv->shutdown(dev);
645 
646         return;
647 }
648 
649 
650 /*
651  * vmbus_device_release - Final callback release of the vmbus child device
652  */
653 static void vmbus_device_release(struct device *device)
654 {
655         struct hv_device *hv_dev = device_to_hv_device(device);
656 
657         kfree(hv_dev);
658 
659 }
660 
661 /* The one and only one */
662 static struct bus_type  hv_bus = {
663         .name =         "vmbus",
664         .match =                vmbus_match,
665         .shutdown =             vmbus_shutdown,
666         .remove =               vmbus_remove,
667         .probe =                vmbus_probe,
668         .uevent =               vmbus_uevent,
669         .dev_groups =           vmbus_groups,
670 };
671 
672 struct onmessage_work_context {
673         struct work_struct work;
674         struct hv_message msg;
675 };
676 
677 static void vmbus_onmessage_work(struct work_struct *work)
678 {
679         struct onmessage_work_context *ctx;
680 
681         /* Do not process messages if we're in DISCONNECTED state */
682         if (vmbus_connection.conn_state == DISCONNECTED)
683                 return;
684 
685         ctx = container_of(work, struct onmessage_work_context,
686                            work);
687         vmbus_onmessage(&ctx->msg);
688         kfree(ctx);
689 }
690 
691 static void hv_process_timer_expiration(struct hv_message *msg, int cpu)
692 {
693         struct clock_event_device *dev = hv_context.clk_evt[cpu];
694 
695         if (dev->event_handler)
696                 dev->event_handler(dev);
697 
698         msg->header.message_type = HVMSG_NONE;
699 
700         /*
701          * Make sure the write to MessageType (ie set to
702          * HVMSG_NONE) happens before we read the
703          * MessagePending and EOMing. Otherwise, the EOMing
704          * will not deliver any more messages since there is
705          * no empty slot
706          */
707         mb();
708 
709         if (msg->header.message_flags.msg_pending) {
710                 /*
711                  * This will cause message queue rescan to
712                  * possibly deliver another msg from the
713                  * hypervisor
714                  */
715                 wrmsrl(HV_X64_MSR_EOM, 0);
716         }
717 }
718 
719 static void vmbus_on_msg_dpc(unsigned long data)
720 {
721         int cpu = smp_processor_id();
722         void *page_addr = hv_context.synic_message_page[cpu];
723         struct hv_message *msg = (struct hv_message *)page_addr +
724                                   VMBUS_MESSAGE_SINT;
725         struct vmbus_channel_message_header *hdr;
726         struct vmbus_channel_message_table_entry *entry;
727         struct onmessage_work_context *ctx;
728 
729         while (1) {
730                 if (msg->header.message_type == HVMSG_NONE)
731                         /* no msg */
732                         break;
733 
734                 hdr = (struct vmbus_channel_message_header *)msg->u.payload;
735 
736                 if (hdr->msgtype >= CHANNELMSG_COUNT) {
737                         WARN_ONCE(1, "unknown msgtype=%d\n", hdr->msgtype);
738                         goto msg_handled;
739                 }
740 
741                 entry = &channel_message_table[hdr->msgtype];
742                 if (entry->handler_type == VMHT_BLOCKING) {
743                         ctx = kmalloc(sizeof(*ctx), GFP_ATOMIC);
744                         if (ctx == NULL)
745                                 continue;
746 
747                         INIT_WORK(&ctx->work, vmbus_onmessage_work);
748                         memcpy(&ctx->msg, msg, sizeof(*msg));
749 
750                         queue_work(vmbus_connection.work_queue, &ctx->work);
751                 } else
752                         entry->message_handler(hdr);
753 
754 msg_handled:
755                 msg->header.message_type = HVMSG_NONE;
756 
757                 /*
758                  * Make sure the write to MessageType (ie set to
759                  * HVMSG_NONE) happens before we read the
760                  * MessagePending and EOMing. Otherwise, the EOMing
761                  * will not deliver any more messages since there is
762                  * no empty slot
763                  */
764                 mb();
765 
766                 if (msg->header.message_flags.msg_pending) {
767                         /*
768                          * This will cause message queue rescan to
769                          * possibly deliver another msg from the
770                          * hypervisor
771                          */
772                         wrmsrl(HV_X64_MSR_EOM, 0);
773                 }
774         }
775 }
776 
777 static void vmbus_isr(void)
778 {
779         int cpu = smp_processor_id();
780         void *page_addr;
781         struct hv_message *msg;
782         union hv_synic_event_flags *event;
783         bool handled = false;
784 
785         page_addr = hv_context.synic_event_page[cpu];
786         if (page_addr == NULL)
787                 return;
788 
789         event = (union hv_synic_event_flags *)page_addr +
790                                          VMBUS_MESSAGE_SINT;
791         /*
792          * Check for events before checking for messages. This is the order
793          * in which events and messages are checked in Windows guests on
794          * Hyper-V, and the Windows team suggested we do the same.
795          */
796 
797         if ((vmbus_proto_version == VERSION_WS2008) ||
798                 (vmbus_proto_version == VERSION_WIN7)) {
799 
800                 /* Since we are a child, we only need to check bit 0 */
801                 if (sync_test_and_clear_bit(0,
802                         (unsigned long *) &event->flags32[0])) {
803                         handled = true;
804                 }
805         } else {
806                 /*
807                  * Our host is win8 or above. The signaling mechanism
808                  * has changed and we can directly look at the event page.
809                  * If bit n is set then we have an interrup on the channel
810                  * whose id is n.
811                  */
812                 handled = true;
813         }
814 
815         if (handled)
816                 tasklet_schedule(hv_context.event_dpc[cpu]);
817 
818 
819         page_addr = hv_context.synic_message_page[cpu];
820         msg = (struct hv_message *)page_addr + VMBUS_MESSAGE_SINT;
821 
822         /* Check if there are actual msgs to be processed */
823         if (msg->header.message_type != HVMSG_NONE) {
824                 if (msg->header.message_type == HVMSG_TIMER_EXPIRED)
825                         hv_process_timer_expiration(msg, cpu);
826                 else
827                         tasklet_schedule(&msg_dpc);
828         }
829 }
830 
831 
832 /*
833  * vmbus_bus_init -Main vmbus driver initialization routine.
834  *
835  * Here, we
836  *      - initialize the vmbus driver context
837  *      - invoke the vmbus hv main init routine
838  *      - get the irq resource
839  *      - retrieve the channel offers
840  */
841 static int vmbus_bus_init(int irq)
842 {
843         int ret;
844 
845         /* Hypervisor initialization...setup hypercall page..etc */
846         ret = hv_init();
847         if (ret != 0) {
848                 pr_err("Unable to initialize the hypervisor - 0x%x\n", ret);
849                 return ret;
850         }
851 
852         tasklet_init(&msg_dpc, vmbus_on_msg_dpc, 0);
853 
854         ret = bus_register(&hv_bus);
855         if (ret)
856                 goto err_cleanup;
857 
858         hv_setup_vmbus_irq(vmbus_isr);
859 
860         ret = hv_synic_alloc();
861         if (ret)
862                 goto err_alloc;
863         /*
864          * Initialize the per-cpu interrupt state and
865          * connect to the host.
866          */
867         on_each_cpu(hv_synic_init, NULL, 1);
868         ret = vmbus_connect();
869         if (ret)
870                 goto err_alloc;
871 
872         if (vmbus_proto_version > VERSION_WIN7)
873                 cpu_hotplug_disable();
874 
875         /*
876          * Only register if the crash MSRs are available
877          */
878         if (ms_hyperv.misc_features & HV_FEATURE_GUEST_CRASH_MSR_AVAILABLE) {
879                 register_die_notifier(&hyperv_die_block);
880                 atomic_notifier_chain_register(&panic_notifier_list,
881                                                &hyperv_panic_block);
882         }
883 
884         vmbus_request_offers();
885 
886         return 0;
887 
888 err_alloc:
889         hv_synic_free();
890         hv_remove_vmbus_irq();
891 
892         bus_unregister(&hv_bus);
893 
894 err_cleanup:
895         hv_cleanup();
896 
897         return ret;
898 }
899 
900 /**
901  * __vmbus_child_driver_register() - Register a vmbus's driver
902  * @hv_driver: Pointer to driver structure you want to register
903  * @owner: owner module of the drv
904  * @mod_name: module name string
905  *
906  * Registers the given driver with Linux through the 'driver_register()' call
907  * and sets up the hyper-v vmbus handling for this driver.
908  * It will return the state of the 'driver_register()' call.
909  *
910  */
911 int __vmbus_driver_register(struct hv_driver *hv_driver, struct module *owner, const char *mod_name)
912 {
913         int ret;
914 
915         pr_info("registering driver %s\n", hv_driver->name);
916 
917         ret = vmbus_exists();
918         if (ret < 0)
919                 return ret;
920 
921         hv_driver->driver.name = hv_driver->name;
922         hv_driver->driver.owner = owner;
923         hv_driver->driver.mod_name = mod_name;
924         hv_driver->driver.bus = &hv_bus;
925 
926         ret = driver_register(&hv_driver->driver);
927 
928         return ret;
929 }
930 EXPORT_SYMBOL_GPL(__vmbus_driver_register);
931 
932 /**
933  * vmbus_driver_unregister() - Unregister a vmbus's driver
934  * @hv_driver: Pointer to driver structure you want to
935  *             un-register
936  *
937  * Un-register the given driver that was previous registered with a call to
938  * vmbus_driver_register()
939  */
940 void vmbus_driver_unregister(struct hv_driver *hv_driver)
941 {
942         pr_info("unregistering driver %s\n", hv_driver->name);
943 
944         if (!vmbus_exists())
945                 driver_unregister(&hv_driver->driver);
946 }
947 EXPORT_SYMBOL_GPL(vmbus_driver_unregister);
948 
949 /*
950  * vmbus_device_create - Creates and registers a new child device
951  * on the vmbus.
952  */
953 struct hv_device *vmbus_device_create(const uuid_le *type,
954                                       const uuid_le *instance,
955                                       struct vmbus_channel *channel)
956 {
957         struct hv_device *child_device_obj;
958 
959         child_device_obj = kzalloc(sizeof(struct hv_device), GFP_KERNEL);
960         if (!child_device_obj) {
961                 pr_err("Unable to allocate device object for child device\n");
962                 return NULL;
963         }
964 
965         child_device_obj->channel = channel;
966         memcpy(&child_device_obj->dev_type, type, sizeof(uuid_le));
967         memcpy(&child_device_obj->dev_instance, instance,
968                sizeof(uuid_le));
969 
970 
971         return child_device_obj;
972 }
973 
974 /*
975  * vmbus_device_register - Register the child device
976  */
977 int vmbus_device_register(struct hv_device *child_device_obj)
978 {
979         int ret = 0;
980 
981         dev_set_name(&child_device_obj->device, "vmbus_%d",
982                      child_device_obj->channel->id);
983 
984         child_device_obj->device.bus = &hv_bus;
985         child_device_obj->device.parent = &hv_acpi_dev->dev;
986         child_device_obj->device.release = vmbus_device_release;
987 
988         /*
989          * Register with the LDM. This will kick off the driver/device
990          * binding...which will eventually call vmbus_match() and vmbus_probe()
991          */
992         ret = device_register(&child_device_obj->device);
993 
994         if (ret)
995                 pr_err("Unable to register child device\n");
996         else
997                 pr_debug("child device %s registered\n",
998                         dev_name(&child_device_obj->device));
999 
1000         return ret;
1001 }
1002 
1003 /*
1004  * vmbus_device_unregister - Remove the specified child device
1005  * from the vmbus.
1006  */
1007 void vmbus_device_unregister(struct hv_device *device_obj)
1008 {
1009         pr_debug("child device %s unregistered\n",
1010                 dev_name(&device_obj->device));
1011 
1012         /*
1013          * Kick off the process of unregistering the device.
1014          * This will call vmbus_remove() and eventually vmbus_device_release()
1015          */
1016         device_unregister(&device_obj->device);
1017 }
1018 
1019 
1020 /*
1021  * VMBUS is an acpi enumerated device. Get the information we
1022  * need from DSDT.
1023  */
1024 #define VTPM_BASE_ADDRESS 0xfed40000
1025 static acpi_status vmbus_walk_resources(struct acpi_resource *res, void *ctx)
1026 {
1027         resource_size_t start = 0;
1028         resource_size_t end = 0;
1029         struct resource *new_res;
1030         struct resource **old_res = &hyperv_mmio;
1031         struct resource **prev_res = NULL;
1032 
1033         switch (res->type) {
1034         case ACPI_RESOURCE_TYPE_IRQ:
1035                 irq = res->data.irq.interrupts[0];
1036                 return AE_OK;
1037 
1038         /*
1039          * "Address" descriptors are for bus windows. Ignore
1040          * "memory" descriptors, which are for registers on
1041          * devices.
1042          */
1043         case ACPI_RESOURCE_TYPE_ADDRESS32:
1044                 start = res->data.address32.address.minimum;
1045                 end = res->data.address32.address.maximum;
1046                 break;
1047 
1048         case ACPI_RESOURCE_TYPE_ADDRESS64:
1049                 start = res->data.address64.address.minimum;
1050                 end = res->data.address64.address.maximum;
1051                 break;
1052 
1053         default:
1054                 /* Unused resource type */
1055                 return AE_OK;
1056 
1057         }
1058         /*
1059          * Ignore ranges that are below 1MB, as they're not
1060          * necessary or useful here.
1061          */
1062         if (end < 0x100000)
1063                 return AE_OK;
1064 
1065         new_res = kzalloc(sizeof(*new_res), GFP_ATOMIC);
1066         if (!new_res)
1067                 return AE_NO_MEMORY;
1068 
1069         /* If this range overlaps the virtual TPM, truncate it. */
1070         if (end > VTPM_BASE_ADDRESS && start < VTPM_BASE_ADDRESS)
1071                 end = VTPM_BASE_ADDRESS;
1072 
1073         new_res->name = "hyperv mmio";
1074         new_res->flags = IORESOURCE_MEM;
1075         new_res->start = start;
1076         new_res->end = end;
1077 
1078         do {
1079                 if (!*old_res) {
1080                         *old_res = new_res;
1081                         break;
1082                 }
1083 
1084                 if ((*old_res)->end < new_res->start) {
1085                         new_res->sibling = *old_res;
1086                         if (prev_res)
1087                                 (*prev_res)->sibling = new_res;
1088                         *old_res = new_res;
1089                         break;
1090                 }
1091 
1092                 prev_res = old_res;
1093                 old_res = &(*old_res)->sibling;
1094 
1095         } while (1);
1096 
1097         return AE_OK;
1098 }
1099 
1100 static int vmbus_acpi_remove(struct acpi_device *device)
1101 {
1102         struct resource *cur_res;
1103         struct resource *next_res;
1104 
1105         if (hyperv_mmio) {
1106                 for (cur_res = hyperv_mmio; cur_res; cur_res = next_res) {
1107                         next_res = cur_res->sibling;
1108                         kfree(cur_res);
1109                 }
1110         }
1111 
1112         return 0;
1113 }
1114 
1115 /**
1116  * vmbus_allocate_mmio() - Pick a memory-mapped I/O range.
1117  * @new:                If successful, supplied a pointer to the
1118  *                      allocated MMIO space.
1119  * @device_obj:         Identifies the caller
1120  * @min:                Minimum guest physical address of the
1121  *                      allocation
1122  * @max:                Maximum guest physical address
1123  * @size:               Size of the range to be allocated
1124  * @align:              Alignment of the range to be allocated
1125  * @fb_overlap_ok:      Whether this allocation can be allowed
1126  *                      to overlap the video frame buffer.
1127  *
1128  * This function walks the resources granted to VMBus by the
1129  * _CRS object in the ACPI namespace underneath the parent
1130  * "bridge" whether that's a root PCI bus in the Generation 1
1131  * case or a Module Device in the Generation 2 case.  It then
1132  * attempts to allocate from the global MMIO pool in a way that
1133  * matches the constraints supplied in these parameters and by
1134  * that _CRS.
1135  *
1136  * Return: 0 on success, -errno on failure
1137  */
1138 int vmbus_allocate_mmio(struct resource **new, struct hv_device *device_obj,
1139                         resource_size_t min, resource_size_t max,
1140                         resource_size_t size, resource_size_t align,
1141                         bool fb_overlap_ok)
1142 {
1143         struct resource *iter;
1144         resource_size_t range_min, range_max, start, local_min, local_max;
1145         const char *dev_n = dev_name(&device_obj->device);
1146         u32 fb_end = screen_info.lfb_base + (screen_info.lfb_size << 1);
1147         int i;
1148 
1149         for (iter = hyperv_mmio; iter; iter = iter->sibling) {
1150                 if ((iter->start >= max) || (iter->end <= min))
1151                         continue;
1152 
1153                 range_min = iter->start;
1154                 range_max = iter->end;
1155 
1156                 /* If this range overlaps the frame buffer, split it into
1157                    two tries. */
1158                 for (i = 0; i < 2; i++) {
1159                         local_min = range_min;
1160                         local_max = range_max;
1161                         if (fb_overlap_ok || (range_min >= fb_end) ||
1162                             (range_max <= screen_info.lfb_base)) {
1163                                 i++;
1164                         } else {
1165                                 if ((range_min <= screen_info.lfb_base) &&
1166                                     (range_max >= screen_info.lfb_base)) {
1167                                         /*
1168                                          * The frame buffer is in this window,
1169                                          * so trim this into the part that
1170                                          * preceeds the frame buffer.
1171                                          */
1172                                         local_max = screen_info.lfb_base - 1;
1173                                         range_min = fb_end;
1174                                 } else {
1175                                         range_min = fb_end;
1176                                         continue;
1177                                 }
1178                         }
1179 
1180                         start = (local_min + align - 1) & ~(align - 1);
1181                         for (; start + size - 1 <= local_max; start += align) {
1182                                 *new = request_mem_region_exclusive(start, size,
1183                                                                     dev_n);
1184                                 if (*new)
1185                                         return 0;
1186                         }
1187                 }
1188         }
1189 
1190         return -ENXIO;
1191 }
1192 EXPORT_SYMBOL_GPL(vmbus_allocate_mmio);
1193 
1194 static int vmbus_acpi_add(struct acpi_device *device)
1195 {
1196         acpi_status result;
1197         int ret_val = -ENODEV;
1198         struct acpi_device *ancestor;
1199 
1200         hv_acpi_dev = device;
1201 
1202         result = acpi_walk_resources(device->handle, METHOD_NAME__CRS,
1203                                         vmbus_walk_resources, NULL);
1204 
1205         if (ACPI_FAILURE(result))
1206                 goto acpi_walk_err;
1207         /*
1208          * Some ancestor of the vmbus acpi device (Gen1 or Gen2
1209          * firmware) is the VMOD that has the mmio ranges. Get that.
1210          */
1211         for (ancestor = device->parent; ancestor; ancestor = ancestor->parent) {
1212                 result = acpi_walk_resources(ancestor->handle, METHOD_NAME__CRS,
1213                                              vmbus_walk_resources, NULL);
1214 
1215                 if (ACPI_FAILURE(result))
1216                         continue;
1217                 if (hyperv_mmio)
1218                         break;
1219         }
1220         ret_val = 0;
1221 
1222 acpi_walk_err:
1223         complete(&probe_event);
1224         if (ret_val)
1225                 vmbus_acpi_remove(device);
1226         return ret_val;
1227 }
1228 
1229 static const struct acpi_device_id vmbus_acpi_device_ids[] = {
1230         {"VMBUS", 0},
1231         {"VMBus", 0},
1232         {"", 0},
1233 };
1234 MODULE_DEVICE_TABLE(acpi, vmbus_acpi_device_ids);
1235 
1236 static struct acpi_driver vmbus_acpi_driver = {
1237         .name = "vmbus",
1238         .ids = vmbus_acpi_device_ids,
1239         .ops = {
1240                 .add = vmbus_acpi_add,
1241                 .remove = vmbus_acpi_remove,
1242         },
1243 };
1244 
1245 static void hv_kexec_handler(void)
1246 {
1247         int cpu;
1248 
1249         hv_synic_clockevents_cleanup();
1250         vmbus_initiate_unload();
1251         for_each_online_cpu(cpu)
1252                 smp_call_function_single(cpu, hv_synic_cleanup, NULL, 1);
1253         hv_cleanup();
1254 };
1255 
1256 static void hv_crash_handler(struct pt_regs *regs)
1257 {
1258         vmbus_initiate_unload();
1259         /*
1260          * In crash handler we can't schedule synic cleanup for all CPUs,
1261          * doing the cleanup for current CPU only. This should be sufficient
1262          * for kdump.
1263          */
1264         hv_synic_cleanup(NULL);
1265         hv_cleanup();
1266 };
1267 
1268 static int __init hv_acpi_init(void)
1269 {
1270         int ret, t;
1271 
1272         if (x86_hyper != &x86_hyper_ms_hyperv)
1273                 return -ENODEV;
1274 
1275         init_completion(&probe_event);
1276 
1277         /*
1278          * Get irq resources first.
1279          */
1280         ret = acpi_bus_register_driver(&vmbus_acpi_driver);
1281 
1282         if (ret)
1283                 return ret;
1284 
1285         t = wait_for_completion_timeout(&probe_event, 5*HZ);
1286         if (t == 0) {
1287                 ret = -ETIMEDOUT;
1288                 goto cleanup;
1289         }
1290 
1291         if (irq <= 0) {
1292                 ret = -ENODEV;
1293                 goto cleanup;
1294         }
1295 
1296         ret = vmbus_bus_init(irq);
1297         if (ret)
1298                 goto cleanup;
1299 
1300         hv_setup_kexec_handler(hv_kexec_handler);
1301         hv_setup_crash_handler(hv_crash_handler);
1302 
1303         return 0;
1304 
1305 cleanup:
1306         acpi_bus_unregister_driver(&vmbus_acpi_driver);
1307         hv_acpi_dev = NULL;
1308         return ret;
1309 }
1310 
1311 static void __exit vmbus_exit(void)
1312 {
1313         int cpu;
1314 
1315         hv_remove_kexec_handler();
1316         hv_remove_crash_handler();
1317         vmbus_connection.conn_state = DISCONNECTED;
1318         hv_synic_clockevents_cleanup();
1319         vmbus_disconnect();
1320         hv_remove_vmbus_irq();
1321         tasklet_kill(&msg_dpc);
1322         vmbus_free_channels();
1323         if (ms_hyperv.misc_features & HV_FEATURE_GUEST_CRASH_MSR_AVAILABLE) {
1324                 unregister_die_notifier(&hyperv_die_block);
1325                 atomic_notifier_chain_unregister(&panic_notifier_list,
1326                                                  &hyperv_panic_block);
1327         }
1328         bus_unregister(&hv_bus);
1329         hv_cleanup();
1330         for_each_online_cpu(cpu) {
1331                 tasklet_kill(hv_context.event_dpc[cpu]);
1332                 smp_call_function_single(cpu, hv_synic_cleanup, NULL, 1);
1333         }
1334         hv_synic_free();
1335         acpi_bus_unregister_driver(&vmbus_acpi_driver);
1336         if (vmbus_proto_version > VERSION_WIN7)
1337                 cpu_hotplug_enable();
1338 }
1339 
1340 
1341 MODULE_LICENSE("GPL");
1342 
1343 subsys_initcall(hv_acpi_init);
1344 module_exit(vmbus_exit);
1345 

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