/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2025 The FreeBSD Foundation
 *
 * This software was developed by Konstantin Belousov <kib@FreeBSD.org>
 * under sponsorship from the FreeBSD Foundation.
 *
 * 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, 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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.
 */

#include <sys/param.h>
#include <sys/event.h>
#include <sys/sysctl.h>
#include <sys/user.h>

#include <err.h>
#include <errno.h>
#include <libprocstat.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>

#include "procstat.h"

static const char kqs[] = "kqueues";
static const char kq[] = "kqueue";

#define FILT_ELEM(name) [-EVFILT_##name] = #name,
static const char *const filter_names[] = {
        [0] = "invalid",
        FILT_ELEM(READ)
        FILT_ELEM(WRITE)
        FILT_ELEM(AIO)
        FILT_ELEM(VNODE)
        FILT_ELEM(PROC)
        FILT_ELEM(SIGNAL)
        FILT_ELEM(TIMER)
        FILT_ELEM(PROCDESC)
        FILT_ELEM(FS)
        FILT_ELEM(LIO)
        FILT_ELEM(USER)
        FILT_ELEM(SENDFILE)
        FILT_ELEM(EMPTY)
};
#undef FILT_ELEM

#define PK_FLAG_ELEM(fname, str) { .flag = fname, .dispstr = str }
#define PK_NAME_ELEM(prefix, fname) { .flag = prefix##fname, .dispstr = #fname }
#define PK_FLAG_LAST_ELEM() { .flag = -1, .dispstr = NULL }
struct pk_elem {
        unsigned int flag;
        const char *dispstr;
};

static const struct pk_elem kn_status_names[] = {
        PK_FLAG_ELEM(KNOTE_STATUS_ACTIVE, "A"),
        PK_FLAG_ELEM(KNOTE_STATUS_QUEUED, "Q"),
        PK_FLAG_ELEM(KNOTE_STATUS_DISABLED, "D"),
        PK_FLAG_ELEM(KNOTE_STATUS_DETACHED, "d"),
        PK_FLAG_ELEM(KNOTE_STATUS_KQUEUE, "K"),
        PK_FLAG_LAST_ELEM(),
};

static const struct pk_elem ev_flags_names[] = {
        PK_FLAG_ELEM(EV_ONESHOT, "O"),
        PK_FLAG_ELEM(EV_CLEAR, "C"),
        PK_FLAG_ELEM(EV_RECEIPT, "R"),
        PK_FLAG_ELEM(EV_DISPATCH, "D"),
        PK_FLAG_ELEM(EV_DROP, "d"),
        PK_FLAG_ELEM(EV_FLAG1, "1"),
        PK_FLAG_ELEM(EV_FLAG2, "2"),
        PK_FLAG_LAST_ELEM(),
};

static char *
procstat_kqueue_flags(const struct pk_elem *names, unsigned flags, bool commas)
{
        char *res;
        const struct pk_elem *pl;
        size_t len;
        int i;
        bool first;

        first = true;
        len = 0;
        for (i = 0;; i++) {
                pl = &names[i];
                if (pl->flag == (unsigned)-1)
                        break;
                if ((flags & pl->flag) != 0) {
                        if (first)
                                first = false;
                        else if (commas)
                                len += sizeof(",");
                        len += strlen(pl->dispstr);
                }
        }
        len++;

        res = malloc(len);
        first = true;
        res[0] = '\0';
        for (i = 0;; i++) {
                pl = &names[i];
                if (pl->flag == (unsigned)-1)
                        break;
                if ((flags & pl->flag) != 0) {
                        if (first)
                                first = false;
                        else if (commas)
                                strlcat(res, ",", len);
                        strlcat(res, pl->dispstr, len);
                }
        }

        if (strlen(res) == 0) {
                free(res);
                res = strdup("-");
        }
        return (res);
}

static const struct pk_elem rw_filter_names[] = {
        PK_NAME_ELEM(NOTE_, LOWAT),
        PK_NAME_ELEM(NOTE_, FILE_POLL),
        PK_FLAG_LAST_ELEM(),
};

static const struct pk_elem user_filter_names[] = {
        PK_NAME_ELEM(NOTE_, FFAND),
        PK_NAME_ELEM(NOTE_, FFOR),
        PK_NAME_ELEM(NOTE_, TRIGGER),
        PK_FLAG_LAST_ELEM(),
};

static const struct pk_elem vnode_filter_names[] = {
        PK_NAME_ELEM(NOTE_, DELETE),
        PK_NAME_ELEM(NOTE_, WRITE),
        PK_NAME_ELEM(NOTE_, EXTEND),
        PK_NAME_ELEM(NOTE_, ATTRIB),
        PK_NAME_ELEM(NOTE_, LINK),
        PK_NAME_ELEM(NOTE_, RENAME),
        PK_NAME_ELEM(NOTE_, REVOKE),
        PK_NAME_ELEM(NOTE_, OPEN),
        PK_NAME_ELEM(NOTE_, CLOSE),
        PK_NAME_ELEM(NOTE_, CLOSE_WRITE),
        PK_NAME_ELEM(NOTE_, READ),
        PK_FLAG_LAST_ELEM(),
};

static const struct pk_elem proc_filter_names[] = {
        PK_NAME_ELEM(NOTE_, EXIT),
        PK_NAME_ELEM(NOTE_, FORK),
        PK_NAME_ELEM(NOTE_, EXEC),
        PK_NAME_ELEM(NOTE_, TRACK),
        PK_NAME_ELEM(NOTE_, TRACKERR),
        PK_NAME_ELEM(NOTE_, CHILD),
        PK_FLAG_LAST_ELEM(),
};

static const struct pk_elem timer_filter_names[] = {
        PK_NAME_ELEM(NOTE_, SECONDS),
        PK_NAME_ELEM(NOTE_, MSECONDS),
        PK_NAME_ELEM(NOTE_, USECONDS),
        PK_NAME_ELEM(NOTE_, NSECONDS),
        PK_NAME_ELEM(NOTE_, ABSTIME),
        PK_FLAG_LAST_ELEM(),
};

#define FILT_ELEM(name) [-EVFILT_##name] = "EVFILT_"#name
static const struct pk_elem *const filter_pk_names[] = {
        [0] =                   NULL,
        [-EVFILT_READ] =        rw_filter_names,
        [-EVFILT_WRITE] =       rw_filter_names,
        [-EVFILT_AIO] =         rw_filter_names,
        [-EVFILT_VNODE] =       vnode_filter_names,
        [-EVFILT_PROC] =        proc_filter_names,
        [-EVFILT_SIGNAL] =      NULL,
        [-EVFILT_TIMER] =       timer_filter_names,
        [-EVFILT_PROCDESC] =    proc_filter_names,
        [-EVFILT_FS] =          NULL,
        [-EVFILT_LIO] =         rw_filter_names,
        [-EVFILT_USER] =        user_filter_names,
        [-EVFILT_SENDFILE] =    NULL,
        [-EVFILT_EMPTY] =       NULL,
};

static char *
procstat_kqueue_fflags(int filter, unsigned fflags)
{
        const struct pk_elem *names;

        names = NULL;
        if (filter < 0 && -filter < (int)nitems(filter_pk_names))
                names = filter_pk_names[-filter];
        if (names == NULL)
                return (strdup("-"));
        return (procstat_kqueue_flags(names, fflags, true));
}

static const char *
procstat_kqueue_get_filter_name(int filter)
{
        filter = -filter;
        if (filter < 0 || filter >= (int)nitems(filter_names))
                filter = 0;
        return (filter_names[filter]);
}

static void
procstat_kqueue(struct procstat *procstat, struct kinfo_proc *kipp, int fd,
    bool verbose)
{
        struct kinfo_knote *kni, *knis;
        char *flags, *fflags, *status;
        unsigned int count, i, j;
        char errbuf[_POSIX2_LINE_MAX];

        errbuf[0] = '\0';
        knis = procstat_get_kqueue_info(procstat, kipp, fd, &count, errbuf);
        if (knis == NULL) {
                warnx("%s\n", errbuf);
                return;
        }

        for (i = 0; i < count; i++) {
                kni = &knis[i];
                flags = procstat_kqueue_flags(ev_flags_names,
                    kni->knt_event.flags, false);
                fflags = procstat_kqueue_fflags(kni->knt_event.filter,
                    kni->knt_event.fflags);
                status = procstat_kqueue_flags(kn_status_names,
                    kni->knt_status, false);
                xo_open_instance(kq);
                xo_emit("{dk:process_id/%7d} ", kipp->ki_pid);
                xo_emit("{:kqueue_fd/%10d} ", fd);
                xo_emit("{:filter/%8s} ", procstat_kqueue_get_filter_name(
                    kni->knt_event.filter));
                xo_emit("{:ident/%10d} ", kni->knt_event.ident);
                xo_emit("{:flags/%10s} ", flags);
                xo_emit("{:fflags/%10s} ", fflags);
                xo_emit("{:data/%#10jx} ", (uintmax_t)kni->knt_event.data);
                xo_emit("{:udata/%10p} ", (uintmax_t)kni->knt_event.udata);
                if (verbose) {
                        for (j = 0; j < nitems(kni->knt_event.ext); j++) {
                                xo_emit("{:ext%u/%#10jx} ", j,
                                    (uintmax_t)kni->knt_event.ext[j]);
                        }
                }
                xo_emit("{:status/%10s}\n", status);
                free(flags);
                free(fflags);
                free(status);
                xo_close_instance(kq);
        }

        procstat_freekqinfo(procstat, knis);
}

void
procstat_kqueues(struct procstat *procstat, struct kinfo_proc *kipp)
{
        struct filestat_list *fl;
        struct filestat *f;
        bool verbose;

        verbose = (procstat_opts & PS_OPT_VERBOSE) != 0;
        if ((procstat_opts & PS_OPT_NOHEADER) == 0) {
                if (verbose) {
                        xo_emit("{T:/%7s %10s %8s %10s %10s %10s %10s %10s "
                            "%10s %10s %10s %10s %10s}\n",
                            "PID", "KQFD", "FILTER", "IDENT", "FLAGS", "FFLAGS",
                            "DATA", "UDATA", "EXT0", "EXT1","EXT2","EXT3",
                            "STATUS");
                } else {
                        xo_emit("{T:/%7s %10s %8s %10s %10s %10s %10s %10s "
                            "%10s}\n",
                            "PID", "KQFD", "FILTER", "IDENT", "FLAGS", "FFLAGS",
                            "DATA", "UDATA", "STATUS");
                }
        }

        xo_emit("{ek:process_id/%d}", kipp->ki_pid);

        fl = procstat_getfiles(procstat, kipp, 0);
        if (fl == NULL)
                return;
        xo_open_list(kqs);
        STAILQ_FOREACH(f, fl, next) {
                if (f->fs_type != PS_FST_TYPE_KQUEUE)
                        continue;
                xo_emit("{ek:kqueue/%d}", f->fs_fd);
                xo_open_list(kq);
                procstat_kqueue(procstat, kipp, f->fs_fd, verbose);
                xo_close_list(kq);
        }
        xo_close_list(kqs);
        procstat_freefiles(procstat, fl);
}