File indexing completed on 2024-05-12 17:00:15

 /*
     SPDX-FileCopyrightText: 2020 David Redondo <kde@david-redondo.de>
 
     SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
 */
 
 #include "freebsdbackend.h"
 
 #include <systemstats/SensorObject.h>
 #include <systemstats/SensorProperty.h>
 #include <systemstats/SysctlSensor.h>
 
 #include <fcntl.h>
 #include <sys/types.h>
 #include <sys/sysctl.h>
 #include <unistd.h>
 
 template <typename T>
 bool readSysctl(const char *name, T *buffer, size_t size = sizeof(T))
 {
     return sysctlbyname(name, buffer, &size, nullptr, 0) != -1;
 }
 
 FreeBsdMemoryBackend::FreeBsdMemoryBackend(KSysGuard::SensorContainer* container)
     : MemoryBackend(container)
     , m_pageSize(getpagesize())
     , m_kd(nullptr)
 {
     char errorBuffer[_POSIX2_LINE_MAX];
     // Get a descriptor for accesing kernel memory which we need for querying swap info. /dev/null
     // indicates that we do not want to directly access kernel memory.
     m_kd = kvm_openfiles(nullptr, "/dev/null", nullptr, O_RDONLY, errorBuffer);
     if (!m_kd) {
         qWarning() << errorBuffer;
     }
 }
 
 void FreeBsdMemoryBackend::makeSensors()
 {
     auto totalSensor = new KSysGuard::SysctlSensor<unsigned long long>(QStringLiteral("total"), "hw.physmem",  m_physicalObject);
     m_total = totalSensor;
     m_sysctlSensors.append(totalSensor);
 
     m_used = new KSysGuard::SensorProperty(QStringLiteral("used"), m_physicalObject);
     m_application = new KSysGuard::SensorProperty(QStringLiteral("application"), m_physicalObject);
 
     auto capturedPagesToBytes = [this] (auto pages) {return pagesToBytes(pages);};
 
     auto freeSensor = new KSysGuard::SysctlSensor<uint32_t>(QStringLiteral("free"), "vm.stats.vm.v_free_count", m_physicalObject);
     freeSensor->setConversionFunction(capturedPagesToBytes);
     m_free = freeSensor;
     m_sysctlSensors.push_back(freeSensor);
 
     auto cacheSensor = new KSysGuard::SysctlSensor<uint32_t>(QStringLiteral("cache"),"vm.stats.vm.v_cache_count", m_physicalObject);
     cacheSensor->setConversionFunction(capturedPagesToBytes);
     m_cache = cacheSensor;
     m_sysctlSensors.push_back(cacheSensor);
 
     auto bufferSensor = new KSysGuard::SysctlSensor<uint64_t>(QStringLiteral("buffer"), "vfs.bufspace", m_physicalObject);
     m_buffer = bufferSensor;
     m_sysctlSensors.push_back(bufferSensor);
 
     m_swapTotal = new KSysGuard::SensorProperty(QStringLiteral("total"), m_swapObject);
     m_swapUsed = new KSysGuard::SensorProperty(QStringLiteral("used"), m_swapObject);
     m_swapFree = new KSysGuard::SensorProperty(QStringLiteral("free"), m_swapObject);
 
 }
 
 unsigned long long FreeBsdMemoryBackend::pagesToBytes(uint32_t pages)
 {
     return m_pageSize * pages;
 }
 
 void FreeBsdMemoryBackend::update()
 {
 
     kvm_swap swapInfo;
     // Calling it with just one swapInfo gets us the totals, passing 0 as the last argument is mandatory
     if (m_swapObject->isSubscribed() && m_kd && (kvm_getswapinfo(m_kd, &swapInfo, 1, 0) != -1)) {
         m_swapTotal->setValue(pagesToBytes(swapInfo.ksw_total));
         m_swapUsed->setValue(pagesToBytes(swapInfo.ksw_used));
         m_swapFree->setValue(pagesToBytes(swapInfo.ksw_total - swapInfo.ksw_used));
     }
 
     for (const auto sysctlSensor : m_sysctlSensors) {
         sysctlSensor->update();
     }
 
     m_used->setValue(m_total->value().toULongLong() - m_free->value().toULongLong());
 
     uint32_t activePages = 0;
     uint32_t inactivePages = 0;
     if (readSysctl("vm.stats.vm.v_active_count", &activePages) && readSysctl("vm.stats.vm.v_inactive_count", &inactivePages)) {
         m_application->setValue(pagesToBytes(activePages + inactivePages));
     }
 }