/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */
/*
 * Copyright 2021 Tintri by DDN, Inc. All rights reserved.
 */

#include <sys/mdb_modapi.h>
#include <mdb/mdb_ctf.h>
#include <sys/types.h>
#include <sys/mutex_impl.h>
#include <sys/rwlock_impl.h>
#include <sys/zone.h>
#include <sys/socket.h>

#include "nfssrv.h"
#include "common.h"

struct common_zsd_cb_data {
        zone_key_t      key;            /* Key of ZSD for which we're looking */
        uint_t          found;          /* Was the specific ZSD entry found? */
        uintptr_t       zsd_data;       /* Result */
};

int
zoned_find_zsd_cb(uintptr_t addr, const void *data, void *cb_data)
{
        const struct zsd_entry *entry = data;
        struct common_zsd_cb_data *cbd = cb_data;

        if (cbd->key != entry->zsd_key)
                return (WALK_NEXT);

        /* Match */
        cbd->zsd_data = (uintptr_t)entry->zsd_data;
        cbd->found = TRUE;
        return (WALK_DONE);
}

int
zoned_get_nfs_globals(uintptr_t zonep, uintptr_t *result)
{
        return (zoned_get_zsd(zonep, "nfssrv_zone_key", result));
}

int
zoned_get_zsd(uintptr_t zonep, char *key_str, uintptr_t *result)
{
        zone_key_t      key;
        struct          common_zsd_cb_data cbd;

        if (mdb_readsym(&key, sizeof (zone_key_t), key_str) == -1) {
                mdb_warn("failed to get %s", key_str);
                return (DCMD_ERR);
        }

        cbd.key = key;
        cbd.found = FALSE;

        if (mdb_pwalk("zsd", zoned_find_zsd_cb, &cbd, zonep) != 0) {
                mdb_warn("failed to walk zsd");
                return (DCMD_ERR);
        }

        if (cbd.found == FALSE) {
                mdb_warn("no ZSD entry found");
                return (DCMD_ERR);
        }

        *result = cbd.zsd_data;
        return (DCMD_OK);
}


const char *
common_mutex(kmutex_t *mp)
{
        char *s;
        size_t sz;
        mutex_impl_t *lp = (mutex_impl_t *)mp;

        if (MUTEX_TYPE_SPIN(lp)) {
                const char *fmt = "spin - lock(%x)/oldspl(%x)/minspl(%x)";

                sz = 1 + mdb_snprintf(NULL, 0, fmt, lp->m_spin.m_spinlock,
                    lp->m_spin.m_oldspl, lp->m_spin.m_minspl);
                s = mdb_alloc(sz, UM_SLEEP | UM_GC);
                (void) mdb_snprintf(s, sz, fmt, lp->m_spin.m_spinlock,
                    lp->m_spin.m_oldspl, lp->m_spin.m_minspl);

                return (s);
        }

        if (MUTEX_TYPE_ADAPTIVE(lp)) {
                const char *fmt = "adaptive - owner %p%s";

                if ((MUTEX_OWNER(lp) == NULL) && !MUTEX_HAS_WAITERS(lp))
                        return ("mutex not held");

                sz = 1 + mdb_snprintf(NULL, 0, fmt, MUTEX_OWNER(lp),
                    MUTEX_HAS_WAITERS(lp) ? " has waiters" : "");
                s = mdb_alloc(sz, UM_SLEEP | UM_GC);
                (void) mdb_snprintf(s, sz, fmt, MUTEX_OWNER(lp),
                    MUTEX_HAS_WAITERS(lp) ? " has waiters" : "");

                return (s);
        }

        return ("mutex dead");
}

const char *
common_rwlock(krwlock_t *lp)
{
        char *s;
        size_t sz;
        uintptr_t w = ((rwlock_impl_t *)lp)->rw_wwwh;
        uintptr_t o = w & RW_OWNER;
        const char *hw = (w & RW_HAS_WAITERS) ? " has_waiters" : "";
        const char *ww = (w & RW_WRITE_WANTED) ? " write_wanted" : "";
        const char *wl = (w & RW_WRITE_LOCKED) ? " write_locked" : "";

        sz = 1 + mdb_snprintf(NULL, 0, "owner %p%s%s%s", o, hw, ww, wl);
        s = mdb_alloc(sz, UM_SLEEP | UM_GC);
        (void) mdb_snprintf(s, sz, "owner %p%s%s%s", o, hw, ww, wl);

        return (s);
}

const char *
common_netbuf_str(struct netbuf *nb)
{
        struct sockaddr_in *in;

        in = mdb_alloc(nb->len + 1, UM_SLEEP | UM_GC);
        if (mdb_vread(in, nb->len, (uintptr_t)nb->buf) == -1)
                return ("");

        if (nb->len < sizeof (struct sockaddr_in)) {
                ((char *)in)[nb->len] = '\0';
                return ((char *)in);
        }

        if (in->sin_family == AF_INET) {
                char *s;
                ssize_t sz;

                mdb_nhconvert(&in->sin_port, &in->sin_port,
                    sizeof (in->sin_port));

                sz = 1 + mdb_snprintf(NULL, 0, "%I:%d", in->sin_addr.s_addr,
                    in->sin_port);
                s = mdb_alloc(sz, UM_SLEEP | UM_GC);
                (void) mdb_snprintf(s, sz, "%I:%d", in->sin_addr.s_addr,
                    in->sin_port);

                return (s);
        } else if ((in->sin_family == AF_INET6) &&
            (nb->len >= sizeof (struct sockaddr_in6))) {
                struct sockaddr_in6 *in6 = (struct sockaddr_in6 *)in;
                char *s;
                size_t sz;

                mdb_nhconvert(&in6->sin6_port, &in6->sin6_port,
                    sizeof (in6->sin6_port));

                sz = 1 + mdb_snprintf(NULL, 0, "[%N]:%d",
                    in6->sin6_addr.s6_addr, in6->sin6_port);
                s = mdb_alloc(sz, UM_SLEEP | UM_GC);
                (void) mdb_snprintf(s, sz, "[%N]:%d", in6->sin6_addr.s6_addr,
                    in6->sin6_port);

                return (s);
        } else {
                ((char *)in)[nb->len] = '\0';
                return ((char *)in);
        }
}

/*
 * Generic hash table walker
 *
 */

typedef struct hash_table_walk_data {
        uintptr_t table;        /* current table pointer */
        int count;              /* number of entries to process */
        void *member;           /* copy of the current member structure */
} hash_table_walk_data_t;

int
hash_table_walk_init(mdb_walk_state_t *wsp)
{
        hash_table_walk_arg_t *arg = wsp->walk_arg;
        hash_table_walk_data_t *wd = mdb_alloc(sizeof (*wd), UM_SLEEP);

        wd->table = arg->array_addr;
        wd->count = arg->array_len;

        wd->member = mdb_alloc(arg->member_size, UM_SLEEP);

        wsp->walk_addr = 0;
        wsp->walk_data = wd;

        return (WALK_NEXT);
}

int
hash_table_walk_step(mdb_walk_state_t *wsp)
{
        hash_table_walk_arg_t *arg = wsp->walk_arg;
        hash_table_walk_data_t *wd = wsp->walk_data;
        uintptr_t addr = wsp->walk_addr;

        if (wd->count == 0)
                return (WALK_DONE);

        if (addr == 0) {
                if (mdb_vread(&wsp->walk_addr, sizeof (wsp->walk_addr),
                    wd->table + arg->first_offset) == -1) {
                        mdb_warn("can't read %s", arg->first_name);
                        return (WALK_ERR);
                }
                if (wsp->walk_addr == 0)
                        wsp->walk_addr = wd->table;

                return (WALK_NEXT);
        }

        if (addr == wd->table) {
                wd->count--;
                wd->table += arg->head_size;
                wsp->walk_addr = 0;

                return (WALK_NEXT);
        }

        if (mdb_vread(wd->member, arg->member_size, addr) == -1) {
                mdb_warn("unable to read %s", arg->member_type_name);
                return (WALK_ERR);
        }

        wsp->walk_addr = *(uintptr_t *)((uintptr_t)wd->member
            + arg->next_offset);
        if (wsp->walk_addr == 0)
                wsp->walk_addr = wd->table;

        return (wsp->walk_callback(addr, wd->member, wsp->walk_cbdata));
}

void
hash_table_walk_fini(mdb_walk_state_t *wsp)
{
        hash_table_walk_arg_t *arg = wsp->walk_arg;
        hash_table_walk_data_t *wd = wsp->walk_data;

        mdb_free(wd->member, arg->member_size);
        mdb_free(wd, sizeof (*wd));
}