sysctl.hpp

Go to the documentation of this file.

 
#ifndef _POWERDXX_SYS_SYSCTL_HPP_
#define _POWERDXX_SYS_SYSCTL_HPP_
 
#include "error.hpp"       /* sys::sc_error */
 
#include <memory>          /* std::unique_ptr */
 
#include <cassert>         /* assert() */
 
#include <sys/types.h>     /* sysctl() */
#include <sys/sysctl.h>    /* sysctl() */
 
namespace sys {
 
namespace ctl {
 
struct error {};
 
typedef int mib_t;
 
inline void sysctl_raw(mib_t const * name, u_int const namelen,
                       void * const oldp, size_t * const oldlenp,
                       void const * const newp, size_t const newlen) {
    if (sysctl(name, namelen, oldp, oldlenp, newp, newlen) == -1) {
        throw sc_error<error>{errno};
    }
}
 
template <size_t MibDepth>
void sysctl_get(mib_t const (& mib)[MibDepth], void * const oldp, size_t & oldlen) {
    sysctl_raw(mib, MibDepth, oldp, &oldlen, nullptr, 0);
}
 
template <size_t MibDepth>
void sysctl_set(mib_t const (& mib)[MibDepth], void const * const newp,
                size_t const newlen) {
    sysctl_raw(mib, MibDepth, nullptr, nullptr, newp, newlen);
}
 
template <size_t MibDepth>
class Sysctl {
    private:
    mib_t mib[MibDepth];
 
    public:
    template <typename... Tail>
    constexpr Sysctl(mib_t const head, Tail const... tail) noexcept :
        mib{head, tail...} {
        static_assert(MibDepth == sizeof...(Tail) + 1,
                      "MIB depth mismatch");
    }
 
    size_t size() const
    {
        size_t len = 0;
        sysctl_get(this->mib, nullptr, len);
        return len;
    }
 
    void get(void * const buf, size_t const bufsize) const {
        auto len = bufsize;
        sysctl_get(this->mib, buf, len);
    }
 
    template <typename T>
    void get(T & value) const {
        get(&value, sizeof(T));
    }
 
    template <typename T>
    std::unique_ptr<T[]> get() const {
        auto const len = size();
        auto result = std::unique_ptr<T[]>(new T[len / sizeof(T)]);
        get(result.get(), len);
        return result;
    }
 
    void set(void const * const buf, size_t const bufsize) {
        sysctl_set(this->mib, buf, bufsize);
    }
 
    template <typename T>
    void set(T const & value) {
        set(&value, sizeof(T));
    }
};
 
template <>
class Sysctl<0> {
    private:
    mib_t mib[CTL_MAXNAME];
 
    size_t depth;
 
    public:
    constexpr Sysctl() : mib{}, depth{0} {}
 
    Sysctl(char const * const name) : depth{CTL_MAXNAME} {
        if (sysctlnametomib(name, this->mib, &this->depth) == -1) {
            throw sc_error<error>{errno};
        }
        assert(this->depth <= CTL_MAXNAME && "MIB depth exceeds limit");
    }
 
    size_t size() const
    {
        size_t len = 0;
        sysctl_raw(this->mib, this->depth, nullptr, &len, nullptr, 0);
        return len;
    }
 
    void get(void * const buf, size_t const bufsize) const {
        auto len = bufsize;
        sysctl_raw(this->mib, this->depth, buf, &len, nullptr, 0);
    }
 
    template <typename T>
    void get(T & value) const {
        get(&value, sizeof(T));
    }
 
    template <typename T>
    std::unique_ptr<T[]> get() const {
        size_t const len = size();
        auto result = std::unique_ptr<T[]>(new T[len / sizeof(T)]);
        get(result.get(), len);
        return result;
    }
 
    void set(void const * const buf, size_t const bufsize) {
        sysctl_raw(this->mib, this->depth, nullptr, nullptr, buf, bufsize);
    }
 
    template <typename T>
    void set(T const & value) {
        set(&value, sizeof(T));
    }
};
 
template <typename ... ArgTs>
Sysctl(mib_t const, ArgTs const ...) -> Sysctl<(1 + sizeof...(ArgTs))>;
 
Sysctl(char const * const) -> Sysctl<0>;
 
Sysctl() -> Sysctl<0>;
 
template <typename T, class SysctlT>
class Sync {
    private:
    SysctlT sysctl;
 
    public:
    constexpr Sync() {}
 
    constexpr Sync(SysctlT const & sysctl) noexcept : sysctl{sysctl} {}
 
    Sync & operator =(T const & value) {
        this->sysctl.set(value);
        return *this;
    }
 
    operator T () const {
        T value;
        this->sysctl.get(value);
        return value;
    }
};
 
template <typename T, size_t MibDepth = 0>
using SysctlSync = Sync<T, Sysctl<MibDepth>>;
 
template <typename T, class SysctlT>
class Once {
    private:
    T value;
 
    public:
    Once(T const & value, SysctlT const & sysctl) noexcept {
        try {
            sysctl.get(this->value);
        } catch (sc_error<error>) {
            this->value = value;
        }
    }
 
    operator T const &() const {
        return this->value;
    }
};
 
template <typename T, size_t MibDepth = 0>
using SysctlOnce = Once<T, Sysctl<MibDepth>>;
 
} /* namespace ctl */
} /* namespace sys */
 
#endif /* _POWERDXX_SYS_SYSCTL_HPP_ */