/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 * Copyright 2025 Oxide Computer Company
 */

#include <mdb/mdb_modapi.h>
#include <sys/rctl.h>
#include <sys/proc.h>
#include <sys/task.h>
#include <sys/project.h>
#include <sys/zone.h>

static int
print_val(uintptr_t addr, rctl_val_t *val, uintptr_t *enforced)
{
        char *priv;
        static const mdb_bitmask_t val_localflag_bits[] = {
                { "SIGNAL", RCTL_LOCAL_SIGNAL, RCTL_LOCAL_SIGNAL },
                { "DENY", RCTL_LOCAL_DENY, RCTL_LOCAL_DENY },
                { "MAX", RCTL_LOCAL_MAXIMAL, RCTL_LOCAL_MAXIMAL },
                { NULL, 0, 0 }
        };

        switch (val->rcv_privilege) {
        case (RCPRIV_BASIC):
                priv = "basic";
                break;
        case (RCPRIV_PRIVILEGED):
                priv = "privileged";
                break;
        case (RCPRIV_SYSTEM):
                priv = "system";
                break;
        default:
                priv = "???";
                break;
        };

        mdb_printf("\t%s ", addr == *enforced ? "(cur)": "     ");

        mdb_printf("%-#18llx %11s\tflags=<%b>\n",
            val->rcv_value, priv, val->rcv_flagaction, val_localflag_bits);

        return (WALK_NEXT);
}

int
rctl(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
        rctl_t rctl;
        rctl_dict_entry_t dict;
        char name[256];
        rctl_hndl_t hndl;

        if (!(flags & DCMD_ADDRSPEC))
                return (DCMD_USAGE);

        if (mdb_vread(&rctl, sizeof (rctl_t), addr) == -1) {
                mdb_warn("failed to read rctl_t structure at %p", addr);
                return (DCMD_ERR);
        }

        if (argc != 0) {
                const mdb_arg_t *argp = &argv[0];

                hndl = (rctl_hndl_t)mdb_argtoull(argp);

                if (rctl.rc_id != hndl)
                        return (DCMD_OK);
        }

        if (mdb_vread(&dict, sizeof (rctl_dict_entry_t),
            (uintptr_t)rctl.rc_dict_entry) == -1) {
                mdb_warn("failed to read dict entry for rctl_t %p at %p",
                    addr, rctl.rc_dict_entry);
                return (DCMD_ERR);
        }

        if (mdb_readstr(name, 256, (uintptr_t)(dict.rcd_name)) == -1) {
                mdb_warn("failed to read name for rctl_t %p", addr);
                return (DCMD_ERR);
        }

        mdb_printf("%0?p\t%3d : %s\n", addr, rctl.rc_id, name);

        if (mdb_pwalk("rctl_val", (mdb_walk_cb_t)print_val, &(rctl.rc_cursor),
            addr) == -1) {
                mdb_warn("failed to walk all values for rctl_t %p", addr);
                return (DCMD_ERR);
        }

        return (DCMD_OK);
}

int
rctl_dict(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
        rctl_dict_entry_t dict;
        char name[256], *type = NULL;

        if (!(flags & DCMD_ADDRSPEC)) {
                if (mdb_walk_dcmd("rctl_dict_list", "rctl_dict", argc,
                    argv) == -1) {
                        mdb_warn("failed to walk 'rctl_dict_list'");
                        return (DCMD_ERR);
                }
                return (DCMD_OK);
        }

        if (DCMD_HDRSPEC(flags))
                mdb_printf("%<u>%2s %-27s %?s %7s %s%</u>\n",
                    "ID", "NAME", "ADDR", "TYPE", "GLOBAL_FLAGS");

        if (mdb_vread(&dict, sizeof (dict), addr) == -1) {
                mdb_warn("failed to read rctl_dict at %p", addr);
                return (DCMD_ERR);
        }
        if (mdb_readstr(name, 256, (uintptr_t)(dict.rcd_name)) == -1) {
                mdb_warn("failed to read rctl_dict name for %p", addr);
                return (DCMD_ERR);
        }

        switch (dict.rcd_entity) {
        case RCENTITY_PROCESS:
                type = "process";
                break;
        case RCENTITY_TASK:
                type = "task";
                break;
        case RCENTITY_PROJECT:
                type = "project";
                break;
        case RCENTITY_ZONE:
                type = "zone";
                break;
        default:
                type = "unknown";
                break;
        }

        mdb_printf("%2d %-27s %0?p %7s 0x%08x", dict.rcd_id, name, addr,
            type, dict.rcd_flagaction);

        return (DCMD_OK);
}

typedef struct dict_data {
        rctl_hndl_t hndl;
        uintptr_t dict_addr;
        rctl_entity_t type;
} dict_data_t;

static int
hndl2dict(uintptr_t addr, rctl_dict_entry_t *entry, dict_data_t *data)
{
        if (data->hndl == entry->rcd_id) {
                data->dict_addr = addr;
                data->type = entry->rcd_entity;
                return (WALK_DONE);
        }

        return (WALK_NEXT);
}

/*
 * Print out all project, task, and process rctls for a given process.
 * If a handle is specified, print only the rctl matching that handle
 * for the process.
 */
int
rctl_list(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
        proc_t proc;
        uintptr_t set;
        task_t task;
        kproject_t proj;
        zone_t zone;
        dict_data_t rdict;
        int i;

        rdict.dict_addr = 0;

        if (!(flags & DCMD_ADDRSPEC))
                return (DCMD_USAGE);

        if (argc == 0)
                rdict.hndl = 0;
        else if (argc == 1) {
                /*
                 * User specified a handle. Go find the rctl_dict_entity_t
                 * structure so we know what type of rctl to look for.
                 */
                const mdb_arg_t *argp = &argv[0];

                rdict.hndl = (rctl_hndl_t)mdb_argtoull(argp);

                if (mdb_walk("rctl_dict_list", (mdb_walk_cb_t)hndl2dict,
                    &rdict) == -1) {
                        mdb_warn("failed to walk rctl_dict_list");
                        return (DCMD_ERR);
                }
                /* Couldn't find a rctl_dict_entry_t for this handle */
                if (rdict.dict_addr == 0)
                        return (DCMD_ERR);
        } else
                return (DCMD_USAGE);


        if (mdb_vread(&proc, sizeof (proc_t), addr) == -1) {
                mdb_warn("failed to read proc at %p", addr);
                return (DCMD_ERR);
        }
        if (mdb_vread(&zone, sizeof (zone_t), (uintptr_t)proc.p_zone) == -1) {
                mdb_warn("failed to read zone at %p", proc.p_zone);
                return (DCMD_ERR);
        }
        if (mdb_vread(&task, sizeof (task_t), (uintptr_t)proc.p_task) == -1) {
                mdb_warn("failed to read task at %p", proc.p_task);
                return (DCMD_ERR);
        }
        if (mdb_vread(&proj, sizeof (kproject_t),
            (uintptr_t)task.tk_proj) == -1) {
                mdb_warn("failed to read proj at %p", task.tk_proj);
                return (DCMD_ERR);
        }

        for (i = 0; i <= RC_MAX_ENTITY; i++) {
                /*
                 * If user didn't specify a handle, print rctls for all
                 * types. Otherwise, we can walk the rctl_set for only the
                 * entity specified by the handle.
                 */
                if (rdict.hndl != 0 && rdict.type != i)
                        continue;

                switch (i) {
                case (RCENTITY_PROCESS):
                        set = (uintptr_t)proc.p_rctls;
                        break;
                case (RCENTITY_TASK):
                        set = (uintptr_t)task.tk_rctls;
                        break;
                case (RCENTITY_PROJECT):
                        set = (uintptr_t)proj.kpj_rctls;
                        break;
                case (RCENTITY_ZONE):
                        set = (uintptr_t)zone.zone_rctls;
                        break;
                default:
                        mdb_warn("Unknown rctl type %d", i);
                        return (DCMD_ERR);
                }

                if (mdb_pwalk_dcmd("rctl_set", "rctl", argc, argv, set) == -1) {
                        mdb_warn("failed to walk rctls in set %p", set);
                        return (DCMD_ERR);
                }
        }

        return (DCMD_OK);
}

typedef struct dict_walk_data {
        int num_dicts;
        int num_cur;
        rctl_dict_entry_t **curdict;
} dict_walk_data_t;

int
rctl_dict_walk_init(mdb_walk_state_t *wsp)
{
        uintptr_t ptr;
        int nlists;
        GElf_Sym sym;
        rctl_dict_entry_t **dicts;
        dict_walk_data_t *dwd;

        if (mdb_lookup_by_name("rctl_lists", &sym) == -1) {
                mdb_warn("failed to find 'rctl_lists'\n");
                return (WALK_ERR);
        }

        nlists = sym.st_size / sizeof (rctl_dict_entry_t *);
        ptr = (uintptr_t)sym.st_value;

        dicts = mdb_alloc(nlists * sizeof (rctl_dict_entry_t *), UM_SLEEP);
        mdb_vread(dicts, sym.st_size, ptr);

        dwd = mdb_alloc(sizeof (dict_walk_data_t), UM_SLEEP);
        dwd->num_dicts = nlists;
        dwd->num_cur = 0;
        dwd->curdict = dicts;

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

        return (WALK_NEXT);
}

int
rctl_dict_walk_step(mdb_walk_state_t *wsp)
{
        dict_walk_data_t *dwd = wsp->walk_data;
        uintptr_t dp;
        rctl_dict_entry_t entry;
        int status;

        dp = (uintptr_t)((dwd->curdict)[dwd->num_cur]);

        while (dp != 0) {
                if (mdb_vread(&entry, sizeof (rctl_dict_entry_t), dp) == -1) {
                        mdb_warn("failed to read rctl_dict_entry_t structure "
                            "at %p", dp);
                        return (WALK_ERR);
                }

                status = wsp->walk_callback(dp, &entry, wsp->walk_cbdata);
                if (status != WALK_NEXT)
                        return (status);

                dp = (uintptr_t)entry.rcd_next;
        }

        dwd->num_cur++;

        if (dwd->num_cur == dwd->num_dicts)
                return (WALK_DONE);

        return (WALK_NEXT);
}

void
rctl_dict_walk_fini(mdb_walk_state_t *wsp)
{
        dict_walk_data_t *wd = wsp->walk_data;
        mdb_free(wd->curdict, wd->num_dicts * sizeof (rctl_dict_entry_t *));
        mdb_free(wd, sizeof (dict_walk_data_t));
}

typedef struct set_walk_data {
        uint_t hashsize;
        int hashcur;
        void **hashloc;
} set_walk_data_t;

int
rctl_set_walk_init(mdb_walk_state_t *wsp)
{
        rctl_set_t rset;
        uint_t hashsz;
        set_walk_data_t *swd;
        rctl_t **rctls;

        if (mdb_vread(&rset, sizeof (rctl_set_t), wsp->walk_addr) == -1) {
                mdb_warn("failed to read rset at %p", wsp->walk_addr);
                return (WALK_ERR);
        }

        if (mdb_readvar(&hashsz, "rctl_set_size") == -1 || hashsz == 0) {
                mdb_warn("rctl_set_size not found or invalid");
                return (WALK_ERR);
        }

        rctls = mdb_alloc(hashsz * sizeof (rctl_t *), UM_SLEEP);
        if (mdb_vread(rctls, hashsz * sizeof (rctl_t *),
            (uintptr_t)rset.rcs_ctls) == -1) {
                mdb_warn("cannot read rctl hash at %p", rset.rcs_ctls);
                mdb_free(rctls, hashsz * sizeof (rctl_t *));
                return (WALK_ERR);
        }

        swd = mdb_alloc(sizeof (set_walk_data_t), UM_SLEEP);
        swd->hashsize = hashsz;
        swd->hashcur = 0;
        swd->hashloc = (void **)rctls;

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

        return (WALK_NEXT);
}


int
rctl_set_walk_step(mdb_walk_state_t *wsp)
{
        set_walk_data_t *swd = wsp->walk_data;
        rctl_t rctl;
        void **rhash = swd->hashloc;
        int status;

        if (swd->hashcur >= swd->hashsize)
                return (WALK_DONE);

        if (wsp->walk_addr == 0) {
                while (swd->hashcur < swd->hashsize) {
                        if (rhash[swd->hashcur] != NULL) {
                                break;
                        }
                        swd->hashcur++;
                }

                if (rhash[swd->hashcur] == NULL ||
                    swd->hashcur >= swd->hashsize)
                        return (WALK_DONE);

                wsp->walk_addr = (uintptr_t)rhash[swd->hashcur];
                swd->hashcur++;
        }

        if (mdb_vread(&rctl, sizeof (rctl_t), wsp->walk_addr) == -1) {
                wsp->walk_addr = 0;
                mdb_warn("unable to read from %#p", wsp->walk_addr);
                return (WALK_ERR);
        }

        status = wsp->walk_callback(wsp->walk_addr, &rctl, wsp->walk_cbdata);

        wsp->walk_addr = (uintptr_t)rctl.rc_next;

        return (status);
}

void
rctl_set_walk_fini(mdb_walk_state_t *wsp)
{
        set_walk_data_t *sd = wsp->walk_data;

        mdb_free(sd->hashloc, sd->hashsize * sizeof (rctl_t *));
        mdb_free(sd, sizeof (set_walk_data_t));
}

int
rctl_val_walk_init(mdb_walk_state_t *wsp)
{
        rctl_t rctl;

        if (mdb_vread(&rctl, sizeof (rctl_t), wsp->walk_addr) == -1) {
                mdb_warn("failed to read rctl at %p", wsp->walk_addr);
                return (WALK_ERR);
        }
        wsp->walk_addr = (uintptr_t)rctl.rc_values;
        wsp->walk_data = rctl.rc_values;
        return (WALK_NEXT);
}

int
rctl_val_walk_step(mdb_walk_state_t *wsp)
{
        rctl_val_t val;
        int status;

        if (mdb_vread(&val, sizeof (rctl_val_t), wsp->walk_addr) == -1) {
                mdb_warn("failed to read rctl_val at %p", wsp->walk_addr);
                return (WALK_DONE);
        }

        status = wsp->walk_callback(wsp->walk_addr, &val, wsp->walk_cbdata);

        if ((wsp->walk_addr = (uintptr_t)val.rcv_next) == 0)
                return (WALK_DONE);

        return (status);
}

typedef struct rctl_val_seen {
        uintptr_t               s_ptr;
        rctl_qty_t              s_val;
} rctl_val_seen_t;

typedef struct rctl_validate_data {
        uintptr_t               v_rctl_addr;
        rctl_val_t              *v_cursor;
        uint_t                  v_flags;
        int                     v_bad_rctl;
        int                     v_cursor_valid;
        int                     v_circularity_detected;
        uint_t                  v_seen_size;
        uint_t                  v_seen_cnt;
        rctl_val_seen_t         *v_seen;
} rctl_validate_data_t;

#define RCV_VERBOSE 0x1

/*
 * rctl_val_validate()
 * Do validation on an individual rctl_val_t. This function is called
 * as part of the rctl_val walker, and helps perform the checks described
 * in the ::rctl_validate dcmd.
 */
static int
rctl_val_validate(uintptr_t addr, rctl_val_t *val, rctl_validate_data_t *data)
{
        int i;

        data->v_seen[data->v_seen_cnt].s_ptr = addr;

        if (addr == (uintptr_t)data->v_cursor)
                data->v_cursor_valid++;

        data->v_seen[data->v_seen_cnt].s_val = val->rcv_value;

        if (val->rcv_prev == (void *)0xbaddcafe ||
            val->rcv_next == (void *)0xbaddcafe ||
            val->rcv_prev == (void *)0xdeadbeef ||
            val->rcv_next == (void *)0xdeadbeef) {
                if (data->v_bad_rctl++ == 0)
                        mdb_printf("%p ", data->v_rctl_addr);
                if (data->v_flags & RCV_VERBOSE)
                        mdb_printf("/ uninitialized or previously "
                            "freed link at %p ", addr);
        }

        if (data->v_seen_cnt == 0) {
                if (val->rcv_prev != NULL) {
                        if (data->v_bad_rctl++ == 0)
                                mdb_printf("%p ", data->v_rctl_addr);
                        if (data->v_flags & RCV_VERBOSE)
                                mdb_printf("/ bad prev pointer at "
                                    "head ");
                }
        } else {
                if ((uintptr_t)val->rcv_prev !=
                    data->v_seen[data->v_seen_cnt - 1].s_ptr) {
                        if (data->v_bad_rctl++ == 0)
                                mdb_printf("%p ", data->v_rctl_addr);
                        if (data->v_flags & RCV_VERBOSE)
                                mdb_printf("/ bad prev pointer at %p ",
                                    addr);
                }

                if (data->v_seen[data->v_seen_cnt].s_val <
                    data->v_seen[data->v_seen_cnt - 1].s_val) {
                        if (data->v_bad_rctl++ == 0)
                                mdb_printf("%p ", data->v_rctl_addr);
                        if (data->v_flags & RCV_VERBOSE)
                                mdb_printf("/ ordering error at %p ",
                                    addr);
                }
        }

        for (i = data->v_seen_cnt; i >= 0; i--) {
                if (data->v_seen[i].s_ptr == (uintptr_t)val->rcv_next) {
                        if (data->v_bad_rctl++ == 0)
                                mdb_printf("%p ", data->v_rctl_addr);
                        if (data->v_flags & RCV_VERBOSE)
                                mdb_printf("/ circular next pointer "
                                    "at %p ", addr);
                        data->v_circularity_detected++;
                        break;
                }
        }

        if (data->v_circularity_detected)
                return (WALK_DONE);

        data->v_seen_cnt++;
        if (data->v_seen_cnt >= data->v_seen_size) {
                uint_t new_seen_size = data->v_seen_size * 2;
                rctl_val_seen_t *tseen = mdb_zalloc(new_seen_size *
                    sizeof (rctl_val_seen_t), UM_SLEEP | UM_GC);

                bcopy(data->v_seen, tseen, data->v_seen_size *
                    sizeof (rctl_val_seen_t));

                data->v_seen = tseen;
                data->v_seen_size = new_seen_size;
        }

        return (WALK_NEXT);
}

/*
 * Validate a rctl pointer by checking:
 *   - rctl_val_t's for that rctl form an ordered, non-circular list
 *   - the cursor points to a rctl_val_t within that list
 *   - there are no more than UINT64_MAX (or # specified by -n)
 *     rctl_val_t's in the list
 */
int
rctl_validate(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
        rctl_validate_data_t data;

        rctl_t r;

        uint64_t long_threshold = UINT64_MAX;

        /* Initialize validate data structure */
        data.v_rctl_addr = addr;
        data.v_flags = 0;
        data.v_bad_rctl = 0;
        data.v_seen_cnt = 0;
        data.v_cursor_valid = 0;
        data.v_circularity_detected = 0;
        data.v_seen_size = 1;
        data.v_seen = mdb_zalloc(data.v_seen_size * sizeof (rctl_val_seen_t),
            UM_SLEEP | UM_GC);

        if (!(flags & DCMD_ADDRSPEC))
                return (DCMD_USAGE);

        if (mdb_getopts(argc, argv,
            'v', MDB_OPT_SETBITS, RCV_VERBOSE, &data.v_flags,
            'n', MDB_OPT_UINT64, &long_threshold,
            NULL) != argc)
                return (DCMD_USAGE);

        if (mdb_vread(&r, sizeof (rctl_t), addr) != sizeof (rctl_t)) {
                mdb_warn("failed to read rctl structure at %p", addr);
                return (DCMD_ERR);
        }

        data.v_cursor = r.rc_cursor;

        if (data.v_cursor == NULL) {
                if (data.v_bad_rctl++ == 0)
                        mdb_printf("%p ", addr);
                if (data.v_flags & RCV_VERBOSE)
                        mdb_printf("/ NULL cursor seen ");
        } else if (data.v_cursor == (rctl_val_t *)0xbaddcafe) {
                if (data.v_bad_rctl++ == 0)
                        mdb_printf("%p ", addr);
                if (data.v_flags & RCV_VERBOSE)
                        mdb_printf("/ uninitialized cursor seen ");
        }

        /* Walk through each val in this rctl for individual validation. */
        if (mdb_pwalk("rctl_val", (mdb_walk_cb_t)rctl_val_validate, &data,
            addr) == -1) {
                mdb_warn("failed to walk all values for rctl_t %p", addr);
                return (DCMD_ERR);
        }

        if (data.v_seen_cnt >= long_threshold) {
                if (data.v_bad_rctl++ == 0)
                        mdb_printf("%p ", addr);
                if (data.v_flags & RCV_VERBOSE)
                        mdb_printf("/ sequence length = %d ",
                            data.v_seen_cnt);
        }

        if (!data.v_cursor_valid) {
                if (data.v_bad_rctl++ == 0)
                        mdb_printf("%p ", addr);
                if (data.v_flags & RCV_VERBOSE)
                        mdb_printf("/ cursor outside sequence");
        }

        if (data.v_bad_rctl)
                mdb_printf("\n");

        if (data.v_circularity_detected)
                mdb_warn("circular list implies possible memory leak; "
                    "recommend invoking ::findleaks");

        return (DCMD_OK);
}