Edit
IABSD.fr/src/sys/dev/pv/hypervic.c
jsg
- sys/dev/pv/hypervic.c
-
/*- * Copyright (c) 2009-2016 Microsoft Corp. * Copyright (c) 2012 NetApp Inc. * Copyright (c) 2012 Citrix Inc. * Copyright (c) 2016 Mike Belopuhov <mike@esdenera.com> * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice unmodified, this list of conditions, and the following * disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* * The OpenBSD port was done under funding by Esdenera Networks GmbH. */ #include <sys/param.h> /* Hyperv requires locked atomic operations */ #ifndef MULTIPROCESSOR #define _HYPERVMPATOMICS #define MULTIPROCESSOR #endif #include <sys/atomic.h> #ifdef _HYPERVMPATOMICS #undef MULTIPROCESSOR #undef _HYPERVMPATOMICS #endif #include <sys/systm.h> #include <sys/malloc.h> #include <sys/kernel.h> #include <sys/device.h> #include <sys/pool.h> #include <sys/task.h> #include <sys/sensors.h> #include <machine/bus.h> #include <net/if.h> #include <net/if_dl.h> #include <netinet/in.h> #include <netinet/if_ether.h> #include <dev/pv/pvvar.h> #include <dev/pv/hypervreg.h> #include <dev/pv/hypervvar.h> #include <dev/pv/hypervicreg.h> struct hv_ic_dev; #define NKVPPOOLS 4 #define MAXPOOLENTS 1023 struct kvp_entry { int kpe_index; uint32_t kpe_valtype; uint8_t kpe_key[HV_KVP_MAX_KEY_SIZE / 2]; uint8_t kpe_val[HV_KVP_MAX_VAL_SIZE / 2]; TAILQ_ENTRY(kvp_entry) kpe_entry; }; TAILQ_HEAD(kvp_list, kvp_entry); struct kvp_pool { struct kvp_list kvp_entries; struct mutex kvp_lock; u_int kvp_index; }; struct pool kvp_entry_pool; struct hv_kvp { struct kvp_pool kvp_pool[NKVPPOOLS]; }; int hv_heartbeat_attach(struct hv_ic_dev *); void hv_heartbeat(void *); int hv_kvp_attach(struct hv_ic_dev *); void hv_kvp(void *); int hv_kvop(void *, int, char *, char *, size_t); int hv_shutdown_attach(struct hv_ic_dev *); void hv_shutdown(void *); int hv_timesync_attach(struct hv_ic_dev *); void hv_timesync(void *); static struct hv_ic_dev { const char *dv_name; const struct hv_guid *dv_type; int (*dv_attach)(struct hv_ic_dev *); void (*dv_handler)(void *); struct hv_channel *dv_ch; uint8_t *dv_buf; void *dv_priv; } hv_ic_devs[] = { { "heartbeat", &hv_guid_heartbeat, hv_heartbeat_attach, hv_heartbeat }, { "kvp", &hv_guid_kvp, hv_kvp_attach, hv_kvp }, { "shutdown", &hv_guid_shutdown, hv_shutdown_attach, hv_shutdown }, { "timesync", &hv_guid_timesync, hv_timesync_attach, hv_timesync } }; static const struct { enum hv_kvp_pool poolidx; const char *poolname; size_t poolnamelen; } kvp_pools[] = { { HV_KVP_POOL_EXTERNAL, "External", sizeof("External") }, { HV_KVP_POOL_GUEST, "Guest", sizeof("Guest") }, { HV_KVP_POOL_AUTO, "Auto", sizeof("Auto") }, { HV_KVP_POOL_AUTO_EXTERNAL, "Guest/Parameters", sizeof("Guest/Parameters") } }; static const struct { int keyidx; const char *keyname; const char *value; } kvp_pool_auto[] = { { 0, "FullyQualifiedDomainName", hostname }, { 1, "IntegrationServicesVersion", "6.6.6" }, { 2, "NetworkAddressIPv4", "127.0.0.1" }, { 3, "NetworkAddressIPv6", "::1" }, { 4, "OSBuildNumber", osversion }, { 5, "OSName", ostype }, { 6, "OSMajorVersion", "6" }, /* free commit for mike */ { 7, "OSMinorVersion", &osrelease[2] }, { 8, "OSVersion", osrelease }, #ifdef __amd64__ /* As specified in SYSTEM_INFO.wProcessorArchitecture */ { 9, "ProcessorArchitecture", "9" } #else { 9, "ProcessorArchitecture", "0" } #endif }; void hv_attach_icdevs(struct hv_softc *sc) { struct hv_ic_dev *dv; struct hv_channel *ch; int i, header = 0; for (i = 0; i < nitems(hv_ic_devs); i++) { dv = &hv_ic_devs[i]; TAILQ_FOREACH(ch, &sc->sc_channels, ch_entry) { if (ch->ch_state != HV_CHANSTATE_OFFERED) continue; if (ch->ch_flags & CHF_MONITOR) continue; if (memcmp(dv->dv_type, &ch->ch_type, sizeof(ch->ch_type)) == 0) break; } if (ch == NULL) continue; dv->dv_ch = ch; /* * These services are not performance critical and * do not need batched reading. Furthermore, some * services such as KVP can only handle one message * from the host at a time. */ dv->dv_ch->ch_flags &= ~CHF_BATCHED; if (dv->dv_attach && dv->dv_attach(dv) != 0) continue; if (hv_channel_open(ch, VMBUS_IC_BUFRINGSIZE, NULL, 0, dv->dv_handler, dv)) { printf("%s: failed to open channel for %s\n", sc->sc_dev.dv_xname, dv->dv_name); continue; } evcount_attach(&ch->ch_evcnt, dv->dv_name, &sc->sc_idtvec); if (!header) { printf("%s: %s", sc->sc_dev.dv_xname, dv->dv_name); header = 1; } else printf(", %s", dv->dv_name); } if (header) printf("\n"); } static inline void hv_ic_negotiate(struct vmbus_icmsg_hdr *hdr, uint32_t *rlen, uint32_t fwver, uint32_t msgver) { struct vmbus_icmsg_negotiate *msg; uint16_t propmin, propmaj, chosenmaj, chosenmin; int i; msg = (struct vmbus_icmsg_negotiate *)hdr; chosenmaj = chosenmin = 0; for (i = 0; i < msg->ic_fwver_cnt; i++) { propmaj = VMBUS_ICVER_MAJOR(msg->ic_ver[i]); propmin = VMBUS_ICVER_MINOR(msg->ic_ver[i]); if (propmaj > chosenmaj && propmaj <= VMBUS_ICVER_MAJOR(fwver) && propmin >= chosenmin && propmin <= VMBUS_ICVER_MINOR(fwver)) { chosenmaj = propmaj; chosenmin = propmin; } } fwver = VMBUS_IC_VERSION(chosenmaj, chosenmin); chosenmaj = chosenmin = 0; for (; i < msg->ic_fwver_cnt + msg->ic_msgver_cnt; i++) { propmaj = VMBUS_ICVER_MAJOR(msg->ic_ver[i]); propmin = VMBUS_ICVER_MINOR(msg->ic_ver[i]); if (propmaj > chosenmaj && propmaj <= VMBUS_ICVER_MAJOR(msgver) && propmin >= chosenmin && propmin <= VMBUS_ICVER_MINOR(msgver)) { chosenmaj = propmaj; chosenmin = propmin; } } msgver = VMBUS_IC_VERSION(chosenmaj, chosenmin); msg->ic_fwver_cnt = 1; msg->ic_ver[0] = fwver; msg->ic_msgver_cnt = 1; msg->ic_ver[1] = msgver; hdr->ic_dsize = sizeof(*msg) + 2 * sizeof(uint32_t) - sizeof(struct vmbus_icmsg_hdr); if (*rlen < sizeof(*msg) + 2 * sizeof(uint32_t)) *rlen = sizeof(*msg) + 2 * sizeof(uint32_t); } int hv_heartbeat_attach(struct hv_ic_dev *dv) { struct hv_channel *ch = dv->dv_ch; struct hv_softc *sc = ch->ch_sc; dv->dv_buf = malloc(PAGE_SIZE, M_DEVBUF, M_ZERO | (cold ? M_NOWAIT : M_WAITOK)); if (dv->dv_buf == NULL) { printf("%s: failed to allocate receive buffer\n", sc->sc_dev.dv_xname); return (-1); } return (0); } void hv_heartbeat(void *arg) { struct hv_ic_dev *dv = arg; struct hv_channel *ch = dv->dv_ch; struct hv_softc *sc = ch->ch_sc; struct vmbus_icmsg_hdr *hdr; struct vmbus_icmsg_heartbeat *msg; uint64_t rid; uint32_t rlen; int rv; rv = hv_channel_recv(ch, dv->dv_buf, PAGE_SIZE, &rlen, &rid, 0); if (rv || rlen == 0) { if (rv != EAGAIN) DPRINTF("%s: heartbeat rv=%d rlen=%u\n", sc->sc_dev.dv_xname, rv, rlen); return; } if (rlen < sizeof(struct vmbus_icmsg_hdr)) { DPRINTF("%s: heartbeat short read rlen=%u\n", sc->sc_dev.dv_xname, rlen); return; } hdr = (struct vmbus_icmsg_hdr *)dv->dv_buf; switch (hdr->ic_type) { case VMBUS_ICMSG_TYPE_NEGOTIATE: hv_ic_negotiate(hdr, &rlen, VMBUS_IC_VERSION(3, 0), VMBUS_IC_VERSION(3, 0)); break; case VMBUS_ICMSG_TYPE_HEARTBEAT: msg = (struct vmbus_icmsg_heartbeat *)hdr; msg->ic_seq += 1; break; default: printf("%s: unhandled heartbeat message type %u\n", sc->sc_dev.dv_xname, hdr->ic_type); return; } hdr->ic_flags = VMBUS_ICMSG_FLAG_TRANSACTION | VMBUS_ICMSG_FLAG_RESPONSE; hv_channel_send(ch, dv->dv_buf, rlen, rid, VMBUS_CHANPKT_TYPE_INBAND, 0); } static void hv_shutdown_task(void *arg) { struct hv_softc *sc = arg; pvbus_shutdown(&sc->sc_dev); } int hv_shutdown_attach(struct hv_ic_dev *dv) { struct hv_channel *ch = dv->dv_ch; struct hv_softc *sc = ch->ch_sc; dv->dv_buf = malloc(PAGE_SIZE, M_DEVBUF, M_ZERO | (cold ? M_NOWAIT : M_WAITOK)); if (dv->dv_buf == NULL) { printf("%s: failed to allocate receive buffer\n", sc->sc_dev.dv_xname); return (-1); } task_set(&sc->sc_sdtask, hv_shutdown_task, sc); return (0); } void hv_shutdown(void *arg) { struct hv_ic_dev *dv = arg; struct hv_channel *ch = dv->dv_ch; struct hv_softc *sc = ch->ch_sc; struct vmbus_icmsg_hdr *hdr; struct vmbus_icmsg_shutdown *msg; uint64_t rid; uint32_t rlen; int rv, shutdown = 0; rv = hv_channel_recv(ch, dv->dv_buf, PAGE_SIZE, &rlen, &rid, 0); if (rv || rlen == 0) { if (rv != EAGAIN) DPRINTF("%s: shutdown rv=%d rlen=%u\n", sc->sc_dev.dv_xname, rv, rlen); return; } if (rlen < sizeof(struct vmbus_icmsg_hdr)) { DPRINTF("%s: shutdown short read rlen=%u\n", sc->sc_dev.dv_xname, rlen); return; } hdr = (struct vmbus_icmsg_hdr *)dv->dv_buf; switch (hdr->ic_type) { case VMBUS_ICMSG_TYPE_NEGOTIATE: hv_ic_negotiate(hdr, &rlen, VMBUS_IC_VERSION(3, 0), VMBUS_IC_VERSION(3, 0)); break; case VMBUS_ICMSG_TYPE_SHUTDOWN: msg = (struct vmbus_icmsg_shutdown *)hdr; if (msg->ic_haltflags == 0 || msg->ic_haltflags == 1) { shutdown = 1; hdr->ic_status = VMBUS_ICMSG_STATUS_OK; } else hdr->ic_status = VMBUS_ICMSG_STATUS_FAIL; break; default: printf("%s: unhandled shutdown message type %u\n", sc->sc_dev.dv_xname, hdr->ic_type); return; } hdr->ic_flags = VMBUS_ICMSG_FLAG_TRANSACTION | VMBUS_ICMSG_FLAG_RESPONSE; hv_channel_send(ch, dv->dv_buf, rlen, rid, VMBUS_CHANPKT_TYPE_INBAND, 0); if (shutdown) task_add(systq, &sc->sc_sdtask); } int hv_timesync_attach(struct hv_ic_dev *dv) { struct hv_channel *ch = dv->dv_ch; struct hv_softc *sc = ch->ch_sc; dv->dv_buf = malloc(PAGE_SIZE, M_DEVBUF, M_ZERO | (cold ? M_NOWAIT : M_WAITOK)); if (dv->dv_buf == NULL) { printf("%s: failed to allocate receive buffer\n", sc->sc_dev.dv_xname); return (-1); } strlcpy(sc->sc_sensordev.xname, sc->sc_dev.dv_xname, sizeof(sc->sc_sensordev.xname)); sc->sc_sensor.type = SENSOR_TIMEDELTA; sc->sc_sensor.status = SENSOR_S_UNKNOWN; sensor_attach(&sc->sc_sensordev, &sc->sc_sensor); sensordev_install(&sc->sc_sensordev); return (0); } void hv_timesync(void *arg) { struct hv_ic_dev *dv = arg; struct hv_channel *ch = dv->dv_ch; struct hv_softc *sc = ch->ch_sc; struct vmbus_icmsg_hdr *hdr; struct vmbus_icmsg_timesync *msg; struct timespec guest, host, diff; uint64_t tns; uint64_t rid; uint32_t rlen; int rv; rv = hv_channel_recv(ch, dv->dv_buf, PAGE_SIZE, &rlen, &rid, 0); if (rv || rlen == 0) { if (rv != EAGAIN) DPRINTF("%s: timesync rv=%d rlen=%u\n", sc->sc_dev.dv_xname, rv, rlen); return; } if (rlen < sizeof(struct vmbus_icmsg_hdr)) { DPRINTF("%s: timesync short read rlen=%u\n", sc->sc_dev.dv_xname, rlen); return; } hdr = (struct vmbus_icmsg_hdr *)dv->dv_buf; switch (hdr->ic_type) { case VMBUS_ICMSG_TYPE_NEGOTIATE: hv_ic_negotiate(hdr, &rlen, VMBUS_IC_VERSION(3, 0), VMBUS_IC_VERSION(3, 0)); break; case VMBUS_ICMSG_TYPE_TIMESYNC: msg = (struct vmbus_icmsg_timesync *)hdr; if (msg->ic_tsflags == VMBUS_ICMSG_TS_FLAG_SAMPLE) { microtime(&sc->sc_sensor.tv); nanotime(&guest); tns = (msg->ic_hvtime - 116444736000000000LL) * 100; host.tv_sec = tns / 1000000000LL; host.tv_nsec = tns % 1000000000LL; timespecsub(&guest, &host, &diff); sc->sc_sensor.value = (int64_t)diff.tv_sec * 1000000000LL + diff.tv_nsec; sc->sc_sensor.status = SENSOR_S_OK; } break; default: printf("%s: unhandled timesync message type %u\n", sc->sc_dev.dv_xname, hdr->ic_type); return; } hdr->ic_flags = VMBUS_ICMSG_FLAG_TRANSACTION | VMBUS_ICMSG_FLAG_RESPONSE; hv_channel_send(ch, dv->dv_buf, rlen, rid, VMBUS_CHANPKT_TYPE_INBAND, 0); } static inline int copyout_utf16le(void *dst, const void *src, size_t dlen, size_t slen) { const uint8_t *sp = src; uint8_t *dp = dst; int i, j; KASSERT(dlen >= slen * 2); for (i = j = 0; i < slen; i++, j += 2) { dp[j] = sp[i]; dp[j + 1] = '\0'; } return (j); } static inline int copyin_utf16le(void *dst, const void *src, size_t dlen, size_t slen) { const uint8_t *sp = src; uint8_t *dp = dst; int i, j; KASSERT(dlen >= slen / 2); for (i = j = 0; i < slen; i += 2, j++) dp[j] = sp[i]; return (j); } static inline int keycmp_utf16le(const uint8_t *key, const uint8_t *ukey, size_t ukeylen) { int i, j; for (i = j = 0; i < ukeylen; i += 2, j++) { if (key[j] != ukey[i]) return (key[j] > ukey[i] ? key[j] - ukey[i] : ukey[i] - key[j]); } return (0); } static void kvp_pool_init(struct kvp_pool *kvpl) { TAILQ_INIT(&kvpl->kvp_entries); mtx_init(&kvpl->kvp_lock, IPL_NET); kvpl->kvp_index = 0; } static int kvp_pool_insert(struct kvp_pool *kvpl, const char *key, const char *val, uint32_t vallen, uint32_t valtype) { struct kvp_entry *kpe; int keylen = strlen(key); if (keylen > HV_KVP_MAX_KEY_SIZE / 2) return (ERANGE); mtx_enter(&kvpl->kvp_lock); TAILQ_FOREACH(kpe, &kvpl->kvp_entries, kpe_entry) { if (strcmp(kpe->kpe_key, key) == 0) { mtx_leave(&kvpl->kvp_lock); return (EEXIST); } } kpe = pool_get(&kvp_entry_pool, PR_ZERO | PR_NOWAIT); if (kpe == NULL) { mtx_leave(&kvpl->kvp_lock); return (ENOMEM); } strlcpy(kpe->kpe_key, key, HV_KVP_MAX_KEY_SIZE / 2); if ((kpe->kpe_valtype = valtype) == HV_KVP_REG_SZ) strlcpy(kpe->kpe_val, val, HV_KVP_MAX_KEY_SIZE / 2); else memcpy(kpe->kpe_val, val, vallen); kpe->kpe_index = kvpl->kvp_index++ & MAXPOOLENTS; TAILQ_INSERT_TAIL(&kvpl->kvp_entries, kpe, kpe_entry); mtx_leave(&kvpl->kvp_lock); return (0); } static int kvp_pool_update(struct kvp_pool *kvpl, const char *key, const char *val, uint32_t vallen, uint32_t valtype) { struct kvp_entry *kpe; int keylen = strlen(key); if (keylen > HV_KVP_MAX_KEY_SIZE / 2) return (ERANGE); mtx_enter(&kvpl->kvp_lock); TAILQ_FOREACH(kpe, &kvpl->kvp_entries, kpe_entry) { if (strcmp(kpe->kpe_key, key) == 0) break; } if (kpe == NULL) { mtx_leave(&kvpl->kvp_lock); return (ENOENT); } if ((kpe->kpe_valtype = valtype) == HV_KVP_REG_SZ) strlcpy(kpe->kpe_val, val, HV_KVP_MAX_KEY_SIZE / 2); else memcpy(kpe->kpe_val, val, vallen); mtx_leave(&kvpl->kvp_lock); return (0); } static int kvp_pool_import(struct kvp_pool *kvpl, const char *key, uint32_t keylen, const char *val, uint32_t vallen, uint32_t valtype) { struct kvp_entry *kpe; if (keylen > HV_KVP_MAX_KEY_SIZE || vallen > HV_KVP_MAX_VAL_SIZE) return (ERANGE); mtx_enter(&kvpl->kvp_lock); TAILQ_FOREACH(kpe, &kvpl->kvp_entries, kpe_entry) { if (keycmp_utf16le(kpe->kpe_key, key, keylen) == 0) break; } if (kpe == NULL) { kpe = pool_get(&kvp_entry_pool, PR_ZERO | PR_NOWAIT); if (kpe == NULL) { mtx_leave(&kvpl->kvp_lock); return (ENOMEM); } copyin_utf16le(kpe->kpe_key, key, HV_KVP_MAX_KEY_SIZE / 2, keylen); kpe->kpe_index = kvpl->kvp_index++ & MAXPOOLENTS; TAILQ_INSERT_TAIL(&kvpl->kvp_entries, kpe, kpe_entry); } copyin_utf16le(kpe->kpe_val, val, HV_KVP_MAX_VAL_SIZE / 2, vallen); kpe->kpe_valtype = valtype; mtx_leave(&kvpl->kvp_lock); return (0); } static int kvp_pool_export(struct kvp_pool *kvpl, uint32_t index, char *key, uint32_t *keylen, char *val, uint32_t *vallen, uint32_t *valtype) { struct kvp_entry *kpe; mtx_enter(&kvpl->kvp_lock); TAILQ_FOREACH(kpe, &kvpl->kvp_entries, kpe_entry) { if (kpe->kpe_index == index) break; } if (kpe == NULL) { mtx_leave(&kvpl->kvp_lock); return (ENOENT); } *keylen = copyout_utf16le(key, kpe->kpe_key, HV_KVP_MAX_KEY_SIZE, strlen(kpe->kpe_key) + 1); *vallen = copyout_utf16le(val, kpe->kpe_val, HV_KVP_MAX_VAL_SIZE, strlen(kpe->kpe_val) + 1); *valtype = kpe->kpe_valtype; mtx_leave(&kvpl->kvp_lock); return (0); } static int kvp_pool_remove(struct kvp_pool *kvpl, const char *key, uint32_t keylen) { struct kvp_entry *kpe; mtx_enter(&kvpl->kvp_lock); TAILQ_FOREACH(kpe, &kvpl->kvp_entries, kpe_entry) { if (keycmp_utf16le(kpe->kpe_key, key, keylen) == 0) break; } if (kpe == NULL) { mtx_leave(&kvpl->kvp_lock); return (ENOENT); } TAILQ_REMOVE(&kvpl->kvp_entries, kpe, kpe_entry); mtx_leave(&kvpl->kvp_lock); pool_put(&kvp_entry_pool, kpe); return (0); } static int kvp_pool_extract(struct kvp_pool *kvpl, const char *key, char *val, uint32_t vallen) { struct kvp_entry *kpe; if (vallen < HV_KVP_MAX_VAL_SIZE / 2) return (ERANGE); mtx_enter(&kvpl->kvp_lock); TAILQ_FOREACH(kpe, &kvpl->kvp_entries, kpe_entry) { if (strcmp(kpe->kpe_key, key) == 0) break; } if (kpe == NULL) { mtx_leave(&kvpl->kvp_lock); return (ENOENT); } switch (kpe->kpe_valtype) { case HV_KVP_REG_SZ: strlcpy(val, kpe->kpe_val, HV_KVP_MAX_VAL_SIZE / 2); break; case HV_KVP_REG_U32: snprintf(val, HV_KVP_MAX_VAL_SIZE / 2, "%u", *(uint32_t *)kpe->kpe_val); break; case HV_KVP_REG_U64: snprintf(val, HV_KVP_MAX_VAL_SIZE / 2, "%llu", *(uint64_t *)kpe->kpe_val); break; } mtx_leave(&kvpl->kvp_lock); return (0); } static int kvp_pool_keys(struct kvp_pool *kvpl, int next, char *key, size_t *keylen) { struct kvp_entry *kpe; int iter = 0; mtx_enter(&kvpl->kvp_lock); TAILQ_FOREACH(kpe, &kvpl->kvp_entries, kpe_entry) { if (iter++ < next) continue; *keylen = strlen(kpe->kpe_key) + 1; strlcpy(key, kpe->kpe_key, *keylen); mtx_leave(&kvpl->kvp_lock); return (0); } mtx_leave(&kvpl->kvp_lock); return (-1); } int hv_kvp_attach(struct hv_ic_dev *dv) { struct hv_channel *ch = dv->dv_ch; struct hv_softc *sc = ch->ch_sc; struct hv_kvp *kvp; int i; dv->dv_buf = malloc(2 * PAGE_SIZE, M_DEVBUF, M_ZERO | (cold ? M_NOWAIT : M_WAITOK)); if (dv->dv_buf == NULL) { printf("%s: failed to allocate receive buffer\n", sc->sc_dev.dv_xname); return (-1); } dv->dv_priv = malloc(sizeof(struct hv_kvp), M_DEVBUF, M_ZERO | (cold ? M_NOWAIT : M_WAITOK)); if (dv->dv_priv == NULL) { free(dv->dv_buf, M_DEVBUF, 2 * PAGE_SIZE); printf("%s: failed to allocate KVP private data\n", sc->sc_dev.dv_xname); return (-1); } kvp = dv->dv_priv; pool_init(&kvp_entry_pool, sizeof(struct kvp_entry), 0, IPL_NET, 0, "hvkvpl", NULL); for (i = 0; i < NKVPPOOLS; i++) kvp_pool_init(&kvp->kvp_pool[i]); /* Initialize 'Auto' pool */ for (i = 0; i < nitems(kvp_pool_auto); i++) { if (kvp_pool_insert(&kvp->kvp_pool[HV_KVP_POOL_AUTO], kvp_pool_auto[i].keyname, kvp_pool_auto[i].value, strlen(kvp_pool_auto[i].value), HV_KVP_REG_SZ)) DPRINTF("%s: failed to insert into 'Auto' pool\n", sc->sc_dev.dv_xname); } sc->sc_pvbus->hv_kvop = hv_kvop; sc->sc_pvbus->hv_arg = dv; return (0); } static int nibble(int ch) { if (ch >= '0' && ch <= '9') return (ch - '0'); if (ch >= 'A' && ch <= 'F') return (10 + ch - 'A'); if (ch >= 'a' && ch <= 'f') return (10 + ch - 'a'); return (-1); } static int kvp_get_ip_info(struct hv_kvp *kvp, const uint8_t *mac, uint8_t *family, uint8_t *addr, uint8_t *netmask, size_t addrlen) { struct ifnet *ifp; struct ifaddr *ifa, *ifa6, *ifa6ll; struct sockaddr_in *sin; struct sockaddr_in6 *sin6, sa6; uint8_t enaddr[ETHER_ADDR_LEN]; uint8_t ipaddr[INET6_ADDRSTRLEN]; int i, j, lo, hi, s, af; /* Convert from the UTF-16LE string format to binary */ for (i = 0, j = 0; j < ETHER_ADDR_LEN; i += 6) { if ((hi = nibble(mac[i])) == -1 || (lo = nibble(mac[i+2])) == -1) return (-1); enaddr[j++] = hi << 4 | lo; } switch (*family) { case ADDR_FAMILY_NONE: af = AF_UNSPEC; break; case ADDR_FAMILY_IPV4: af = AF_INET; break; case ADDR_FAMILY_IPV6: af = AF_INET6; break; default: return (-1); } KERNEL_LOCK(); s = splnet(); TAILQ_FOREACH(ifp, &ifnetlist, if_list) { if (!memcmp(LLADDR(ifp->if_sadl), enaddr, ETHER_ADDR_LEN)) break; } if (ifp == NULL) { splx(s); KERNEL_UNLOCK(); return (-1); } ifa6 = ifa6ll = NULL; /* Try to find a best matching address, preferring IPv4 */ TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_list) { /* * First IPv4 address is always a best match unless * we were asked for an IPv6 address. */ if ((af == AF_INET || af == AF_UNSPEC) && (ifa->ifa_addr->sa_family == AF_INET)) { af = AF_INET; goto found; } if ((af == AF_INET6 || af == AF_UNSPEC) && (ifa->ifa_addr->sa_family == AF_INET6)) { if (!IN6_IS_ADDR_LINKLOCAL( &satosin6(ifa->ifa_addr)->sin6_addr)) { /* Done if we're looking for an IPv6 address */ if (af == AF_INET6) goto found; /* Stick to the first one */ if (ifa6 == NULL) ifa6 = ifa; } else /* Pick the last one */ ifa6ll = ifa; } } /* If we haven't found any IPv4 or IPv6 direct matches... */ if (ifa == NULL) { /* ... try the last global IPv6 address... */ if (ifa6 != NULL) ifa = ifa6; /* ... or the last link-local... */ else if (ifa6ll != NULL) ifa = ifa6ll; else { splx(s); KERNEL_UNLOCK(); return (-1); } } found: switch (af) { case AF_INET: sin = satosin(ifa->ifa_addr); inet_ntop(AF_INET, &sin->sin_addr, ipaddr, sizeof(ipaddr)); copyout_utf16le(addr, ipaddr, addrlen, INET_ADDRSTRLEN); sin = satosin(ifa->ifa_netmask); inet_ntop(AF_INET, &sin->sin_addr, ipaddr, sizeof(ipaddr)); copyout_utf16le(netmask, ipaddr, addrlen, INET_ADDRSTRLEN); *family = ADDR_FAMILY_IPV4; break; case AF_UNSPEC: case AF_INET6: sin6 = satosin6(ifa->ifa_addr); if (IN6_IS_SCOPE_EMBED(&sin6->sin6_addr)) { sa6 = *satosin6(ifa->ifa_addr); sa6.sin6_addr.s6_addr16[1] = 0; sin6 = &sa6; } inet_ntop(AF_INET6, &sin6->sin6_addr, ipaddr, sizeof(ipaddr)); copyout_utf16le(addr, ipaddr, addrlen, INET6_ADDRSTRLEN); sin6 = satosin6(ifa->ifa_netmask); inet_ntop(AF_INET6, &sin6->sin6_addr, ipaddr, sizeof(ipaddr)); copyout_utf16le(netmask, ipaddr, addrlen, INET6_ADDRSTRLEN); *family = ADDR_FAMILY_IPV6; break; } splx(s); KERNEL_UNLOCK(); return (0); } static void hv_kvp_process(struct hv_kvp *kvp, struct vmbus_icmsg_kvp *msg) { union hv_kvp_hdr *kvh = &msg->ic_kvh; union hv_kvp_msg *kvm = &msg->ic_kvm; switch (kvh->kvh_op) { case HV_KVP_OP_SET: if (kvh->kvh_pool == HV_KVP_POOL_AUTO_EXTERNAL && kvp_pool_import(&kvp->kvp_pool[HV_KVP_POOL_AUTO_EXTERNAL], kvm->kvm_val.kvm_key, kvm->kvm_val.kvm_keylen, kvm->kvm_val.kvm_val, kvm->kvm_val.kvm_vallen, kvm->kvm_val.kvm_valtype)) { DPRINTF("%s: failed to import into 'Guest/Parameters'" " pool\n", __func__); kvh->kvh_err = HV_KVP_S_CONT; } else if (kvh->kvh_pool == HV_KVP_POOL_EXTERNAL && kvp_pool_import(&kvp->kvp_pool[HV_KVP_POOL_EXTERNAL], kvm->kvm_val.kvm_key, kvm->kvm_val.kvm_keylen, kvm->kvm_val.kvm_val, kvm->kvm_val.kvm_vallen, kvm->kvm_val.kvm_valtype)) { DPRINTF("%s: failed to import into 'External' pool\n", __func__); kvh->kvh_err = HV_KVP_S_CONT; } else if (kvh->kvh_pool != HV_KVP_POOL_AUTO_EXTERNAL && kvh->kvh_pool != HV_KVP_POOL_EXTERNAL) { kvh->kvh_err = HV_KVP_S_CONT; } else kvh->kvh_err = HV_KVP_S_OK; break; case HV_KVP_OP_DELETE: if (kvh->kvh_pool != HV_KVP_POOL_EXTERNAL || kvp_pool_remove(&kvp->kvp_pool[HV_KVP_POOL_EXTERNAL], kvm->kvm_del.kvm_key, kvm->kvm_del.kvm_keylen)) { DPRINTF("%s: failed to remove from 'External' pool\n", __func__); kvh->kvh_err = HV_KVP_S_CONT; } else kvh->kvh_err = HV_KVP_S_OK; break; case HV_KVP_OP_ENUMERATE: if (kvh->kvh_pool == HV_KVP_POOL_AUTO && kvp_pool_export(&kvp->kvp_pool[HV_KVP_POOL_AUTO], kvm->kvm_enum.kvm_index, kvm->kvm_enum.kvm_key, &kvm->kvm_enum.kvm_keylen, kvm->kvm_enum.kvm_val, &kvm->kvm_enum.kvm_vallen, &kvm->kvm_enum.kvm_valtype)) kvh->kvh_err = HV_KVP_S_CONT; else if (kvh->kvh_pool == HV_KVP_POOL_GUEST && kvp_pool_export(&kvp->kvp_pool[HV_KVP_POOL_GUEST], kvm->kvm_enum.kvm_index, kvm->kvm_enum.kvm_key, &kvm->kvm_enum.kvm_keylen, kvm->kvm_enum.kvm_val, &kvm->kvm_enum.kvm_vallen, &kvm->kvm_enum.kvm_valtype)) kvh->kvh_err = HV_KVP_S_CONT; else kvh->kvh_err = HV_KVP_S_OK; break; case HV_KVP_OP_GET_IP_INFO: if (VMBUS_ICVER_MAJOR(msg->ic_hdr.ic_msgver) <= 4) { struct vmbus_icmsg_kvp_addr *amsg; struct hv_kvp_msg_addr *kva; amsg = (struct vmbus_icmsg_kvp_addr *)msg; kva = &amsg->ic_kvm; if (kvp_get_ip_info(kvp, kva->kvm_mac, &kva->kvm_family, kva->kvm_addr, kva->kvm_netmask, sizeof(kva->kvm_addr))) kvh->kvh_err = HV_KVP_S_CONT; else kvh->kvh_err = HV_KVP_S_OK; } else { DPRINTF("KVP GET_IP_INFO fw %u.%u msg %u.%u dsize=%u\n", VMBUS_ICVER_MAJOR(msg->ic_hdr.ic_fwver), VMBUS_ICVER_MINOR(msg->ic_hdr.ic_fwver), VMBUS_ICVER_MAJOR(msg->ic_hdr.ic_msgver), VMBUS_ICVER_MINOR(msg->ic_hdr.ic_msgver), msg->ic_hdr.ic_dsize); kvh->kvh_err = HV_KVP_S_CONT; } break; default: DPRINTF("KVP message op %u pool %u\n", kvh->kvh_op, kvh->kvh_pool); kvh->kvh_err = HV_KVP_S_CONT; } } void hv_kvp(void *arg) { struct hv_ic_dev *dv = arg; struct hv_channel *ch = dv->dv_ch; struct hv_softc *sc = ch->ch_sc; struct hv_kvp *kvp = dv->dv_priv; struct vmbus_icmsg_hdr *hdr; uint64_t rid; uint32_t fwver, msgver, rlen; int rv; for (;;) { rv = hv_channel_recv(ch, dv->dv_buf, 2 * PAGE_SIZE, &rlen, &rid, 0); if (rv || rlen == 0) { if (rv != EAGAIN) DPRINTF("%s: kvp rv=%d rlen=%u\n", sc->sc_dev.dv_xname, rv, rlen); return; } if (rlen < sizeof(struct vmbus_icmsg_hdr)) { DPRINTF("%s: kvp short read rlen=%u\n", sc->sc_dev.dv_xname, rlen); return; } hdr = (struct vmbus_icmsg_hdr *)dv->dv_buf; switch (hdr->ic_type) { case VMBUS_ICMSG_TYPE_NEGOTIATE: switch (sc->sc_proto) { case VMBUS_VERSION_WS2008: fwver = VMBUS_IC_VERSION(1, 0); msgver = VMBUS_IC_VERSION(1, 0); break; case VMBUS_VERSION_WIN7: fwver = VMBUS_IC_VERSION(3, 0); msgver = VMBUS_IC_VERSION(3, 0); break; default: fwver = VMBUS_IC_VERSION(3, 0); msgver = VMBUS_IC_VERSION(4, 0); } hv_ic_negotiate(hdr, &rlen, fwver, msgver); break; case VMBUS_ICMSG_TYPE_KVP: if (hdr->ic_dsize >= sizeof(union hv_kvp_hdr)) hv_kvp_process(kvp, (struct vmbus_icmsg_kvp *)hdr); else printf("%s: message too short: %u\n", sc->sc_dev.dv_xname, hdr->ic_dsize); break; default: printf("%s: unhandled kvp message type %u\n", sc->sc_dev.dv_xname, hdr->ic_type); continue; } hdr->ic_flags = VMBUS_ICMSG_FLAG_TRANSACTION | VMBUS_ICMSG_FLAG_RESPONSE; hv_channel_send(ch, dv->dv_buf, rlen, rid, VMBUS_CHANPKT_TYPE_INBAND, 0); } } static int kvp_poolname(char **key) { char *p; int i, rv = -1; if ((p = strrchr(*key, '/')) == NULL) return (rv); *p = '\0'; for (i = 0; i < nitems(kvp_pools); i++) { if (strncasecmp(*key, kvp_pools[i].poolname, kvp_pools[i].poolnamelen) == 0) { rv = kvp_pools[i].poolidx; break; } } if (rv >= 0) *key = ++p; return (rv); } int hv_kvop(void *arg, int op, char *key, char *val, size_t vallen) { struct hv_ic_dev *dv = arg; struct hv_kvp *kvp = dv->dv_priv; struct kvp_pool *kvpl; int next, pool, error = 0; char *vp = val; size_t keylen; pool = kvp_poolname(&key); if (pool == -1) return (EINVAL); kvpl = &kvp->kvp_pool[pool]; if (strlen(key) == 0) { for (next = 0; next < MAXPOOLENTS; next++) { if (val + vallen < vp + HV_KVP_MAX_KEY_SIZE / 2) return (ERANGE); if (kvp_pool_keys(kvpl, next, vp, &keylen)) goto out; if (strlcat(val, "\n", vallen) >= vallen) return (ERANGE); vp += keylen; } out: if (vp > val) *(vp - 1) = '\0'; return (0); } if (op == PVBUS_KVWRITE) { if (pool == HV_KVP_POOL_AUTO) error = kvp_pool_update(kvpl, key, val, vallen, HV_KVP_REG_SZ); else if (pool == HV_KVP_POOL_GUEST) error = kvp_pool_insert(kvpl, key, val, vallen, HV_KVP_REG_SZ); else error = EINVAL; } else error = kvp_pool_extract(kvpl, key, val, vallen); return (error); }