/*-
 * 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);
}