^ that should probably be 2-clause...

doesn't that also need #if HAVE_PROCSTAT?

this makes the rest of the function as unreachable code, and compilers might warn about that

Are there situations where you would end up here? I mean, libprocstat is in base, since 9.0, so it is unlikely to be gone at any point.

I absolutely have Opinions on C++ style that apply here, so I'm going to talk to Tobias elsewhere.

In order to simplify cleanup, I'd use a RAII class as well:

/** @brief Wrapper around procstat_open_sysctl()
 * 
 * Hangs on to a procstat instance for its friend classes, and closes
 * it on destruction. Cast to bool to check for success.
 */
struct ProcStat
{
    ProcStat()
    {
        pstat = procstat_open_sysctl();
    }
    ~ProcStat()
    {
        procstat_close(pstat);
    }
    operator bool() const
    {
        return pstat;
    }
    
    struct procstat *pstat;
};

Lines 37-42 become ProcStat p; if (!p) return rc;, but more importantly you can drop cleanup from other return paths since the destructor handles it.

Similarly, you could

struct ProcStatProcesses
{
public:
    ProcStatProcesses(ProcStat& pstat) : parent(pstat)
    {
        procs = procstat_getprocs(parent.pstat, KERN_PROC_PROC, 0, &proc_count);
    }
    ~ProcStatProcesses()
    {
        if (procs)
        {
            procstat_freeprocs(parent.pstat, procs);
        }
    }
    operator bool() const
    {
        return procs && proc_count > 0;
    }

    ProcStat& parent;
    unsigned int proc_count;
    struct kinfo_proc *procs;
}

I'd probably also write an iterator for it, returning KProcessInfo from operator*(), so that the magic is hidden away in small classes and the overall algorithm becomes a very short bit of text. You might call that over-engineered, since there's nothing wrong with the code as-written.