/*      $NetBSD: sysctlfs.c,v 1.22 2025/11/19 22:16:48 andvar Exp $     */

/*-
 * Copyright (c) 2006, 2007  Antti Kantee.  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, 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 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.
 */

/*
 * sysctlfs: mount sysctls as a file system tree.  Supports query and
 * modify of nodes in the sysctl namespace in addition to namespace
 * traversal.
 */

#include <sys/cdefs.h>
#ifndef lint
__RCSID("$NetBSD: sysctlfs.c,v 1.22 2025/11/19 22:16:48 andvar Exp $");
#endif /* !lint */

#include <sys/types.h>
#include <sys/sysctl.h>

#include <stdio.h>
#include <assert.h>
#include <err.h>
#include <errno.h>
#include <mntopts.h>
#include <paths.h>
#include <puffs.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <util.h>

#ifdef RUMP_ACTION
#include <rump/rump.h>
#include <rump/rump_syscalls.h>

#define sysctl(a,b,c,d,e,f) rump_sys___sysctl(a,b,c,d,e,f)
#endif

PUFFSOP_PROTOS(sysctlfs)

struct sfsnode {
        int sysctl_flags;
        ino_t myid;
};

#define SFSPATH_DOTDOT 0
#define SFSPATH_NORMAL 1

#define N_HIERARCHY 10
typedef int SfsName[N_HIERARCHY];

struct sfsfid {
        int len;
        SfsName path;
};

static struct sfsnode rn;
static SfsName sname_root;
static struct timespec fstime;

static ino_t nextid = 3;
static mode_t fileperms;
static uid_t fileuid;
static gid_t filegid;

static int rflag;

#define ISADIR(a) ((SYSCTL_TYPE(a->sysctl_flags) == CTLTYPE_NODE))
#define SFS_MAXFILE 32768
#define SFS_NODEPERDIR 128

static int sysctlfs_domount(struct puffs_usermount *);

/*
 * build paths.  doesn't support rename (but neither does the fs)
 */
static int
sysctlfs_pathbuild(struct puffs_usermount *pu,
    const struct puffs_pathobj *parent, const struct puffs_pathobj *comp,
    size_t offset, struct puffs_pathobj *res)
{
        SfsName *sname;
        size_t clen;

        assert(parent->po_len < N_HIERARCHY); /* code uses +1 */

        sname = malloc(sizeof(SfsName));
        assert(sname != NULL);

        clen = parent->po_len;
        if (comp->po_len == SFSPATH_DOTDOT) {
                assert(clen != 0);
                clen--;
        }

        memcpy(sname, parent->po_path, clen * sizeof(int));

        res->po_path = sname;
        res->po_len = clen;

        return 0;
}

static int
sysctlfs_pathtransform(struct puffs_usermount *pu,
    const struct puffs_pathobj *p, const struct puffs_cn *pcn,
    struct puffs_pathobj *res)
{

        res->po_path = NULL;
        /*
         * XXX: overload.  prevents us from doing rename, but the fs
         * (and sysctl(3)) doesn't support it, so no biggie
         */
        if (PCNISDOTDOT(pcn)) {
                res->po_len = SFSPATH_DOTDOT;
        } else {
                res->po_len = SFSPATH_NORMAL;
        }

        return 0;
}

static int
sysctlfs_pathcmp(struct puffs_usermount *pu, struct puffs_pathobj *po1,
    struct puffs_pathobj *po2, size_t clen, int checkprefix)
{

        if (memcmp(po1->po_path, po2->po_path, clen * sizeof(int)) == 0)
                return 0;
        return 1;
}

static void
sysctlfs_pathfree(struct puffs_usermount *pu, struct puffs_pathobj *po)
{

        free(po->po_path);
}

static struct puffs_node *
getnode(struct puffs_usermount *pu, struct puffs_pathobj *po, int nodetype)
{
        struct sysctlnode sn[SFS_NODEPERDIR];
        struct sysctlnode qnode;
        struct puffs_node *pn;
        struct sfsnode *sfs;
        SfsName myname, *sname;
        size_t sl, i;

        /*
         * Check if we need to create a new in-memory node or if we
         * already have one for this path.  Shortcut for the rootnode.
         * Also, memcmp against zero-length would be quite true always.
         */
        if (po->po_len == 0)
                pn = puffs_getroot(pu);
        else
                pn = puffs_pn_nodewalk(pu, puffs_path_walkcmp, po);

        if (pn != NULL) 
                return pn;
        /*
         * don't know nodetype?  query...
         *
         * XXX1: nothing really guarantees 0 is an invalid nodetype
         * XXX2: is there really no easier way of doing this?  we
         *       know the whole mib path
         */
        if (!nodetype) {
                sname = po->po_path;
                memcpy(myname, po->po_path, po->po_len * sizeof(myname[0]));

                memset(&qnode, 0, sizeof(qnode));
                qnode.sysctl_flags = SYSCTL_VERSION;
                myname[po->po_len-1] = CTL_QUERY;

                sl = sizeof(sn);
                if (sysctl(myname, po->po_len, sn, &sl,
                    &qnode, sizeof(qnode)) == -1)
                        abort();
                
                for (i = 0; i < sl / sizeof(struct sysctlnode); i++) {
                         if (sn[i].sysctl_num == (*sname)[po->po_len-1]) {
                                nodetype = sn[i].sysctl_flags;
                                break;
                        }
                }
                if (!nodetype)
                        return NULL;
        }

        sfs = emalloc(sizeof(*sfs));    
        sfs->sysctl_flags = nodetype;
        sfs->myid = nextid++;

        pn = puffs_pn_new(pu, sfs);
        assert(pn);

        return pn;
}

static void __dead
usage(void)
{

        fprintf(stderr, "Usage: %s [-o <mntopts>] sysctlfs mountpath\n",
            getprogname());
        exit(1);
}

int
main(int argc, char *argv[])
{
        struct puffs_usermount *pu;
        struct puffs_ops *pops;
        mntoptparse_t mp;
        int mntflags, pflags;
        int detach;
        int ch;

        setprogname(argv[0]);

        if (argc < 2)
                usage();

        mntflags = pflags = 0;
        detach = 1;
        while ((ch = getopt(argc, argv, "o:rs")) != -1) {
                switch (ch) {
                case 'o':
                        mp = getmntopts(optarg, puffsmopts, &mntflags, &pflags);
                        if (mp == NULL)
                                err(EXIT_FAILURE, "getmntopts");
                        freemntopts(mp);
                        break;
                case 'r':
                        rflag = 1;
                        break;
                case 's':
                        detach = 0;
                        break;
                }
        }
        argv += optind;
        argc -= optind;
        pflags |= PUFFS_FLAG_BUILDPATH | PUFFS_KFLAG_NOCACHE;

        if (pflags & PUFFS_FLAG_OPDUMP)
                detach = 0;

        if (argc != 2)
                usage();

        PUFFSOP_INIT(pops);

        PUFFSOP_SETFSNOP(pops, unmount);
        PUFFSOP_SETFSNOP(pops, sync);
        PUFFSOP_SETFSNOP(pops, statvfs);
        PUFFSOP_SET(pops, sysctlfs, fs, nodetofh);
        PUFFSOP_SET(pops, sysctlfs, fs, fhtonode);

        PUFFSOP_SET(pops, sysctlfs, node, lookup);
        PUFFSOP_SET(pops, sysctlfs, node, getattr);
        PUFFSOP_SET(pops, sysctlfs, node, setattr);
        PUFFSOP_SET(pops, sysctlfs, node, readdir);
        PUFFSOP_SET(pops, sysctlfs, node, read);
        PUFFSOP_SET(pops, sysctlfs, node, write);
        PUFFSOP_SET(pops, puffs_genfs, node, reclaim);

        pu = puffs_init(pops, _PATH_PUFFS, "sysctlfs", NULL, pflags);
        if (pu == NULL)
                err(EXIT_FAILURE, "puffs_init");

        puffs_set_pathbuild(pu, sysctlfs_pathbuild);
        puffs_set_pathtransform(pu, sysctlfs_pathtransform);
        puffs_set_pathcmp(pu, sysctlfs_pathcmp);
        puffs_set_pathfree(pu, sysctlfs_pathfree);

        puffs_setfhsize(pu, sizeof(struct sfsfid), PUFFS_FHFLAG_NFSV3);

        if (sysctlfs_domount(pu) != 0)
                errx(EXIT_FAILURE, "domount");

        if (detach)
                if (puffs_daemon(pu, 1, 1) == -1)
                        err(EXIT_FAILURE, "puffs_daemon");

#ifdef RUMP_ACTION
        {
                extern int puffs_fakecc;
                puffs_fakecc = 1;
                rump_init();
        }
#endif

        if (puffs_mount(pu, argv[1], mntflags, puffs_getroot(pu)) == -1)
                err(EXIT_FAILURE, "puffs_mount");
        if (puffs_mainloop(pu) == -1)
                err(EXIT_FAILURE, "mainloop");

        return 0;
}

static int
sysctlfs_domount(struct puffs_usermount *pu)
{
        struct puffs_pathobj *po_root;
        struct puffs_node *pn_root;
        struct timeval tv_now;

        rn.myid = 2;
        rn.sysctl_flags = CTLTYPE_NODE;

        gettimeofday(&tv_now, NULL);
        TIMEVAL_TO_TIMESPEC(&tv_now, &fstime);

        pn_root = puffs_pn_new(pu, &rn);
        assert(pn_root != NULL);
        puffs_setroot(pu, pn_root);

        po_root = puffs_getrootpathobj(pu);
        po_root->po_path = &sname_root;
        po_root->po_len = 0;

        fileuid = geteuid();
        filegid = getegid();

        if (fileuid == 0)
                fileperms = 0644;
        else
                fileperms = 0444;

        return 0;
}

int
sysctlfs_fs_fhtonode(struct puffs_usermount *pu, void *fid, size_t fidsize,
        struct puffs_newinfo *pni)
{
        struct puffs_pathobj po;
        struct puffs_node *pn;
        struct sfsnode *sfs;
        struct sfsfid *sfid;

        sfid = fid;

        po.po_len = sfid->len;
        po.po_path = &sfid->path;

        pn = getnode(pu, &po, 0);
        if (pn == NULL)
                return EINVAL;
        sfs = pn->pn_data;

        puffs_newinfo_setcookie(pni, pn);
        if (ISADIR(sfs))
                puffs_newinfo_setvtype(pni, VDIR);
        else
                puffs_newinfo_setvtype(pni, VREG);

        return 0;
}

int
sysctlfs_fs_nodetofh(struct puffs_usermount *pu, void *cookie,
        void *fid, size_t *fidsize)
{
        struct puffs_node *pn = cookie;
        struct sfsfid *sfid;

        sfid = fid;
        sfid->len = PNPLEN(pn);
        memcpy(&sfid->path, PNPATH(pn), sfid->len * sizeof(int));

        return 0;
}

static void
getnodedata(struct sfsnode *sfs, struct puffs_pathobj *po,
        char *buf, size_t *bufsize)
{
        size_t sz;
        int error = 0;

        assert(!ISADIR(sfs));

        memset(buf, 0, *bufsize);
        switch (SYSCTL_TYPE(sfs->sysctl_flags)) {
        case CTLTYPE_BOOL: {
                bool b;
                sz = sizeof(bool);
                assert(sz <= *bufsize);
                if (sysctl(po->po_path, po->po_len, &b, &sz, NULL, 0) == -1) {
                        error = errno;
                        break;
                }
                if (rflag)
                        memcpy(buf, &b, sz);
                else
                        snprintf(buf, *bufsize, "%s", b ? "true" : "false");
                break;
        }
        case CTLTYPE_INT: {
                int i;
                sz = sizeof(int);
                assert(sz <= *bufsize);
                if (sysctl(po->po_path, po->po_len, &i, &sz, NULL, 0) == -1) {
                        error = errno;
                        break;
                }
                if (rflag)
                        memcpy(buf, &i, sz);
                else
                        snprintf(buf, *bufsize, "%d", i);
                break;
        }
        case CTLTYPE_QUAD: {
                quad_t q;
                sz = sizeof(q);
                assert(sz <= *bufsize);
                if (sysctl(po->po_path, po->po_len, &q, &sz, NULL, 0) == -1) {
                        error = errno;
                        break;
                }
                if (rflag)
                        memcpy(buf, &q, sz);
                else
                        snprintf(buf, *bufsize, "%" PRId64, q);
                break;
        }
        case CTLTYPE_STRUCT: {
                uint8_t snode[SFS_MAXFILE/2-1];
                unsigned i;

                sz = sizeof(snode);
                assert(sz <= *bufsize);
                if (sysctl(po->po_path, po->po_len, snode, &sz, NULL, 0) == -1){
                        error = errno;
                        break;
                }
                if (rflag) {
                        memcpy(buf, &snode, sz);
                } else {
                        for (i = 0; i < sz && 2*i < *bufsize; i++) {
                                sprintf(&buf[2*i], "%02x", snode[i]);
                        }
                        buf[2*i] = '\0';
                }
                break;
        }
        case CTLTYPE_STRING: {
                sz = *bufsize;
                assert(sz <= *bufsize);
                if (sysctl(po->po_path, po->po_len, buf, &sz, NULL, 0) == -1) {
                        error = errno;
                        break;
                }
                break;
        }
        default:
                snprintf(buf, *bufsize, "invalid sysctl CTLTYPE %d",
                    SYSCTL_TYPE(sfs->sysctl_flags));
                break;
        }

        if (error) {
                *bufsize = 0;
                return;
        }

        if (rflag)
                *bufsize = sz;
        else
                *bufsize = strlen(buf);
}

static int
getlinks(struct sfsnode *sfs, struct puffs_pathobj *po)
{
        struct sysctlnode sn[SFS_NODEPERDIR];
        struct sysctlnode qnode;
        SfsName *sname;
        size_t sl;

        if (!ISADIR(sfs))
                return 1;

        memset(&qnode, 0, sizeof(qnode));
        sl = sizeof(sn);
        qnode.sysctl_flags = SYSCTL_VERSION;
        sname = po->po_path;
        (*sname)[po->po_len] = CTL_QUERY;

        if (sysctl(*sname, po->po_len + 1, sn, &sl,
            &qnode, sizeof(qnode)) == -1)
                return 0;

        return (sl / sizeof(sn[0])) + 2;
}

static int
getsize(struct sfsnode *sfs, struct puffs_pathobj *po)
{
        char buf[SFS_MAXFILE];
        size_t sz = sizeof(buf);

        if (ISADIR(sfs))
                return getlinks(sfs, po) * 16; /* totally arbitrary */

        getnodedata(sfs, po, buf, &sz);
        if (rflag)
                return sz;
        else
                return sz + 1; /* for \n, not \0 */
}

int
sysctlfs_node_lookup(struct puffs_usermount *pu, void *opc,
        struct puffs_newinfo *pni, const struct puffs_cn *pcn)
{
        struct puffs_cn *p2cn = __UNCONST(pcn); /* XXX: fix the interface */
        struct sysctlnode sn[SFS_NODEPERDIR];
        struct sysctlnode qnode;
        struct puffs_node *pn_dir = opc;
        struct puffs_node *pn_new;
        struct sfsnode *sfs_dir = pn_dir->pn_data, *sfs_new;
        SfsName *sname = PCNPATH(pcn);
        size_t sl, i;
        int nodetype;

        assert(ISADIR(sfs_dir));

        /*
         * If we're looking for dotdot, we already have the entire pathname
         * in sname, courtesy of pathbuild, so we can skip this step.
         */
        if (!PCNISDOTDOT(pcn)) {
                memset(&qnode, 0, sizeof(qnode));
                sl = SFS_NODEPERDIR * sizeof(struct sysctlnode);
                qnode.sysctl_flags = SYSCTL_VERSION;
                (*sname)[PCNPLEN(pcn)] = CTL_QUERY;

                if (sysctl(*sname, PCNPLEN(pcn) + 1, sn, &sl,
                    &qnode, sizeof(qnode)) == -1)
                        return ENOENT;

                for (i = 0; i < sl / sizeof(struct sysctlnode); i++)
                        if (strcmp(sn[i].sysctl_name, pcn->pcn_name) == 0)
                                break;
                if (i == sl / sizeof(struct sysctlnode))
                        return ENOENT;

                (*sname)[PCNPLEN(pcn)] = sn[i].sysctl_num;
                p2cn->pcn_po_full.po_len++;
                nodetype = sn[i].sysctl_flags;
        } else
                nodetype = CTLTYPE_NODE;

        pn_new = getnode(pu, &p2cn->pcn_po_full, nodetype);
        if (pn_new == NULL)
                return ENOENT;
        sfs_new = pn_new->pn_data;

        puffs_newinfo_setcookie(pni, pn_new);
        if (ISADIR(sfs_new))
                puffs_newinfo_setvtype(pni, VDIR);
        else
                puffs_newinfo_setvtype(pni, VREG);

        return 0;
}

int
sysctlfs_node_getattr(struct puffs_usermount *pu, void *opc, struct vattr *va,
        const struct puffs_cred *pcr)
{
        struct puffs_node *pn = opc;
        struct sfsnode *sfs = pn->pn_data;

        memset(va, 0, sizeof(struct vattr));

        if (ISADIR(sfs)) {
                va->va_type = VDIR;
                va->va_mode = 0555;
        } else {
                va->va_type = VREG;
                va->va_mode = fileperms;
        }
        va->va_uid = fileuid;
        va->va_gid = filegid;
        va->va_nlink = getlinks(sfs, &pn->pn_po);
        va->va_fileid = sfs->myid;
        va->va_size = getsize(sfs, &pn->pn_po);
        va->va_gen = 1;
        va->va_rdev = PUFFS_VNOVAL;
        va->va_blocksize = 512;
        va->va_filerev = 1;

        va->va_atime = va->va_mtime = va->va_ctime = va->va_birthtime = fstime;

        return 0;
}

int
sysctlfs_node_setattr(struct puffs_usermount *pu, void *opc,
        const struct vattr *va, const struct puffs_cred *pcr)
{

        /* dummy, but required for write */
        /* XXX: we could return EOPNOTSUPP or something */
        return 0;
}

int
sysctlfs_node_readdir(struct puffs_usermount *pu, void *opc,
        struct dirent *dent, off_t *readoff, size_t *reslen,
        const struct puffs_cred *pcr, int *eofflag,
        off_t *cookies, size_t *ncookies)
{
        struct sysctlnode sn[SFS_NODEPERDIR];
        struct sysctlnode qnode;
        struct puffs_node *pn_dir = opc;
        struct puffs_node *pn_res;
        struct puffs_pathobj po;
        struct sfsnode *sfs_dir = pn_dir->pn_data, *sfs_ent;
        SfsName *sname;
        size_t sl, i;
        enum vtype vt;
        ino_t id;

        *ncookies = 0;

 again:
        if (*readoff == DENT_DOT || *readoff == DENT_DOTDOT) {
                puffs_gendotdent(&dent, sfs_dir->myid, *readoff, reslen);
                (*readoff)++;
                PUFFS_STORE_DCOOKIE(cookies, ncookies, *readoff);
                goto again;
        }

        memset(&qnode, 0, sizeof(qnode));
        sl = SFS_NODEPERDIR * sizeof(struct sysctlnode);
        qnode.sysctl_flags = SYSCTL_VERSION;
        sname = PNPATH(pn_dir);
        (*sname)[PNPLEN(pn_dir)] = CTL_QUERY;

        if (sysctl(*sname, PNPLEN(pn_dir) + 1, sn, &sl,
            &qnode, sizeof(qnode)) == -1)
                return ENOENT;

        po.po_path = sname;
        po.po_len = PNPLEN(pn_dir)+1;

        for (i = DENT_ADJ(*readoff); i < sl / sizeof(struct sysctlnode); i++) {
                if (SYSCTL_TYPE(sn[i].sysctl_flags) == CTLTYPE_NODE)
                        vt = VDIR;
                else
                        vt = VREG;

                /*
                 * check if the node exists.  if so, give it the real
                 * inode number.  otherwise just fake it.
                 */
                (*sname)[PNPLEN(pn_dir)] = sn[i].sysctl_num;
                pn_res = puffs_pn_nodewalk(pu, puffs_path_walkcmp, &po);
                if (pn_res) {
                        sfs_ent = pn_res->pn_data;
                        id = sfs_ent->myid;
                } else {
                        id = nextid++;
                }

                if (!puffs_nextdent(&dent, sn[i].sysctl_name, id,
                    puffs_vtype2dt(vt), reslen))
                        return 0;

                (*readoff)++;
                PUFFS_STORE_DCOOKIE(cookies, ncookies, *readoff);
        }

        *eofflag = 1;
        return 0;
}

int
sysctlfs_node_read(struct puffs_usermount *pu, void *opc, uint8_t *buf,
        off_t offset, size_t *resid, const struct puffs_cred *pcr,
        int ioflag)
{
        char localbuf[SFS_MAXFILE];
        struct puffs_node *pn = opc;
        struct sfsnode *sfs = pn->pn_data;
        size_t sz = sizeof(localbuf);
        int xfer;

        if (ISADIR(sfs))
                return EISDIR;

        getnodedata(sfs, &pn->pn_po, localbuf, &sz);
        if ((ssize_t)sz < offset)
                xfer = 0;
        else
                xfer = MIN(*resid, sz - offset);

        if (xfer <= 0)
                return 0;

        memcpy(buf, localbuf + offset, xfer);
        *resid -= xfer;

        if (*resid && !rflag) {
                buf[xfer] = '\n';
                (*resid)--;
        }

        return 0;
}

int
sysctlfs_node_write(struct puffs_usermount *pu, void *opc, uint8_t *buf,
        off_t offset, size_t *resid, const struct puffs_cred *cred,
        int ioflag)
{
        struct puffs_node *pn = opc;
        struct sfsnode *sfs = pn->pn_data;
        long long ll;
        int i, rv;
        bool b;

        /*
         * I picked the wrong day to ... um, the wrong place to return errors
         */

        /* easy to support, but just unavailable now */
        if (rflag)
                return EOPNOTSUPP;

        if (puffs_cred_isjuggernaut(cred) == 0)
                return EACCES;

        if (ISADIR(sfs))
                return EISDIR;

        if (offset != 0)
                return EINVAL;

        if (ioflag & PUFFS_IO_APPEND)
                return EINVAL;

        switch (SYSCTL_TYPE(sfs->sysctl_flags)) {
        case CTLTYPE_BOOL:
                if (strcasestr((const char *)buf, "true"))
                        b = true;
                else if (strcasestr((const char *)buf, "false"))
                        b = false;
                else
                        return EINVAL;
                rv = sysctl(PNPATH(pn), PNPLEN(pn), NULL, NULL,
                    &b, sizeof(b));
                break;
        case CTLTYPE_INT:
                if (sscanf((const char *)buf, "%d", &i) != 1)
                        return EINVAL;
                rv = sysctl(PNPATH(pn), PNPLEN(pn), NULL, NULL,
                    &i, sizeof(int));
                break;
        case CTLTYPE_QUAD:
                if (sscanf((const char *)buf, "%lld", &ll) != 1)
                        return EINVAL;
                rv =  sysctl(PNPATH(pn), PNPLEN(pn), NULL, NULL,
                    &ll, sizeof(long long));
                break;
        case CTLTYPE_STRING:
                rv = sysctl(PNPATH(pn), PNPLEN(pn), NULL, NULL, buf, *resid);
                break;
        default:
                rv = EINVAL;
                break;
        }

        if (rv)
                return rv;

        *resid = 0;
        return 0;
}