1 /*- 2 * Copyright (c) 2009-2012 Microsoft Corp. 3 * Copyright (c) 2012 NetApp Inc. 4 * Copyright (c) 2012 Citrix Inc. 5 * Copyright (c) 2016 Mike Belopuhov <mike@esdenera.com> 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice unmodified, this list of conditions, and the following 13 * disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 */ 29 30 /* 31 * The OpenBSD port was done under funding by Esdenera Networks GmbH. 32 */ 33 34 #include <sys/param.h> 35 36 /* Hyperv requires locked atomic operations */ 37 #ifndef MULTIPROCESSOR 38 #define _HYPERVMPATOMICS 39 #define MULTIPROCESSOR 40 #endif 41 #include <sys/atomic.h> 42 #ifdef _HYPERVMPATOMICS 43 #undef MULTIPROCESSOR 44 #undef _HYPERVMPATOMICS 45 #endif 46 47 #include <sys/systm.h> 48 #include <sys/malloc.h> 49 #include <sys/device.h> 50 #include <sys/timetc.h> 51 #include <sys/task.h> 52 53 #include <machine/bus.h> 54 #include <machine/cpu.h> 55 #include <machine/cpufunc.h> 56 57 #include <uvm/uvm_extern.h> 58 59 #include <machine/i82489var.h> 60 61 #include <dev/pv/pvvar.h> 62 #include <dev/pv/hypervreg.h> 63 #include <dev/pv/hypervvar.h> 64 65 /* Command submission flags */ 66 #define HCF_SLEEPOK 0x0001 /* M_WAITOK */ 67 #define HCF_NOSLEEP 0x0002 /* M_NOWAIT */ 68 #define HCF_NOREPLY 0x0004 69 70 struct hv_softc *hv_sc; 71 72 int hv_match(struct device *, void *, void *); 73 void hv_attach(struct device *, struct device *, void *); 74 void hv_set_version(struct hv_softc *); 75 u_int hv_gettime(struct timecounter *); 76 int hv_init_hypercall(struct hv_softc *); 77 uint64_t hv_hypercall(struct hv_softc *, uint64_t, void *, void *); 78 int hv_init_interrupts(struct hv_softc *); 79 int hv_init_synic(struct hv_softc *); 80 int hv_cmd(struct hv_softc *, void *, size_t, void *, size_t, int); 81 int hv_start(struct hv_softc *, struct hv_msg *); 82 int hv_reply(struct hv_softc *, struct hv_msg *); 83 void hv_wait(struct hv_softc *, int (*done)(struct hv_softc *, 84 struct hv_msg *), struct hv_msg *, void *, const char *); 85 uint16_t hv_intr_signal(struct hv_softc *, void *); 86 void hv_intr(void); 87 void hv_event_intr(struct hv_softc *); 88 void hv_message_intr(struct hv_softc *); 89 int hv_vmbus_connect(struct hv_softc *); 90 void hv_channel_response(struct hv_softc *, struct vmbus_chanmsg_hdr *); 91 void hv_channel_offer(struct hv_softc *, struct vmbus_chanmsg_hdr *); 92 void hv_channel_rescind(struct hv_softc *, struct vmbus_chanmsg_hdr *); 93 void hv_channel_delivered(struct hv_softc *, struct vmbus_chanmsg_hdr *); 94 int hv_channel_scan(struct hv_softc *); 95 void hv_process_offer(struct hv_softc *, struct hv_offer *); 96 struct hv_channel * 97 hv_channel_lookup(struct hv_softc *, uint32_t); 98 int hv_channel_ring_create(struct hv_channel *, uint32_t); 99 void hv_channel_ring_destroy(struct hv_channel *); 100 void hv_channel_pause(struct hv_channel *); 101 uint hv_channel_unpause(struct hv_channel *); 102 uint hv_channel_ready(struct hv_channel *); 103 extern void hv_attach_icdevs(struct hv_softc *); 104 int hv_attach_devices(struct hv_softc *); 105 106 struct { 107 int hmd_response; 108 int hmd_request; 109 void (*hmd_handler)(struct hv_softc *, 110 struct vmbus_chanmsg_hdr *); 111 } hv_msg_dispatch[] = { 112 { 0, 0, NULL }, 113 { VMBUS_CHANMSG_CHOFFER, 0, hv_channel_offer }, 114 { VMBUS_CHANMSG_CHRESCIND, 0, hv_channel_rescind }, 115 { VMBUS_CHANMSG_CHREQUEST, VMBUS_CHANMSG_CHOFFER, 116 NULL }, 117 { VMBUS_CHANMSG_CHOFFER_DONE, 0, 118 hv_channel_delivered }, 119 { VMBUS_CHANMSG_CHOPEN, 0, NULL }, 120 { VMBUS_CHANMSG_CHOPEN_RESP, VMBUS_CHANMSG_CHOPEN, 121 hv_channel_response }, 122 { VMBUS_CHANMSG_CHCLOSE, 0, NULL }, 123 { VMBUS_CHANMSG_GPADL_CONN, 0, NULL }, 124 { VMBUS_CHANMSG_GPADL_SUBCONN, 0, NULL }, 125 { VMBUS_CHANMSG_GPADL_CONNRESP, VMBUS_CHANMSG_GPADL_CONN, 126 hv_channel_response }, 127 { VMBUS_CHANMSG_GPADL_DISCONN, 0, NULL }, 128 { VMBUS_CHANMSG_GPADL_DISCONNRESP, VMBUS_CHANMSG_GPADL_DISCONN, 129 hv_channel_response }, 130 { VMBUS_CHANMSG_CHFREE, 0, NULL }, 131 { VMBUS_CHANMSG_CONNECT, 0, NULL }, 132 { VMBUS_CHANMSG_CONNECT_RESP, VMBUS_CHANMSG_CONNECT, 133 hv_channel_response }, 134 { VMBUS_CHANMSG_DISCONNECT, 0, NULL }, 135 }; 136 137 struct timecounter hv_timecounter = { 138 .tc_get_timecount = hv_gettime, 139 .tc_counter_mask = 0xffffffff, 140 .tc_frequency = 10000000, 141 .tc_name = "hyperv", 142 .tc_quality = 9001, 143 .tc_priv = NULL, 144 .tc_user = 0, 145 }; 146 147 struct cfdriver hyperv_cd = { 148 NULL, "hyperv", DV_DULL 149 }; 150 151 const struct cfattach hyperv_ca = { 152 sizeof(struct hv_softc), hv_match, hv_attach 153 }; 154 155 const struct hv_guid hv_guid_network = { 156 { 0x63, 0x51, 0x61, 0xf8, 0x3e, 0xdf, 0xc5, 0x46, 157 0x91, 0x3f, 0xf2, 0xd2, 0xf9, 0x65, 0xed, 0x0e } 158 }; 159 160 const struct hv_guid hv_guid_ide = { 161 { 0x32, 0x26, 0x41, 0x32, 0xcb, 0x86, 0xa2, 0x44, 162 0x9b, 0x5c, 0x50, 0xd1, 0x41, 0x73, 0x54, 0xf5 } 163 }; 164 165 const struct hv_guid hv_guid_scsi = { 166 { 0xd9, 0x63, 0x61, 0xba, 0xa1, 0x04, 0x29, 0x4d, 167 0xb6, 0x05, 0x72, 0xe2, 0xff, 0xb1, 0xdc, 0x7f } 168 }; 169 170 const struct hv_guid hv_guid_shutdown = { 171 { 0x31, 0x60, 0x0b, 0x0e, 0x13, 0x52, 0x34, 0x49, 172 0x81, 0x8b, 0x38, 0xd9, 0x0c, 0xed, 0x39, 0xdb } 173 }; 174 175 const struct hv_guid hv_guid_timesync = { 176 { 0x30, 0xe6, 0x27, 0x95, 0xae, 0xd0, 0x7b, 0x49, 177 0xad, 0xce, 0xe8, 0x0a, 0xb0, 0x17, 0x5c, 0xaf } 178 }; 179 180 const struct hv_guid hv_guid_heartbeat = { 181 { 0x39, 0x4f, 0x16, 0x57, 0x15, 0x91, 0x78, 0x4e, 182 0xab, 0x55, 0x38, 0x2f, 0x3b, 0xd5, 0x42, 0x2d } 183 }; 184 185 const struct hv_guid hv_guid_kvp = { 186 { 0xe7, 0xf4, 0xa0, 0xa9, 0x45, 0x5a, 0x96, 0x4d, 187 0xb8, 0x27, 0x8a, 0x84, 0x1e, 0x8c, 0x03, 0xe6 } 188 }; 189 190 #ifdef HYPERV_DEBUG 191 const struct hv_guid hv_guid_vss = { 192 { 0x29, 0x2e, 0xfa, 0x35, 0x23, 0xea, 0x36, 0x42, 193 0x96, 0xae, 0x3a, 0x6e, 0xba, 0xcb, 0xa4, 0x40 } 194 }; 195 196 const struct hv_guid hv_guid_dynmem = { 197 { 0xdc, 0x74, 0x50, 0x52, 0x85, 0x89, 0xe2, 0x46, 198 0x80, 0x57, 0xa3, 0x07, 0xdc, 0x18, 0xa5, 0x02 } 199 }; 200 201 const struct hv_guid hv_guid_mouse = { 202 { 0x9e, 0xb6, 0xa8, 0xcf, 0x4a, 0x5b, 0xc0, 0x4c, 203 0xb9, 0x8b, 0x8b, 0xa1, 0xa1, 0xf3, 0xf9, 0x5a } 204 }; 205 206 const struct hv_guid hv_guid_kbd = { 207 { 0x6d, 0xad, 0x12, 0xf9, 0x17, 0x2b, 0xea, 0x48, 208 0xbd, 0x65, 0xf9, 0x27, 0xa6, 0x1c, 0x76, 0x84 } 209 }; 210 211 const struct hv_guid hv_guid_video = { 212 { 0x02, 0x78, 0x0a, 0xda, 0x77, 0xe3, 0xac, 0x4a, 213 0x8e, 0x77, 0x05, 0x58, 0xeb, 0x10, 0x73, 0xf8 } 214 }; 215 216 const struct hv_guid hv_guid_fc = { 217 { 0x4a, 0xcc, 0x9b, 0x2f, 0x69, 0x00, 0xf3, 0x4a, 218 0xb7, 0x6b, 0x6f, 0xd0, 0xbe, 0x52, 0x8c, 0xda } 219 }; 220 221 const struct hv_guid hv_guid_fcopy = { 222 { 0xe3, 0x4b, 0xd1, 0x34, 0xe4, 0xde, 0xc8, 0x41, 223 0x9a, 0xe7, 0x6b, 0x17, 0x49, 0x77, 0xc1, 0x92 } 224 }; 225 226 const struct hv_guid hv_guid_pcie = { 227 { 0x1d, 0xf6, 0xc4, 0x44, 0x44, 0x44, 0x00, 0x44, 228 0x9d, 0x52, 0x80, 0x2e, 0x27, 0xed, 0xe1, 0x9f } 229 }; 230 231 const struct hv_guid hv_guid_netdir = { 232 { 0x3d, 0xaf, 0x2e, 0x8c, 0xa7, 0x32, 0x09, 0x4b, 233 0xab, 0x99, 0xbd, 0x1f, 0x1c, 0x86, 0xb5, 0x01 } 234 }; 235 236 const struct hv_guid hv_guid_rdesktop = { 237 { 0xf4, 0xac, 0x6a, 0x27, 0x15, 0xac, 0x6c, 0x42, 238 0x98, 0xdd, 0x75, 0x21, 0xad, 0x3f, 0x01, 0xfe } 239 }; 240 241 /* Automatic Virtual Machine Activation (AVMA) Services */ 242 const struct hv_guid hv_guid_avma1 = { 243 { 0x55, 0xb2, 0x87, 0x44, 0x8c, 0xb8, 0x3f, 0x40, 244 0xbb, 0x51, 0xd1, 0xf6, 0x9c, 0xf1, 0x7f, 0x87 } 245 }; 246 247 const struct hv_guid hv_guid_avma2 = { 248 { 0xf4, 0xba, 0x75, 0x33, 0x15, 0x9e, 0x30, 0x4b, 249 0xb7, 0x65, 0x67, 0xac, 0xb1, 0x0d, 0x60, 0x7b } 250 }; 251 252 const struct hv_guid hv_guid_avma3 = { 253 { 0xa0, 0x1f, 0x22, 0x99, 0xad, 0x24, 0xe2, 0x11, 254 0xbe, 0x98, 0x00, 0x1a, 0xa0, 0x1b, 0xbf, 0x6e } 255 }; 256 257 const struct hv_guid hv_guid_avma4 = { 258 { 0x16, 0x57, 0xe6, 0xf8, 0xb3, 0x3c, 0x06, 0x4a, 259 0x9a, 0x60, 0x18, 0x89, 0xc5, 0xcc, 0xca, 0xb5 } 260 }; 261 #endif /* HYPERV_DEBUG */ 262 263 int 264 hv_match(struct device *parent, void *match, void *aux) 265 { 266 struct pv_attach_args *pva = aux; 267 struct pvbus_hv *hv = &pva->pva_hv[PVBUS_HYPERV]; 268 269 if ((hv->hv_major == 0 && hv->hv_minor == 0) || hv->hv_base == 0) 270 return (0); 271 272 return (1); 273 } 274 275 void 276 hv_attach(struct device *parent, struct device *self, void *aux) 277 { 278 struct hv_softc *sc = (struct hv_softc *)self; 279 struct pv_attach_args *pva = aux; 280 struct pvbus_hv *hv = &pva->pva_hv[PVBUS_HYPERV]; 281 282 sc->sc_pvbus = hv; 283 sc->sc_dmat = pva->pva_dmat; 284 285 if (!(hv->hv_features & CPUID_HV_MSR_HYPERCALL) || 286 !(hv->hv_features & CPUID_HV_MSR_SYNIC)) { 287 printf(": not functional\n"); 288 return; 289 } 290 291 DPRINTF("\n"); 292 293 hv_set_version(sc); 294 295 if (hv->hv_features & CPUID_HV_MSR_TIME_REFCNT) 296 tc_init(&hv_timecounter); 297 298 if (hv_init_hypercall(sc)) 299 return; 300 301 /* Wire it up to the global */ 302 hv_sc = sc; 303 304 if (hv_init_interrupts(sc)) 305 return; 306 307 if (hv_vmbus_connect(sc)) 308 return; 309 310 DPRINTF("%s", sc->sc_dev.dv_xname); 311 printf(": protocol %d.%d, features %#x\n", 312 VMBUS_VERSION_MAJOR(sc->sc_proto), 313 VMBUS_VERSION_MINOR(sc->sc_proto), 314 hv->hv_features); 315 316 if (hv_channel_scan(sc)) 317 return; 318 319 /* Attach heartbeat, KVP and other "internal" services */ 320 hv_attach_icdevs(sc); 321 322 /* Attach devices with external drivers */ 323 hv_attach_devices(sc); 324 } 325 326 void 327 hv_set_version(struct hv_softc *sc) 328 { 329 uint64_t ver; 330 331 /* OpenBSD build date */ 332 ver = MSR_HV_GUESTID_OSTYPE_OPENBSD; 333 ver |= (uint64_t)OpenBSD << MSR_HV_GUESTID_VERSION_SHIFT; 334 wrmsr(MSR_HV_GUEST_OS_ID, ver); 335 } 336 337 u_int 338 hv_gettime(struct timecounter *tc) 339 { 340 u_int now = rdmsr(MSR_HV_TIME_REF_COUNT); 341 342 return (now); 343 } 344 345 void 346 hv_delay(int usecs) 347 { 348 uint64_t interval, start; 349 350 /* 10 MHz fixed frequency */ 351 interval = (uint64_t)usecs * 10; 352 start = rdmsr(MSR_HV_TIME_REF_COUNT); 353 while (rdmsr(MSR_HV_TIME_REF_COUNT) - start < interval) 354 CPU_BUSY_CYCLE(); 355 } 356 357 int 358 hv_init_hypercall(struct hv_softc *sc) 359 { 360 extern void *hv_hypercall_page; 361 uint64_t msr; 362 paddr_t pa; 363 364 sc->sc_hc = &hv_hypercall_page; 365 366 if (!pmap_extract(pmap_kernel(), (vaddr_t)sc->sc_hc, &pa)) { 367 printf(": hypercall page PA extraction failed\n"); 368 return (-1); 369 } 370 371 msr = (atop(pa) << MSR_HV_HYPERCALL_PGSHIFT) | MSR_HV_HYPERCALL_ENABLE; 372 wrmsr(MSR_HV_HYPERCALL, msr); 373 374 if (!(rdmsr(MSR_HV_HYPERCALL) & MSR_HV_HYPERCALL_ENABLE)) { 375 printf(": failed to set up a hypercall page\n"); 376 return (-1); 377 } 378 379 return (0); 380 } 381 382 uint64_t 383 hv_hypercall(struct hv_softc *sc, uint64_t control, void *input, 384 void *output) 385 { 386 paddr_t input_pa = 0, output_pa = 0; 387 uint64_t status = 0; 388 389 if (input != NULL && 390 pmap_extract(pmap_kernel(), (vaddr_t)input, &input_pa) == 0) { 391 printf("%s: hypercall input PA extraction failed\n", 392 sc->sc_dev.dv_xname); 393 return (~HYPERCALL_STATUS_SUCCESS); 394 } 395 396 if (output != NULL && 397 pmap_extract(pmap_kernel(), (vaddr_t)output, &output_pa) == 0) { 398 printf("%s: hypercall output PA extraction failed\n", 399 sc->sc_dev.dv_xname); 400 return (~HYPERCALL_STATUS_SUCCESS); 401 } 402 403 #ifdef __amd64__ 404 extern uint64_t hv_hypercall_trampoline(uint64_t, paddr_t, paddr_t); 405 status = hv_hypercall_trampoline(control, input_pa, output_pa); 406 #else /* __i386__ */ 407 { 408 uint32_t control_hi = control >> 32; 409 uint32_t control_lo = control & 0xfffffffff; 410 uint32_t status_hi = 1; 411 uint32_t status_lo = 1; 412 413 __asm__ volatile ("call *%8" : 414 "=d" (status_hi), "=a"(status_lo) : 415 "d" (control_hi), "a" (control_lo), 416 "b" (0), "c" (input_pa), "D" (0), "S" (output_pa), 417 "m" (sc->sc_hc)); 418 419 status = status_lo | ((uint64_t)status_hi << 32); 420 } 421 #endif /* __amd64__ */ 422 423 return (status); 424 } 425 426 int 427 hv_init_interrupts(struct hv_softc *sc) 428 { 429 struct cpu_info *ci = curcpu(); 430 int cpu = CPU_INFO_UNIT(ci); 431 432 sc->sc_idtvec = LAPIC_HYPERV_VECTOR; 433 434 TAILQ_INIT(&sc->sc_reqs); 435 mtx_init(&sc->sc_reqlck, IPL_NET); 436 437 TAILQ_INIT(&sc->sc_rsps); 438 mtx_init(&sc->sc_rsplck, IPL_NET); 439 440 sc->sc_simp[cpu] = km_alloc(PAGE_SIZE, &kv_any, &kp_zero, &kd_nowait); 441 if (sc->sc_simp[cpu] == NULL) { 442 printf(": failed to allocate SIMP\n"); 443 return (-1); 444 } 445 446 sc->sc_siep[cpu] = km_alloc(PAGE_SIZE, &kv_any, &kp_zero, &kd_nowait); 447 if (sc->sc_siep[cpu] == NULL) { 448 printf(": failed to allocate SIEP\n"); 449 km_free(sc->sc_simp[cpu], PAGE_SIZE, &kv_any, &kp_zero); 450 return (-1); 451 } 452 453 sc->sc_proto = VMBUS_VERSION_WS2008; 454 455 return (hv_init_synic(sc)); 456 } 457 458 int 459 hv_init_synic(struct hv_softc *sc) 460 { 461 struct cpu_info *ci = curcpu(); 462 int cpu = CPU_INFO_UNIT(ci); 463 uint64_t simp, siefp, sctrl, sint; 464 paddr_t pa; 465 466 /* 467 * Setup the Synic's message page 468 */ 469 if (!pmap_extract(pmap_kernel(), (vaddr_t)sc->sc_simp[cpu], &pa)) { 470 printf(": SIMP PA extraction failed\n"); 471 return (-1); 472 } 473 simp = rdmsr(MSR_HV_SIMP); 474 simp &= (1 << MSR_HV_SIMP_PGSHIFT) - 1; 475 simp |= (atop(pa) << MSR_HV_SIMP_PGSHIFT); 476 simp |= MSR_HV_SIMP_ENABLE; 477 wrmsr(MSR_HV_SIMP, simp); 478 479 /* 480 * Setup the Synic's event page 481 */ 482 if (!pmap_extract(pmap_kernel(), (vaddr_t)sc->sc_siep[cpu], &pa)) { 483 printf(": SIEP PA extraction failed\n"); 484 return (-1); 485 } 486 siefp = rdmsr(MSR_HV_SIEFP); 487 siefp &= (1<<MSR_HV_SIEFP_PGSHIFT) - 1; 488 siefp |= (atop(pa) << MSR_HV_SIEFP_PGSHIFT); 489 siefp |= MSR_HV_SIEFP_ENABLE; 490 wrmsr(MSR_HV_SIEFP, siefp); 491 492 /* 493 * Configure and unmask SINT for message and event flags 494 */ 495 sint = rdmsr(MSR_HV_SINT0 + VMBUS_SINT_MESSAGE); 496 sint = sc->sc_idtvec | MSR_HV_SINT_AUTOEOI | 497 (sint & MSR_HV_SINT_RSVD_MASK); 498 wrmsr(MSR_HV_SINT0 + VMBUS_SINT_MESSAGE, sint); 499 500 /* Enable the global synic bit */ 501 sctrl = rdmsr(MSR_HV_SCONTROL); 502 sctrl |= MSR_HV_SCTRL_ENABLE; 503 wrmsr(MSR_HV_SCONTROL, sctrl); 504 505 sc->sc_vcpus[cpu] = rdmsr(MSR_HV_VP_INDEX); 506 507 DPRINTF("vcpu%u: SIMP %#llx SIEFP %#llx SCTRL %#llx\n", 508 sc->sc_vcpus[cpu], simp, siefp, sctrl); 509 510 return (0); 511 } 512 513 int 514 hv_cmd(struct hv_softc *sc, void *cmd, size_t cmdlen, void *rsp, 515 size_t rsplen, int flags) 516 { 517 struct hv_msg msg; 518 int rv; 519 520 if (cmdlen > VMBUS_MSG_DSIZE_MAX) { 521 printf("%s: payload too large (%lu)\n", sc->sc_dev.dv_xname, 522 cmdlen); 523 return (EMSGSIZE); 524 } 525 526 memset(&msg, 0, sizeof(msg)); 527 528 msg.msg_req.hc_dsize = cmdlen; 529 memcpy(msg.msg_req.hc_data, cmd, cmdlen); 530 531 if (!(flags & HCF_NOREPLY)) { 532 msg.msg_rsp = rsp; 533 msg.msg_rsplen = rsplen; 534 } else 535 msg.msg_flags |= MSGF_NOQUEUE; 536 537 if (flags & HCF_NOSLEEP) 538 msg.msg_flags |= MSGF_NOSLEEP; 539 540 if ((rv = hv_start(sc, &msg)) != 0) 541 return (rv); 542 return (hv_reply(sc, &msg)); 543 } 544 545 int 546 hv_start(struct hv_softc *sc, struct hv_msg *msg) 547 { 548 const int delays[] = { 100, 100, 100, 500, 500, 5000, 5000, 5000 }; 549 const char *wchan = "hvstart"; 550 uint16_t status; 551 int i, s; 552 553 msg->msg_req.hc_connid = VMBUS_CONNID_MESSAGE; 554 msg->msg_req.hc_msgtype = 1; 555 556 if (!(msg->msg_flags & MSGF_NOQUEUE)) { 557 mtx_enter(&sc->sc_reqlck); 558 TAILQ_INSERT_TAIL(&sc->sc_reqs, msg, msg_entry); 559 mtx_leave(&sc->sc_reqlck); 560 } 561 562 for (i = 0; i < nitems(delays); i++) { 563 status = hv_hypercall(sc, HYPERCALL_POST_MESSAGE, 564 &msg->msg_req, NULL); 565 if (status == HYPERCALL_STATUS_SUCCESS) 566 break; 567 if (msg->msg_flags & MSGF_NOSLEEP) { 568 delay(delays[i]); 569 s = splnet(); 570 hv_intr(); 571 splx(s); 572 } else { 573 tsleep_nsec(wchan, PRIBIO, wchan, 574 USEC_TO_NSEC(delays[i])); 575 } 576 } 577 if (status != 0) { 578 printf("%s: posting vmbus message failed with %d\n", 579 sc->sc_dev.dv_xname, status); 580 if (!(msg->msg_flags & MSGF_NOQUEUE)) { 581 mtx_enter(&sc->sc_reqlck); 582 TAILQ_REMOVE(&sc->sc_reqs, msg, msg_entry); 583 mtx_leave(&sc->sc_reqlck); 584 } 585 return (EIO); 586 } 587 588 return (0); 589 } 590 591 static int 592 hv_reply_done(struct hv_softc *sc, struct hv_msg *msg) 593 { 594 struct hv_msg *m; 595 596 mtx_enter(&sc->sc_rsplck); 597 TAILQ_FOREACH(m, &sc->sc_rsps, msg_entry) { 598 if (m == msg) { 599 mtx_leave(&sc->sc_rsplck); 600 return (1); 601 } 602 } 603 mtx_leave(&sc->sc_rsplck); 604 return (0); 605 } 606 607 int 608 hv_reply(struct hv_softc *sc, struct hv_msg *msg) 609 { 610 if (msg->msg_flags & MSGF_NOQUEUE) 611 return (0); 612 613 hv_wait(sc, hv_reply_done, msg, msg, "hvreply"); 614 615 mtx_enter(&sc->sc_rsplck); 616 TAILQ_REMOVE(&sc->sc_rsps, msg, msg_entry); 617 mtx_leave(&sc->sc_rsplck); 618 619 return (0); 620 } 621 622 void 623 hv_wait(struct hv_softc *sc, int (*cond)(struct hv_softc *, struct hv_msg *), 624 struct hv_msg *msg, void *wchan, const char *wmsg) 625 { 626 int s; 627 628 KASSERT(cold ? msg->msg_flags & MSGF_NOSLEEP : 1); 629 630 while (!cond(sc, msg)) { 631 if (msg->msg_flags & MSGF_NOSLEEP) { 632 delay(1000); 633 s = splnet(); 634 hv_intr(); 635 splx(s); 636 } else { 637 tsleep_nsec(wchan, PRIBIO, wmsg ? wmsg : "hvwait", 638 USEC_TO_NSEC(1000)); 639 } 640 } 641 } 642 643 uint16_t 644 hv_intr_signal(struct hv_softc *sc, void *con) 645 { 646 uint64_t status; 647 648 status = hv_hypercall(sc, HYPERCALL_SIGNAL_EVENT, con, NULL); 649 return ((uint16_t)status); 650 } 651 652 void 653 hv_intr(void) 654 { 655 struct hv_softc *sc = hv_sc; 656 657 hv_event_intr(sc); 658 hv_message_intr(sc); 659 } 660 661 void 662 hv_event_intr(struct hv_softc *sc) 663 { 664 struct vmbus_evtflags *evt; 665 struct cpu_info *ci = curcpu(); 666 int cpu = CPU_INFO_UNIT(ci); 667 int bit, row, maxrow, chanid; 668 struct hv_channel *ch; 669 u_long *revents, pending; 670 671 evt = (struct vmbus_evtflags *)sc->sc_siep[cpu] + 672 VMBUS_SINT_MESSAGE; 673 if ((sc->sc_proto == VMBUS_VERSION_WS2008) || 674 (sc->sc_proto == VMBUS_VERSION_WIN7)) { 675 if (!test_bit(0, &evt->evt_flags[0])) 676 return; 677 clear_bit(0, &evt->evt_flags[0]); 678 maxrow = VMBUS_CHAN_MAX_COMPAT / VMBUS_EVTFLAG_LEN; 679 /* 680 * receive size is 1/2 page and divide that by 4 bytes 681 */ 682 revents = sc->sc_revents; 683 } else { 684 maxrow = nitems(evt->evt_flags); 685 /* 686 * On Host with Win8 or above, the event page can be 687 * checked directly to get the id of the channel 688 * that has the pending interrupt. 689 */ 690 revents = &evt->evt_flags[0]; 691 } 692 693 for (row = 0; row < maxrow; row++) { 694 if (revents[row] == 0) 695 continue; 696 pending = atomic_swap_ulong(&revents[row], 0); 697 for (bit = 0; pending > 0; pending >>= 1, bit++) { 698 if ((pending & 1) == 0) 699 continue; 700 chanid = (row * LONG_BIT) + bit; 701 /* vmbus channel protocol message */ 702 if (chanid == 0) 703 continue; 704 ch = hv_channel_lookup(sc, chanid); 705 if (ch == NULL) { 706 printf("%s: unhandled event on %d\n", 707 sc->sc_dev.dv_xname, chanid); 708 continue; 709 } 710 if (ch->ch_state != HV_CHANSTATE_OPENED) { 711 printf("%s: channel %d is not active\n", 712 sc->sc_dev.dv_xname, chanid); 713 continue; 714 } 715 ch->ch_evcnt.ec_count++; 716 hv_channel_schedule(ch); 717 } 718 } 719 } 720 721 void 722 hv_message_intr(struct hv_softc *sc) 723 { 724 struct vmbus_message *msg; 725 struct vmbus_chanmsg_hdr *hdr; 726 struct cpu_info *ci = curcpu(); 727 int cpu = CPU_INFO_UNIT(ci); 728 729 for (;;) { 730 msg = (struct vmbus_message *)sc->sc_simp[cpu] + 731 VMBUS_SINT_MESSAGE; 732 if (msg->msg_type == VMBUS_MSGTYPE_NONE) 733 break; 734 735 hdr = (struct vmbus_chanmsg_hdr *)msg->msg_data; 736 if (hdr->chm_type >= VMBUS_CHANMSG_COUNT) { 737 printf("%s: unhandled message type %u flags %#x\n", 738 sc->sc_dev.dv_xname, hdr->chm_type, 739 msg->msg_flags); 740 goto skip; 741 } 742 if (hv_msg_dispatch[hdr->chm_type].hmd_handler) 743 hv_msg_dispatch[hdr->chm_type].hmd_handler(sc, hdr); 744 else 745 printf("%s: unhandled message type %u\n", 746 sc->sc_dev.dv_xname, hdr->chm_type); 747 skip: 748 msg->msg_type = VMBUS_MSGTYPE_NONE; 749 virtio_membar_sync(); 750 if (msg->msg_flags & VMBUS_MSGFLAG_PENDING) 751 wrmsr(MSR_HV_EOM, 0); 752 } 753 } 754 755 void 756 hv_channel_response(struct hv_softc *sc, struct vmbus_chanmsg_hdr *rsphdr) 757 { 758 struct hv_msg *msg; 759 struct vmbus_chanmsg_hdr *reqhdr; 760 int req; 761 762 req = hv_msg_dispatch[rsphdr->chm_type].hmd_request; 763 mtx_enter(&sc->sc_reqlck); 764 TAILQ_FOREACH(msg, &sc->sc_reqs, msg_entry) { 765 reqhdr = (struct vmbus_chanmsg_hdr *)&msg->msg_req.hc_data; 766 if (reqhdr->chm_type == req) { 767 TAILQ_REMOVE(&sc->sc_reqs, msg, msg_entry); 768 break; 769 } 770 } 771 mtx_leave(&sc->sc_reqlck); 772 if (msg != NULL) { 773 memcpy(msg->msg_rsp, rsphdr, msg->msg_rsplen); 774 mtx_enter(&sc->sc_rsplck); 775 TAILQ_INSERT_TAIL(&sc->sc_rsps, msg, msg_entry); 776 mtx_leave(&sc->sc_rsplck); 777 wakeup(msg); 778 } 779 } 780 781 void 782 hv_channel_offer(struct hv_softc *sc, struct vmbus_chanmsg_hdr *hdr) 783 { 784 struct hv_offer *co; 785 786 co = malloc(sizeof(*co), M_DEVBUF, M_NOWAIT | M_ZERO); 787 if (co == NULL) { 788 printf("%s: failed to allocate an offer object\n", 789 sc->sc_dev.dv_xname); 790 return; 791 } 792 793 memcpy(&co->co_chan, hdr, sizeof(co->co_chan)); 794 795 mtx_enter(&sc->sc_offerlck); 796 SIMPLEQ_INSERT_TAIL(&sc->sc_offers, co, co_entry); 797 mtx_leave(&sc->sc_offerlck); 798 } 799 800 void 801 hv_channel_rescind(struct hv_softc *sc, struct vmbus_chanmsg_hdr *hdr) 802 { 803 const struct vmbus_chanmsg_chrescind *cmd; 804 805 cmd = (const struct vmbus_chanmsg_chrescind *)hdr; 806 printf("%s: revoking channel %u\n", sc->sc_dev.dv_xname, 807 cmd->chm_chanid); 808 } 809 810 void 811 hv_channel_delivered(struct hv_softc *sc, struct vmbus_chanmsg_hdr *hdr) 812 { 813 atomic_setbits_int(&sc->sc_flags, HSF_OFFERS_DELIVERED); 814 wakeup(&sc->sc_offers); 815 } 816 817 int 818 hv_vmbus_connect(struct hv_softc *sc) 819 { 820 const uint32_t versions[] = { 821 VMBUS_VERSION_WIN10, 822 VMBUS_VERSION_WIN8_1, VMBUS_VERSION_WIN8, 823 VMBUS_VERSION_WIN7, VMBUS_VERSION_WS2008 824 }; 825 struct vmbus_chanmsg_connect cmd; 826 struct vmbus_chanmsg_connect_resp rsp; 827 paddr_t epa, mpa1, mpa2; 828 int i; 829 830 sc->sc_events = km_alloc(PAGE_SIZE, &kv_any, &kp_zero, &kd_nowait); 831 if (sc->sc_events == NULL) { 832 printf(": failed to allocate channel port events page\n"); 833 goto errout; 834 } 835 if (!pmap_extract(pmap_kernel(), (vaddr_t)sc->sc_events, &epa)) { 836 printf(": channel port events page PA extraction failed\n"); 837 goto errout; 838 } 839 840 sc->sc_wevents = (u_long *)sc->sc_events; 841 sc->sc_revents = (u_long *)((caddr_t)sc->sc_events + (PAGE_SIZE >> 1)); 842 843 sc->sc_monitor[0] = km_alloc(PAGE_SIZE, &kv_any, &kp_zero, &kd_nowait); 844 if (sc->sc_monitor[0] == NULL) { 845 printf(": failed to allocate monitor page 1\n"); 846 goto errout; 847 } 848 if (!pmap_extract(pmap_kernel(), (vaddr_t)sc->sc_monitor[0], &mpa1)) { 849 printf(": monitor page 1 PA extraction failed\n"); 850 goto errout; 851 } 852 853 sc->sc_monitor[1] = km_alloc(PAGE_SIZE, &kv_any, &kp_zero, &kd_nowait); 854 if (sc->sc_monitor[1] == NULL) { 855 printf(": failed to allocate monitor page 2\n"); 856 goto errout; 857 } 858 if (!pmap_extract(pmap_kernel(), (vaddr_t)sc->sc_monitor[1], &mpa2)) { 859 printf(": monitor page 2 PA extraction failed\n"); 860 goto errout; 861 } 862 863 memset(&cmd, 0, sizeof(cmd)); 864 cmd.chm_hdr.chm_type = VMBUS_CHANMSG_CONNECT; 865 cmd.chm_evtflags = (uint64_t)epa; 866 cmd.chm_mnf1 = (uint64_t)mpa1; 867 cmd.chm_mnf2 = (uint64_t)mpa2; 868 869 memset(&rsp, 0, sizeof(rsp)); 870 871 for (i = 0; i < nitems(versions); i++) { 872 cmd.chm_ver = versions[i]; 873 if (hv_cmd(sc, &cmd, sizeof(cmd), &rsp, sizeof(rsp), 874 HCF_NOSLEEP)) { 875 DPRINTF("%s: CONNECT failed\n", 876 sc->sc_dev.dv_xname); 877 goto errout; 878 } 879 if (rsp.chm_done) { 880 sc->sc_flags |= HSF_CONNECTED; 881 sc->sc_proto = versions[i]; 882 sc->sc_handle = VMBUS_GPADL_START; 883 break; 884 } 885 } 886 if (i == nitems(versions)) { 887 printf("%s: failed to negotiate protocol version\n", 888 sc->sc_dev.dv_xname); 889 goto errout; 890 } 891 892 return (0); 893 894 errout: 895 if (sc->sc_events) { 896 km_free(sc->sc_events, PAGE_SIZE, &kv_any, &kp_zero); 897 sc->sc_events = NULL; 898 sc->sc_wevents = NULL; 899 sc->sc_revents = NULL; 900 } 901 if (sc->sc_monitor[0]) { 902 km_free(sc->sc_monitor[0], PAGE_SIZE, &kv_any, &kp_zero); 903 sc->sc_monitor[0] = NULL; 904 } 905 if (sc->sc_monitor[1]) { 906 km_free(sc->sc_monitor[1], PAGE_SIZE, &kv_any, &kp_zero); 907 sc->sc_monitor[1] = NULL; 908 } 909 return (-1); 910 } 911 912 #ifdef HYPERV_DEBUG 913 static inline char * 914 guidprint(struct hv_guid *a) 915 { 916 /* 3 0 5 4 7 6 8 9 10 15 */ 917 /* 33221100-5544-7766-9988-FFEEDDCCBBAA */ 918 static char buf[16 * 2 + 4 + 1]; 919 int i, j = 0; 920 921 for (i = 3; i != -1; i -= 1, j += 2) 922 snprintf(&buf[j], 3, "%02x", (uint8_t)a->data[i]); 923 buf[j++] = '-'; 924 for (i = 5; i != 3; i -= 1, j += 2) 925 snprintf(&buf[j], 3, "%02x", (uint8_t)a->data[i]); 926 buf[j++] = '-'; 927 for (i = 7; i != 5; i -= 1, j += 2) 928 snprintf(&buf[j], 3, "%02x", (uint8_t)a->data[i]); 929 buf[j++] = '-'; 930 for (i = 8; i < 10; i += 1, j += 2) 931 snprintf(&buf[j], 3, "%02x", (uint8_t)a->data[i]); 932 buf[j++] = '-'; 933 for (i = 10; i < 16; i += 1, j += 2) 934 snprintf(&buf[j], 3, "%02x", (uint8_t)a->data[i]); 935 return (&buf[0]); 936 } 937 #endif /* HYPERV_DEBUG */ 938 939 void 940 hv_guid_sprint(struct hv_guid *guid, char *str, size_t size) 941 { 942 const struct { 943 const struct hv_guid *guid; 944 const char *ident; 945 } map[] = { 946 { &hv_guid_network, "network" }, 947 { &hv_guid_ide, "ide" }, 948 { &hv_guid_scsi, "scsi" }, 949 { &hv_guid_shutdown, "shutdown" }, 950 { &hv_guid_timesync, "timesync" }, 951 { &hv_guid_heartbeat, "heartbeat" }, 952 { &hv_guid_kvp, "kvp" }, 953 #ifdef HYPERV_DEBUG 954 { &hv_guid_vss, "vss" }, 955 { &hv_guid_dynmem, "dynamic-memory" }, 956 { &hv_guid_mouse, "mouse" }, 957 { &hv_guid_kbd, "keyboard" }, 958 { &hv_guid_video, "video" }, 959 { &hv_guid_fc, "fiber-channel" }, 960 { &hv_guid_fcopy, "file-copy" }, 961 { &hv_guid_pcie, "pcie-passthrough" }, 962 { &hv_guid_netdir, "network-direct" }, 963 { &hv_guid_rdesktop, "remote-desktop" }, 964 { &hv_guid_avma1, "avma-1" }, 965 { &hv_guid_avma2, "avma-2" }, 966 { &hv_guid_avma3, "avma-3" }, 967 { &hv_guid_avma4, "avma-4" }, 968 #endif 969 }; 970 int i; 971 972 for (i = 0; i < nitems(map); i++) { 973 if (memcmp(guid, map[i].guid, sizeof(*guid)) == 0) { 974 strlcpy(str, map[i].ident, size); 975 return; 976 } 977 } 978 #ifdef HYPERV_DEBUG 979 strlcpy(str, guidprint(guid), size); 980 #endif 981 } 982 983 static int 984 hv_channel_scan_done(struct hv_softc *sc, struct hv_msg *msg __unused) 985 { 986 return (sc->sc_flags & HSF_OFFERS_DELIVERED); 987 } 988 989 int 990 hv_channel_scan(struct hv_softc *sc) 991 { 992 struct vmbus_chanmsg_hdr hdr; 993 struct vmbus_chanmsg_choffer rsp; 994 struct hv_offer *co; 995 996 SIMPLEQ_INIT(&sc->sc_offers); 997 mtx_init(&sc->sc_offerlck, IPL_NET); 998 999 memset(&hdr, 0, sizeof(hdr)); 1000 hdr.chm_type = VMBUS_CHANMSG_CHREQUEST; 1001 1002 if (hv_cmd(sc, &hdr, sizeof(hdr), &rsp, sizeof(rsp), 1003 HCF_NOSLEEP | HCF_NOREPLY)) { 1004 DPRINTF("%s: CHREQUEST failed\n", sc->sc_dev.dv_xname); 1005 return (-1); 1006 } 1007 1008 hv_wait(sc, hv_channel_scan_done, (struct hv_msg *)&hdr, 1009 &sc->sc_offers, "hvscan"); 1010 1011 TAILQ_INIT(&sc->sc_channels); 1012 mtx_init(&sc->sc_channelck, IPL_NET); 1013 1014 mtx_enter(&sc->sc_offerlck); 1015 while (!SIMPLEQ_EMPTY(&sc->sc_offers)) { 1016 co = SIMPLEQ_FIRST(&sc->sc_offers); 1017 SIMPLEQ_REMOVE_HEAD(&sc->sc_offers, co_entry); 1018 mtx_leave(&sc->sc_offerlck); 1019 1020 hv_process_offer(sc, co); 1021 free(co, M_DEVBUF, sizeof(*co)); 1022 1023 mtx_enter(&sc->sc_offerlck); 1024 } 1025 mtx_leave(&sc->sc_offerlck); 1026 1027 return (0); 1028 } 1029 1030 void 1031 hv_process_offer(struct hv_softc *sc, struct hv_offer *co) 1032 { 1033 struct hv_channel *ch, *nch; 1034 1035 nch = malloc(sizeof(*nch), M_DEVBUF, M_ZERO | M_NOWAIT); 1036 if (nch == NULL) { 1037 printf("%s: failed to allocate memory for the channel\n", 1038 sc->sc_dev.dv_xname); 1039 return; 1040 } 1041 nch->ch_sc = sc; 1042 hv_guid_sprint(&co->co_chan.chm_chtype, nch->ch_ident, 1043 sizeof(nch->ch_ident)); 1044 1045 /* 1046 * By default we setup state to enable batched reading. 1047 * A specific service can choose to disable this prior 1048 * to opening the channel. 1049 */ 1050 nch->ch_flags |= CHF_BATCHED; 1051 1052 KASSERT((((vaddr_t)&nch->ch_monprm) & 0x7) == 0); 1053 memset(&nch->ch_monprm, 0, sizeof(nch->ch_monprm)); 1054 nch->ch_monprm.mp_connid = VMBUS_CONNID_EVENT; 1055 1056 if (sc->sc_proto != VMBUS_VERSION_WS2008) 1057 nch->ch_monprm.mp_connid = co->co_chan.chm_connid; 1058 1059 if (co->co_chan.chm_flags1 & VMBUS_CHOFFER_FLAG1_HASMNF) { 1060 nch->ch_mgroup = co->co_chan.chm_montrig / VMBUS_MONTRIG_LEN; 1061 nch->ch_mindex = co->co_chan.chm_montrig % VMBUS_MONTRIG_LEN; 1062 nch->ch_flags |= CHF_MONITOR; 1063 } 1064 1065 nch->ch_id = co->co_chan.chm_chanid; 1066 1067 memcpy(&nch->ch_type, &co->co_chan.chm_chtype, sizeof(ch->ch_type)); 1068 memcpy(&nch->ch_inst, &co->co_chan.chm_chinst, sizeof(ch->ch_inst)); 1069 1070 mtx_enter(&sc->sc_channelck); 1071 TAILQ_FOREACH(ch, &sc->sc_channels, ch_entry) { 1072 if (!memcmp(&ch->ch_type, &nch->ch_type, sizeof(ch->ch_type)) && 1073 !memcmp(&ch->ch_inst, &nch->ch_inst, sizeof(ch->ch_inst))) 1074 break; 1075 } 1076 if (ch != NULL) { 1077 if (co->co_chan.chm_subidx == 0) { 1078 printf("%s: unknown offer \"%s\"\n", 1079 sc->sc_dev.dv_xname, nch->ch_ident); 1080 mtx_leave(&sc->sc_channelck); 1081 free(nch, M_DEVBUF, sizeof(*nch)); 1082 return; 1083 } 1084 #ifdef HYPERV_DEBUG 1085 printf("%s: subchannel %u for \"%s\"\n", sc->sc_dev.dv_xname, 1086 co->co_chan.chm_subidx, ch->ch_ident); 1087 #endif 1088 mtx_leave(&sc->sc_channelck); 1089 free(nch, M_DEVBUF, sizeof(*nch)); 1090 return; 1091 } 1092 1093 nch->ch_state = HV_CHANSTATE_OFFERED; 1094 1095 TAILQ_INSERT_TAIL(&sc->sc_channels, nch, ch_entry); 1096 mtx_leave(&sc->sc_channelck); 1097 1098 #ifdef HYPERV_DEBUG 1099 printf("%s: channel %u: \"%s\"", sc->sc_dev.dv_xname, nch->ch_id, 1100 nch->ch_ident); 1101 if (nch->ch_flags & CHF_MONITOR) 1102 printf(", monitor %u\n", co->co_chan.chm_montrig); 1103 else 1104 printf("\n"); 1105 #endif 1106 } 1107 1108 struct hv_channel * 1109 hv_channel_lookup(struct hv_softc *sc, uint32_t relid) 1110 { 1111 struct hv_channel *ch; 1112 1113 TAILQ_FOREACH(ch, &sc->sc_channels, ch_entry) { 1114 if (ch->ch_id == relid) 1115 return (ch); 1116 } 1117 return (NULL); 1118 } 1119 1120 int 1121 hv_channel_ring_create(struct hv_channel *ch, uint32_t buflen) 1122 { 1123 struct hv_softc *sc = ch->ch_sc; 1124 1125 buflen = roundup(buflen, PAGE_SIZE) + sizeof(struct vmbus_bufring); 1126 ch->ch_ring = km_alloc(2 * buflen, &kv_any, &kp_zero, cold ? 1127 &kd_nowait : &kd_waitok); 1128 if (ch->ch_ring == NULL) { 1129 printf("%s: failed to allocate channel ring\n", 1130 sc->sc_dev.dv_xname); 1131 return (-1); 1132 } 1133 ch->ch_ring_size = 2 * buflen; 1134 1135 memset(&ch->ch_wrd, 0, sizeof(ch->ch_wrd)); 1136 ch->ch_wrd.rd_ring = (struct vmbus_bufring *)ch->ch_ring; 1137 ch->ch_wrd.rd_size = buflen; 1138 ch->ch_wrd.rd_dsize = buflen - sizeof(struct vmbus_bufring); 1139 mtx_init(&ch->ch_wrd.rd_lock, IPL_NET); 1140 1141 memset(&ch->ch_rrd, 0, sizeof(ch->ch_rrd)); 1142 ch->ch_rrd.rd_ring = (struct vmbus_bufring *)((uint8_t *)ch->ch_ring + 1143 buflen); 1144 ch->ch_rrd.rd_size = buflen; 1145 ch->ch_rrd.rd_dsize = buflen - sizeof(struct vmbus_bufring); 1146 mtx_init(&ch->ch_rrd.rd_lock, IPL_NET); 1147 1148 if (hv_handle_alloc(ch, ch->ch_ring, 2 * buflen, &ch->ch_ring_gpadl)) { 1149 printf("%s: failed to obtain a PA handle for the ring\n", 1150 sc->sc_dev.dv_xname); 1151 hv_channel_ring_destroy(ch); 1152 return (-1); 1153 } 1154 1155 return (0); 1156 } 1157 1158 void 1159 hv_channel_ring_destroy(struct hv_channel *ch) 1160 { 1161 km_free(ch->ch_ring, ch->ch_ring_size, &kv_any, &kp_zero); 1162 ch->ch_ring = NULL; 1163 hv_handle_free(ch, ch->ch_ring_gpadl); 1164 1165 memset(&ch->ch_wrd, 0, sizeof(ch->ch_wrd)); 1166 memset(&ch->ch_rrd, 0, sizeof(ch->ch_rrd)); 1167 } 1168 1169 int 1170 hv_channel_open(struct hv_channel *ch, size_t buflen, void *udata, 1171 size_t udatalen, void (*handler)(void *), void *arg) 1172 { 1173 struct hv_softc *sc = ch->ch_sc; 1174 struct vmbus_chanmsg_chopen cmd; 1175 struct vmbus_chanmsg_chopen_resp rsp; 1176 int rv; 1177 1178 if (ch->ch_ring == NULL && 1179 hv_channel_ring_create(ch, buflen)) { 1180 DPRINTF("%s: failed to create channel ring\n", 1181 sc->sc_dev.dv_xname); 1182 return (-1); 1183 } 1184 1185 memset(&cmd, 0, sizeof(cmd)); 1186 cmd.chm_hdr.chm_type = VMBUS_CHANMSG_CHOPEN; 1187 cmd.chm_openid = ch->ch_id; 1188 cmd.chm_chanid = ch->ch_id; 1189 cmd.chm_gpadl = ch->ch_ring_gpadl; 1190 cmd.chm_txbr_pgcnt = ch->ch_wrd.rd_size >> PAGE_SHIFT; 1191 cmd.chm_vcpuid = ch->ch_vcpu; 1192 1193 if (udata && udatalen > 0) 1194 memcpy(cmd.chm_udata, udata, udatalen); 1195 1196 memset(&rsp, 0, sizeof(rsp)); 1197 1198 ch->ch_handler = handler; 1199 ch->ch_ctx = arg; 1200 1201 ch->ch_state = HV_CHANSTATE_OPENED; 1202 1203 rv = hv_cmd(sc, &cmd, sizeof(cmd), &rsp, sizeof(rsp), 1204 cold ? HCF_NOSLEEP : HCF_SLEEPOK); 1205 if (rv) { 1206 hv_channel_ring_destroy(ch); 1207 DPRINTF("%s: CHOPEN failed with %d\n", 1208 sc->sc_dev.dv_xname, rv); 1209 ch->ch_handler = NULL; 1210 ch->ch_ctx = NULL; 1211 ch->ch_state = HV_CHANSTATE_OFFERED; 1212 return (-1); 1213 } 1214 1215 return (0); 1216 } 1217 1218 int 1219 hv_channel_close(struct hv_channel *ch) 1220 { 1221 struct hv_softc *sc = ch->ch_sc; 1222 struct vmbus_chanmsg_chclose cmd; 1223 int rv; 1224 1225 memset(&cmd, 0, sizeof(cmd)); 1226 cmd.chm_hdr.chm_type = VMBUS_CHANMSG_CHCLOSE; 1227 cmd.chm_chanid = ch->ch_id; 1228 1229 ch->ch_state = HV_CHANSTATE_CLOSING; 1230 rv = hv_cmd(sc, &cmd, sizeof(cmd), NULL, 0, HCF_NOREPLY); 1231 if (rv) { 1232 DPRINTF("%s: CHCLOSE failed with %d\n", 1233 sc->sc_dev.dv_xname, rv); 1234 return (-1); 1235 } 1236 ch->ch_state = HV_CHANSTATE_CLOSED; 1237 hv_channel_ring_destroy(ch); 1238 return (0); 1239 } 1240 1241 static inline void 1242 hv_channel_setevent(struct hv_softc *sc, struct hv_channel *ch) 1243 { 1244 struct vmbus_mon_trig *mtg; 1245 1246 /* Each uint32_t represents 32 channels */ 1247 set_bit(ch->ch_id, sc->sc_wevents); 1248 if (ch->ch_flags & CHF_MONITOR) { 1249 mtg = &sc->sc_monitor[1]->mnf_trigs[ch->ch_mgroup]; 1250 set_bit(ch->ch_mindex, &mtg->mt_pending); 1251 } else 1252 hv_intr_signal(sc, &ch->ch_monprm); 1253 } 1254 1255 void 1256 hv_channel_intr(void *arg) 1257 { 1258 struct hv_channel *ch = arg; 1259 1260 if (hv_channel_ready(ch)) 1261 ch->ch_handler(ch->ch_ctx); 1262 1263 if (hv_channel_unpause(ch) == 0) 1264 return; 1265 1266 hv_channel_pause(ch); 1267 hv_channel_schedule(ch); 1268 } 1269 1270 int 1271 hv_channel_setdeferred(struct hv_channel *ch, const char *name) 1272 { 1273 ch->ch_taskq = taskq_create(name, 1, IPL_NET, TASKQ_MPSAFE); 1274 if (ch->ch_taskq == NULL) 1275 return (-1); 1276 task_set(&ch->ch_task, hv_channel_intr, ch); 1277 return (0); 1278 } 1279 1280 void 1281 hv_channel_schedule(struct hv_channel *ch) 1282 { 1283 if (ch->ch_handler) { 1284 if (!cold && (ch->ch_flags & CHF_BATCHED)) { 1285 hv_channel_pause(ch); 1286 task_add(ch->ch_taskq, &ch->ch_task); 1287 } else 1288 ch->ch_handler(ch->ch_ctx); 1289 } 1290 } 1291 1292 static inline void 1293 hv_ring_put(struct hv_ring_data *wrd, uint8_t *data, uint32_t datalen) 1294 { 1295 int left = MIN(datalen, wrd->rd_dsize - wrd->rd_prod); 1296 1297 memcpy(&wrd->rd_ring->br_data[wrd->rd_prod], data, left); 1298 memcpy(&wrd->rd_ring->br_data[0], data + left, datalen - left); 1299 wrd->rd_prod += datalen; 1300 if (wrd->rd_prod >= wrd->rd_dsize) 1301 wrd->rd_prod -= wrd->rd_dsize; 1302 } 1303 1304 static inline void 1305 hv_ring_get(struct hv_ring_data *rrd, uint8_t *data, uint32_t datalen, 1306 int peek) 1307 { 1308 int left = MIN(datalen, rrd->rd_dsize - rrd->rd_cons); 1309 1310 memcpy(data, &rrd->rd_ring->br_data[rrd->rd_cons], left); 1311 memcpy(data + left, &rrd->rd_ring->br_data[0], datalen - left); 1312 if (!peek) { 1313 rrd->rd_cons += datalen; 1314 if (rrd->rd_cons >= rrd->rd_dsize) 1315 rrd->rd_cons -= rrd->rd_dsize; 1316 } 1317 } 1318 1319 static inline void 1320 hv_ring_avail(struct hv_ring_data *rd, uint32_t *towrite, uint32_t *toread) 1321 { 1322 uint32_t ridx = rd->rd_ring->br_rindex; 1323 uint32_t widx = rd->rd_ring->br_windex; 1324 uint32_t r, w; 1325 1326 if (widx >= ridx) 1327 w = rd->rd_dsize - (widx - ridx); 1328 else 1329 w = ridx - widx; 1330 r = rd->rd_dsize - w; 1331 if (towrite) 1332 *towrite = w; 1333 if (toread) 1334 *toread = r; 1335 } 1336 1337 int 1338 hv_ring_write(struct hv_ring_data *wrd, struct iovec *iov, int iov_cnt, 1339 int *needsig) 1340 { 1341 uint64_t indices = 0; 1342 uint32_t avail, oprod, datalen = sizeof(indices); 1343 int i; 1344 1345 for (i = 0; i < iov_cnt; i++) 1346 datalen += iov[i].iov_len; 1347 1348 KASSERT(datalen <= wrd->rd_dsize); 1349 1350 hv_ring_avail(wrd, &avail, NULL); 1351 if (avail <= datalen) { 1352 DPRINTF("%s: avail %u datalen %u\n", __func__, avail, datalen); 1353 return (EAGAIN); 1354 } 1355 1356 oprod = wrd->rd_prod; 1357 1358 for (i = 0; i < iov_cnt; i++) 1359 hv_ring_put(wrd, iov[i].iov_base, iov[i].iov_len); 1360 1361 indices = (uint64_t)oprod << 32; 1362 hv_ring_put(wrd, (uint8_t *)&indices, sizeof(indices)); 1363 1364 virtio_membar_sync(); 1365 wrd->rd_ring->br_windex = wrd->rd_prod; 1366 virtio_membar_sync(); 1367 1368 /* Signal when the ring transitions from being empty to non-empty */ 1369 if (wrd->rd_ring->br_imask == 0 && 1370 wrd->rd_ring->br_rindex == oprod) 1371 *needsig = 1; 1372 else 1373 *needsig = 0; 1374 1375 return (0); 1376 } 1377 1378 int 1379 hv_channel_send(struct hv_channel *ch, void *data, uint32_t datalen, 1380 uint64_t rid, int type, uint32_t flags) 1381 { 1382 struct hv_softc *sc = ch->ch_sc; 1383 struct vmbus_chanpkt cp; 1384 struct iovec iov[3]; 1385 uint32_t pktlen, pktlen_aligned; 1386 uint64_t zeropad = 0; 1387 int rv, needsig = 0; 1388 1389 pktlen = sizeof(cp) + datalen; 1390 pktlen_aligned = roundup(pktlen, sizeof(uint64_t)); 1391 1392 cp.cp_hdr.cph_type = type; 1393 cp.cp_hdr.cph_flags = flags; 1394 VMBUS_CHANPKT_SETLEN(cp.cp_hdr.cph_hlen, sizeof(cp)); 1395 VMBUS_CHANPKT_SETLEN(cp.cp_hdr.cph_tlen, pktlen_aligned); 1396 cp.cp_hdr.cph_tid = rid; 1397 1398 iov[0].iov_base = &cp; 1399 iov[0].iov_len = sizeof(cp); 1400 1401 iov[1].iov_base = data; 1402 iov[1].iov_len = datalen; 1403 1404 iov[2].iov_base = &zeropad; 1405 iov[2].iov_len = pktlen_aligned - pktlen; 1406 1407 mtx_enter(&ch->ch_wrd.rd_lock); 1408 rv = hv_ring_write(&ch->ch_wrd, iov, 3, &needsig); 1409 mtx_leave(&ch->ch_wrd.rd_lock); 1410 if (rv == 0 && needsig) 1411 hv_channel_setevent(sc, ch); 1412 1413 return (rv); 1414 } 1415 1416 int 1417 hv_channel_send_sgl(struct hv_channel *ch, struct vmbus_gpa *sgl, 1418 uint32_t nsge, void *data, uint32_t datalen, uint64_t rid) 1419 { 1420 struct hv_softc *sc = ch->ch_sc; 1421 struct vmbus_chanpkt_sglist cp; 1422 struct iovec iov[4]; 1423 uint32_t buflen, pktlen, pktlen_aligned; 1424 uint64_t zeropad = 0; 1425 int rv, needsig = 0; 1426 1427 buflen = sizeof(struct vmbus_gpa) * nsge; 1428 pktlen = sizeof(cp) + datalen + buflen; 1429 pktlen_aligned = roundup(pktlen, sizeof(uint64_t)); 1430 1431 cp.cp_hdr.cph_type = VMBUS_CHANPKT_TYPE_GPA; 1432 cp.cp_hdr.cph_flags = VMBUS_CHANPKT_FLAG_RC; 1433 VMBUS_CHANPKT_SETLEN(cp.cp_hdr.cph_hlen, sizeof(cp) + buflen); 1434 VMBUS_CHANPKT_SETLEN(cp.cp_hdr.cph_tlen, pktlen_aligned); 1435 cp.cp_hdr.cph_tid = rid; 1436 cp.cp_gpa_cnt = nsge; 1437 cp.cp_rsvd = 0; 1438 1439 iov[0].iov_base = &cp; 1440 iov[0].iov_len = sizeof(cp); 1441 1442 iov[1].iov_base = sgl; 1443 iov[1].iov_len = buflen; 1444 1445 iov[2].iov_base = data; 1446 iov[2].iov_len = datalen; 1447 1448 iov[3].iov_base = &zeropad; 1449 iov[3].iov_len = pktlen_aligned - pktlen; 1450 1451 mtx_enter(&ch->ch_wrd.rd_lock); 1452 rv = hv_ring_write(&ch->ch_wrd, iov, 4, &needsig); 1453 mtx_leave(&ch->ch_wrd.rd_lock); 1454 if (rv == 0 && needsig) 1455 hv_channel_setevent(sc, ch); 1456 1457 return (rv); 1458 } 1459 1460 int 1461 hv_channel_send_prpl(struct hv_channel *ch, struct vmbus_gpa_range *prpl, 1462 uint32_t nprp, void *data, uint32_t datalen, uint64_t rid) 1463 { 1464 struct hv_softc *sc = ch->ch_sc; 1465 struct vmbus_chanpkt_prplist cp; 1466 struct iovec iov[4]; 1467 uint32_t buflen, pktlen, pktlen_aligned; 1468 uint64_t zeropad = 0; 1469 int rv, needsig = 0; 1470 1471 buflen = sizeof(struct vmbus_gpa_range) * (nprp + 1); 1472 pktlen = sizeof(cp) + datalen + buflen; 1473 pktlen_aligned = roundup(pktlen, sizeof(uint64_t)); 1474 1475 cp.cp_hdr.cph_type = VMBUS_CHANPKT_TYPE_GPA; 1476 cp.cp_hdr.cph_flags = VMBUS_CHANPKT_FLAG_RC; 1477 VMBUS_CHANPKT_SETLEN(cp.cp_hdr.cph_hlen, sizeof(cp) + buflen); 1478 VMBUS_CHANPKT_SETLEN(cp.cp_hdr.cph_tlen, pktlen_aligned); 1479 cp.cp_hdr.cph_tid = rid; 1480 cp.cp_range_cnt = 1; 1481 cp.cp_rsvd = 0; 1482 1483 iov[0].iov_base = &cp; 1484 iov[0].iov_len = sizeof(cp); 1485 1486 iov[1].iov_base = prpl; 1487 iov[1].iov_len = buflen; 1488 1489 iov[2].iov_base = data; 1490 iov[2].iov_len = datalen; 1491 1492 iov[3].iov_base = &zeropad; 1493 iov[3].iov_len = pktlen_aligned - pktlen; 1494 1495 mtx_enter(&ch->ch_wrd.rd_lock); 1496 rv = hv_ring_write(&ch->ch_wrd, iov, 4, &needsig); 1497 mtx_leave(&ch->ch_wrd.rd_lock); 1498 if (rv == 0 && needsig) 1499 hv_channel_setevent(sc, ch); 1500 1501 return (rv); 1502 } 1503 1504 int 1505 hv_ring_peek(struct hv_ring_data *rrd, void *data, uint32_t datalen) 1506 { 1507 uint32_t avail; 1508 1509 KASSERT(datalen <= rrd->rd_dsize); 1510 1511 hv_ring_avail(rrd, NULL, &avail); 1512 if (avail < datalen) 1513 return (EAGAIN); 1514 1515 hv_ring_get(rrd, (uint8_t *)data, datalen, 1); 1516 return (0); 1517 } 1518 1519 int 1520 hv_ring_read(struct hv_ring_data *rrd, void *data, uint32_t datalen, 1521 uint32_t offset) 1522 { 1523 uint64_t indices; 1524 uint32_t avail; 1525 1526 KASSERT(datalen <= rrd->rd_dsize); 1527 1528 hv_ring_avail(rrd, NULL, &avail); 1529 if (avail < datalen) { 1530 DPRINTF("%s: avail %u datalen %u\n", __func__, avail, datalen); 1531 return (EAGAIN); 1532 } 1533 1534 if (offset) { 1535 rrd->rd_cons += offset; 1536 if (rrd->rd_cons >= rrd->rd_dsize) 1537 rrd->rd_cons -= rrd->rd_dsize; 1538 } 1539 1540 hv_ring_get(rrd, (uint8_t *)data, datalen, 0); 1541 hv_ring_get(rrd, (uint8_t *)&indices, sizeof(indices), 0); 1542 1543 virtio_membar_sync(); 1544 rrd->rd_ring->br_rindex = rrd->rd_cons; 1545 1546 return (0); 1547 } 1548 1549 int 1550 hv_channel_recv(struct hv_channel *ch, void *data, uint32_t datalen, 1551 uint32_t *rlen, uint64_t *rid, int raw) 1552 { 1553 struct vmbus_chanpkt_hdr cph; 1554 uint32_t offset, pktlen; 1555 int rv; 1556 1557 *rlen = 0; 1558 1559 mtx_enter(&ch->ch_rrd.rd_lock); 1560 1561 if ((rv = hv_ring_peek(&ch->ch_rrd, &cph, sizeof(cph))) != 0) { 1562 mtx_leave(&ch->ch_rrd.rd_lock); 1563 return (rv); 1564 } 1565 1566 offset = raw ? 0 : VMBUS_CHANPKT_GETLEN(cph.cph_hlen); 1567 pktlen = VMBUS_CHANPKT_GETLEN(cph.cph_tlen) - offset; 1568 if (pktlen > datalen) { 1569 mtx_leave(&ch->ch_rrd.rd_lock); 1570 printf("%s: pktlen %u datalen %u\n", __func__, pktlen, datalen); 1571 return (EINVAL); 1572 } 1573 1574 rv = hv_ring_read(&ch->ch_rrd, data, pktlen, offset); 1575 if (rv == 0) { 1576 *rlen = pktlen; 1577 *rid = cph.cph_tid; 1578 } 1579 1580 mtx_leave(&ch->ch_rrd.rd_lock); 1581 1582 return (rv); 1583 } 1584 1585 static inline void 1586 hv_ring_mask(struct hv_ring_data *rd) 1587 { 1588 virtio_membar_sync(); 1589 rd->rd_ring->br_imask = 1; 1590 virtio_membar_sync(); 1591 } 1592 1593 static inline void 1594 hv_ring_unmask(struct hv_ring_data *rd) 1595 { 1596 virtio_membar_sync(); 1597 rd->rd_ring->br_imask = 0; 1598 virtio_membar_sync(); 1599 } 1600 1601 void 1602 hv_channel_pause(struct hv_channel *ch) 1603 { 1604 hv_ring_mask(&ch->ch_rrd); 1605 } 1606 1607 uint 1608 hv_channel_unpause(struct hv_channel *ch) 1609 { 1610 uint32_t avail; 1611 1612 hv_ring_unmask(&ch->ch_rrd); 1613 hv_ring_avail(&ch->ch_rrd, NULL, &avail); 1614 1615 return (avail); 1616 } 1617 1618 uint 1619 hv_channel_ready(struct hv_channel *ch) 1620 { 1621 uint32_t avail; 1622 1623 hv_ring_avail(&ch->ch_rrd, NULL, &avail); 1624 1625 return (avail); 1626 } 1627 1628 /* How many PFNs can be referenced by the header */ 1629 #define HV_NPFNHDR ((VMBUS_MSG_DSIZE_MAX - \ 1630 sizeof(struct vmbus_chanmsg_gpadl_conn)) / sizeof(uint64_t)) 1631 1632 /* How many PFNs can be referenced by the body */ 1633 #define HV_NPFNBODY ((VMBUS_MSG_DSIZE_MAX - \ 1634 sizeof(struct vmbus_chanmsg_gpadl_subconn)) / sizeof(uint64_t)) 1635 1636 int 1637 hv_handle_alloc(struct hv_channel *ch, void *buffer, uint32_t buflen, 1638 uint32_t *handle) 1639 { 1640 struct hv_softc *sc = ch->ch_sc; 1641 struct vmbus_chanmsg_gpadl_conn *hdr; 1642 struct vmbus_chanmsg_gpadl_subconn *cmd; 1643 struct vmbus_chanmsg_gpadl_connresp rsp; 1644 struct hv_msg *msg; 1645 int i, j, last, left, rv; 1646 int bodylen = 0, ncmds = 0, pfn = 0; 1647 int waitflag = cold ? M_NOWAIT : M_WAITOK; 1648 uint64_t *frames; 1649 paddr_t pa; 1650 caddr_t body; 1651 /* Total number of pages to reference */ 1652 int total = atop(buflen); 1653 /* Number of pages that will fit the header */ 1654 int inhdr = MIN(total, HV_NPFNHDR); 1655 1656 KASSERT((buflen & (PAGE_SIZE - 1)) == 0); 1657 1658 if ((msg = malloc(sizeof(*msg), M_DEVBUF, M_ZERO | waitflag)) == NULL) 1659 return (ENOMEM); 1660 1661 /* Prepare array of frame addresses */ 1662 if ((frames = mallocarray(total, sizeof(*frames), M_DEVBUF, M_ZERO | 1663 waitflag)) == NULL) { 1664 free(msg, M_DEVBUF, sizeof(*msg)); 1665 return (ENOMEM); 1666 } 1667 for (i = 0; i < total; i++) { 1668 if (!pmap_extract(pmap_kernel(), (vaddr_t)buffer + 1669 PAGE_SIZE * i, &pa)) { 1670 free(msg, M_DEVBUF, sizeof(*msg)); 1671 free(frames, M_DEVBUF, total * sizeof(*frames)); 1672 return (EFAULT); 1673 } 1674 frames[i] = atop(pa); 1675 } 1676 1677 msg->msg_req.hc_dsize = sizeof(struct vmbus_chanmsg_gpadl_conn) + 1678 inhdr * sizeof(uint64_t); 1679 hdr = (struct vmbus_chanmsg_gpadl_conn *)msg->msg_req.hc_data; 1680 msg->msg_rsp = &rsp; 1681 msg->msg_rsplen = sizeof(rsp); 1682 if (waitflag == M_NOWAIT) 1683 msg->msg_flags = MSGF_NOSLEEP; 1684 1685 left = total - inhdr; 1686 1687 /* Allocate additional gpadl_body structures if required */ 1688 if (left > 0) { 1689 ncmds = MAX(1, left / HV_NPFNBODY + left % HV_NPFNBODY); 1690 bodylen = ncmds * VMBUS_MSG_DSIZE_MAX; 1691 body = malloc(bodylen, M_DEVBUF, M_ZERO | waitflag); 1692 if (body == NULL) { 1693 free(msg, M_DEVBUF, sizeof(*msg)); 1694 free(frames, M_DEVBUF, atop(buflen) * sizeof(*frames)); 1695 return (ENOMEM); 1696 } 1697 } 1698 1699 *handle = atomic_inc_int_nv(&sc->sc_handle); 1700 1701 hdr->chm_hdr.chm_type = VMBUS_CHANMSG_GPADL_CONN; 1702 hdr->chm_chanid = ch->ch_id; 1703 hdr->chm_gpadl = *handle; 1704 1705 /* Single range for a contiguous buffer */ 1706 hdr->chm_range_cnt = 1; 1707 hdr->chm_range_len = sizeof(struct vmbus_gpa_range) + total * 1708 sizeof(uint64_t); 1709 hdr->chm_range.gpa_ofs = 0; 1710 hdr->chm_range.gpa_len = buflen; 1711 1712 /* Fit as many pages as possible into the header */ 1713 for (i = 0; i < inhdr; i++) 1714 hdr->chm_range.gpa_page[i] = frames[pfn++]; 1715 1716 for (i = 0; i < ncmds; i++) { 1717 cmd = (struct vmbus_chanmsg_gpadl_subconn *)(body + 1718 VMBUS_MSG_DSIZE_MAX * i); 1719 cmd->chm_hdr.chm_type = VMBUS_CHANMSG_GPADL_SUBCONN; 1720 cmd->chm_gpadl = *handle; 1721 last = MIN(left, HV_NPFNBODY); 1722 for (j = 0; j < last; j++) 1723 cmd->chm_gpa_page[j] = frames[pfn++]; 1724 left -= last; 1725 } 1726 1727 rv = hv_start(sc, msg); 1728 if (rv != 0) { 1729 DPRINTF("%s: GPADL_CONN failed\n", sc->sc_dev.dv_xname); 1730 goto out; 1731 } 1732 for (i = 0; i < ncmds; i++) { 1733 int cmdlen = sizeof(*cmd); 1734 cmd = (struct vmbus_chanmsg_gpadl_subconn *)(body + 1735 VMBUS_MSG_DSIZE_MAX * i); 1736 /* Last element can be short */ 1737 if (i == ncmds - 1) 1738 cmdlen += last * sizeof(uint64_t); 1739 else 1740 cmdlen += HV_NPFNBODY * sizeof(uint64_t); 1741 rv = hv_cmd(sc, cmd, cmdlen, NULL, 0, waitflag | HCF_NOREPLY); 1742 if (rv != 0) { 1743 DPRINTF("%s: GPADL_SUBCONN (iteration %d/%d) failed " 1744 "with %d\n", sc->sc_dev.dv_xname, i, ncmds, rv); 1745 goto out; 1746 } 1747 } 1748 rv = hv_reply(sc, msg); 1749 if (rv != 0) 1750 DPRINTF("%s: GPADL allocation failed with %d\n", 1751 sc->sc_dev.dv_xname, rv); 1752 1753 out: 1754 free(msg, M_DEVBUF, sizeof(*msg)); 1755 free(frames, M_DEVBUF, total * sizeof(*frames)); 1756 if (bodylen > 0) 1757 free(body, M_DEVBUF, bodylen); 1758 if (rv != 0) 1759 return (rv); 1760 1761 KASSERT(*handle == rsp.chm_gpadl); 1762 1763 return (0); 1764 } 1765 1766 void 1767 hv_handle_free(struct hv_channel *ch, uint32_t handle) 1768 { 1769 struct hv_softc *sc = ch->ch_sc; 1770 struct vmbus_chanmsg_gpadl_disconn cmd; 1771 struct vmbus_chanmsg_gpadl_disconn rsp; 1772 int rv; 1773 1774 memset(&cmd, 0, sizeof(cmd)); 1775 cmd.chm_hdr.chm_type = VMBUS_CHANMSG_GPADL_DISCONN; 1776 cmd.chm_chanid = ch->ch_id; 1777 cmd.chm_gpadl = handle; 1778 1779 rv = hv_cmd(sc, &cmd, sizeof(cmd), &rsp, sizeof(rsp), cold ? 1780 HCF_NOSLEEP : 0); 1781 if (rv) 1782 DPRINTF("%s: GPADL_DISCONN failed with %d\n", 1783 sc->sc_dev.dv_xname, rv); 1784 } 1785 1786 static int 1787 hv_attach_print(void *aux, const char *name) 1788 { 1789 struct hv_attach_args *aa = aux; 1790 1791 if (name) 1792 printf("\"%s\" at %s", aa->aa_ident, name); 1793 1794 return (UNCONF); 1795 } 1796 1797 int 1798 hv_attach_devices(struct hv_softc *sc) 1799 { 1800 struct hv_dev *dv; 1801 struct hv_channel *ch; 1802 1803 SLIST_INIT(&sc->sc_devs); 1804 mtx_init(&sc->sc_devlck, IPL_NET); 1805 1806 TAILQ_FOREACH(ch, &sc->sc_channels, ch_entry) { 1807 if (ch->ch_state != HV_CHANSTATE_OFFERED) 1808 continue; 1809 if (!(ch->ch_flags & CHF_MONITOR)) 1810 continue; 1811 dv = malloc(sizeof(*dv), M_DEVBUF, M_ZERO | M_NOWAIT); 1812 if (dv == NULL) { 1813 printf("%s: failed to allocate device object\n", 1814 sc->sc_dev.dv_xname); 1815 return (-1); 1816 } 1817 dv->dv_aa.aa_parent = sc; 1818 dv->dv_aa.aa_type = &ch->ch_type; 1819 dv->dv_aa.aa_inst = &ch->ch_inst; 1820 dv->dv_aa.aa_ident = ch->ch_ident; 1821 dv->dv_aa.aa_chan = ch; 1822 dv->dv_aa.aa_dmat = sc->sc_dmat; 1823 mtx_enter(&sc->sc_devlck); 1824 SLIST_INSERT_HEAD(&sc->sc_devs, dv, dv_entry); 1825 mtx_leave(&sc->sc_devlck); 1826 config_found((struct device *)sc, &dv->dv_aa, hv_attach_print); 1827 } 1828 return (0); 1829 } 1830 1831 void 1832 hv_evcount_attach(struct hv_channel *ch, const char *name) 1833 { 1834 struct hv_softc *sc = ch->ch_sc; 1835 1836 evcount_attach(&ch->ch_evcnt, name, &sc->sc_idtvec); 1837 } 1838