ihateninjas/PrismLauncher
1
0
Fork 0
mirror of https://github.com/PrismLauncher/PrismLauncher synced 2026-04-23 09:05:03 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Remove systeminfo; move getSystemRam into SysInfo.h (#4323)

Browse source
This commit is contained in:
Alexandru Ionut Tripon 2026-01-31 20:24:40 +02:00 committed by GitHub
parent 411b4b0649 283d49ba35
commit fda9e74972
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
22 changed files with 117 additions and 584 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
CMakeLists.txt
View file

@ -483,7 +483,6 @@ option(NBT_USE_ZLIB "Build NBT library with zlib support" OFF)
option(NBT_BUILD_TESTS "Build NBT library tests" OFF) #FIXME: fix unit tests.
add_subdirectory(libraries/libnbtplusplus)
add_subdirectory(libraries/systeminfo) # system information library
add_subdirectory(libraries/launcher) # java based launcher part for Minecraft
add_subdirectory(libraries/javacheck) # java compatibility checker

1
launcher/Application.cpp
View file

@ -126,7 +126,6 @@
#include <LocalPeer.h>
#include <stdlib.h>
#include <sys.h>
#include "SysInfo.h"
#ifdef Q_OS_LINUX

3
launcher/CMakeLists.txt
View file

@ -1336,7 +1336,6 @@ if(${Launcher_USE_PCH})
endif()
target_link_libraries(Launcher_logic
systeminfo
Launcher_murmur2
nbt++
${ZLIB_LIBRARIES}
@ -1459,7 +1458,6 @@ if(Launcher_BUILD_UPDATER)
target_link_libraries(prism_updater_logic
${ZLIB_LIBRARIES}
systeminfo
BuildConfig
Qt${QT_VERSION_MAJOR}::Widgets
Qt${QT_VERSION_MAJOR}::Core
@ -1516,7 +1514,6 @@ if(WIN32 OR (DEFINED Launcher_BUILD_FILELINKER AND Launcher_BUILD_FILELINKER))
endif()
target_link_libraries(filelink_logic
systeminfo
BuildConfig
Qt${QT_VERSION_MAJOR}::Widgets
Qt${QT_VERSION_MAJOR}::Core

113
launcher/SysInfo.cpp
View file

@ -1,20 +1,67 @@
#include <QDebug>
#include <QString>
#include "sys.h"
#ifdef Q_OS_MACOS
#include <sys/sysctl.h>
#endif
// SPDX-License-Identifier: GPL-3.0-only
/*
* Prism Launcher - Minecraft Launcher
* Copyright (C) 2022 r58Playz <r58playz@gmail.com>
* Copyright (C) 2024 timoreo <contact@timoreo.fr>
* Copyright (C) 2024 Trial97 <alexandru.tripon97@gmail.com>
* Copyright (C) 2025 TheKodeToad <TheKodeToad@proton.me>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, version 3.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
* This file incorporates work covered by the following copyright and
* permission notice:
*
* Copyright 2013-2021 MultiMC Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <QFile>
#include <QMap>
#include <QProcess>
#include <QStandardPaths>
#include <QString>
#if defined(Q_OS_WINDOWS)
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#include <windows.h>
#elif defined(Q_OS_LINUX)
#include <sys/sysinfo.h>
#elif defined(Q_OS_FREEBSD) || defined(Q_OS_OPENBSD)
#include <cstdio>
#elif defined(Q_OS_APPLE)
#include <sys/sysctl.h>
#endif
#ifdef Q_OS_MACOS
bool rosettaDetect()
{
int ret = 0;
size_t size = sizeof(ret);
if (sysctlbyname("sysctl.proc_translated", &ret, &size, NULL, 0) == -1) {
if (sysctlbyname("sysctl.proc_translated", &ret, &size, nullptr, 0) == -1) {
return false;
}
return ret == 1;
@ -51,18 +98,58 @@ QString useQTForArch()
return QSysInfo::currentCpuArchitecture();
}
uint64_t getSystemRamMiB()
{
#if defined(Q_OS_WINDOWS)
MEMORYSTATUSEX status;
status.dwLength = sizeof status;
if (GlobalMemoryStatusEx(&status)) {
// transforming bytes -> mib
return (uint64_t)status.ullTotalPhys / 1024 / 1024;
}
#elif defined(Q_OS_LINUX)
struct sysinfo info;
if (sysinfo(&info) != -1) {
// transforming bytes -> mib
return info.totalram / 1024 / 1024;
}
#elif defined(Q_OS_FREEBSD) || defined(Q_OS_OPENBSD)
char buff[512];
FILE* fp = popen("sysctl hw.physmem", "r");
if (fp != nullptr) {
if (fgets(buff, 512, fp) != nullptr) {
std::string str(buff);
uint64_t mem = std::stoull(str.substr(12, std::string::npos));
// transforming kib -> mib
return mem / 1024;
}
}
#elif defined(Q_OS_APPLE)
uint64_t memsize;
size_t memsizesize = sizeof memsize;
if (!sysctlbyname("hw.memsize", &memsize, &memsizesize, nullptr, 0)) {
// transforming bytes -> mib
return memsize / 1024 / 1024;
}
#elif defined(__GNUC__) || defined(__clang__)
#warning getSystemRam not implemented on this platform; detecting amount of installed RAM will not work
#endif
return 0;
}
int suitableMaxMem()
{
float totalRAM = (float)Sys::getSystemRam() / (float)Sys::mebibyte;
int maxMemoryAlloc;
int totalRAM = getSystemRamMiB();
// If totalRAM < 6GB, use (totalRAM / 1.5), else 4GB
if (totalRAM < (4096 * 1.5))
maxMemoryAlloc = (int)(totalRAM / 1.5);
return totalRAM / 1.5;
else
maxMemoryAlloc = 4096;
return maxMemoryAlloc;
return 4096;
}
QString getSupportedJavaArchitecture()

7
launcher/SysInfo.h
View file

@ -1,9 +1,16 @@
#pragma once
#include <cstdint>
#include <QString>
namespace SysInfo {
QString currentSystem();
QString useQTForArch();
QString getSupportedJavaArchitecture();
/**
* @return Total system memory in mebibytes, or 0 if it could not be determined.
*/
uint64_t getSystemRamMiB();
int suitableMaxMem();
} // namespace SysInfo

2
launcher/filelink/FileLink.cpp
View file

@ -34,8 +34,6 @@
#include <DesktopServices.h>
#include <sys.h>
#if defined Q_OS_WIN32
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN

1
launcher/launch/steps/CheckJava.cpp
View file

@ -36,7 +36,6 @@
#include "CheckJava.h"
#include <FileSystem.h>
#include <launch/LaunchTask.h>
#include <sys.h>
#include <QCryptographicHash>
#include <QFileInfo>
#include <QStandardPaths>

4
launcher/modplatform/flame/FlameInstanceCreationTask.cpp
View file

@ -54,7 +54,7 @@
#include "settings/INISettingsObject.h"
#include "sys.h"
#include "SysInfo.h"
#include "tasks/ConcurrentTask.h"
#include "ui/dialogs/BlockedModsDialog.h"
#include "ui/dialogs/CustomMessageBox.h"
@ -423,7 +423,7 @@ bool FlameCreationTask::createInstance()
// only set memory if this is a fresh instance
if (m_instance == nullptr && recommendedRAM > 0) {
const uint64_t sysMiB = Sys::getSystemRam() / Sys::mebibyte;
const uint64_t sysMiB = SysInfo::getSystemRamMiB();
const uint64_t max = sysMiB * 0.9;
if (static_cast<uint64_t>(recommendedRAM) > max) {

1
launcher/ui/pages/global/JavaPage.cpp
View file

@ -55,7 +55,6 @@
#include "java/JavaUtils.h"
#include <FileSystem.h>
#include <sys.h>
#include "Application.h"
#include "settings/SettingsObject.h"

2
launcher/ui/setupwizard/JavaWizardPage.cpp
View file

@ -10,8 +10,6 @@
#include <QToolButton>
#include <QVBoxLayout>
#include <sys.h>
#include "JavaCommon.h"
#include "ui/widgets/JavaWizardWidget.h"

4
launcher/ui/widgets/JavaSettingsWidget.cpp
View file

@ -46,7 +46,7 @@
#include "java/JavaInstallList.h"
#include "java/JavaUtils.h"
#include "settings/Setting.h"
#include "sys.h"
#include "SysInfo.h"
#include "ui/dialogs/CustomMessageBox.h"
#include "ui/dialogs/VersionSelectDialog.h"
#include "ui/java/InstallJavaDialog.h"
@ -285,7 +285,7 @@ void JavaSettingsWidget::onJavaAutodetect()
}
void JavaSettingsWidget::updateThresholds()
{
auto sysMiB = Sys::getSystemRam() / Sys::mebibyte;
auto sysMiB = SysInfo::getSystemRamMiB();
unsigned int maxMem = m_ui->maxMemSpinBox->value();
unsigned int minMem = m_ui->minMemSpinBox->value();

4
launcher/ui/widgets/JavaWizardWidget.cpp
View file

@ -13,8 +13,6 @@
#include <QToolButton>
#include <QVBoxLayout>
#include <sys.h>
#include "DesktopServices.h"
#include "FileSystem.h"
#include "JavaCommon.h"
@ -32,7 +30,7 @@
JavaWizardWidget::JavaWizardWidget(QWidget* parent) : QWidget(parent)
{
m_availableMemory = Sys::getSystemRam() / Sys::mebibyte;
m_availableMemory = SysInfo::getSystemRamMiB();
goodIcon = QIcon::fromTheme("status-good");
yellowIcon = QIcon::fromTheme("status-yellow");

2
launcher/updater/prismupdater/PrismUpdater.cpp
View file

@ -40,8 +40,6 @@
#include <QProgressDialog>
#include <memory>
#include <sys.h>
#if defined Q_OS_WIN32
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN

8
libraries/README.md
View file

@ -89,11 +89,13 @@ Color functions extracted from [KGuiAddons](https://inqlude.org/libraries/kguiad
Available either under LGPL version 2.1 or later.
## systeminfo
## tomlplusplus
A Prism Launcher-specific library for probing system information.
A TOML language parser. Used by Forge 1.14+ to store mod metadata.
Apache 2.0
See [github repo](https://github.com/marzer/tomlplusplus).
Licenced under the MIT licence.
## qdcss

27
libraries/systeminfo/CMakeLists.txt
View file

@ -1,27 +0,0 @@
project(systeminfo)
if(Launcher_QT_VERSION_MAJOR EQUAL 6)
find_package(Qt6 COMPONENTS Core REQUIRED)
endif()
set(systeminfo_SOURCES
include/sys.h
include/distroutils.h
src/distroutils.cpp
)
if (WIN32)
list(APPEND systeminfo_SOURCES src/sys_win32.cpp)
elseif (UNIX)
if(APPLE)
list(APPEND systeminfo_SOURCES src/sys_apple.cpp)
else()
list(APPEND systeminfo_SOURCES src/sys_unix.cpp)
endif()
endif()
add_library(systeminfo STATIC ${systeminfo_SOURCES})
target_link_libraries(systeminfo Qt${QT_VERSION_MAJOR}::Core Qt${QT_VERSION_MAJOR}::Gui Qt${QT_VERSION_MAJOR}::Network ${systeminfo_LIBS})
target_include_directories(systeminfo PUBLIC include)
ecm_add_test(src/sys_test.cpp LINK_LIBRARIES systeminfo Qt${QT_VERSION_MAJOR}::Test TEST_NAME sys)

22
libraries/systeminfo/include/distroutils.h
View file

@ -1,22 +0,0 @@
#include <QString>
#include "sys.h"
namespace Sys {
struct LsbInfo {
QString distributor;
QString version;
QString description;
QString codename;
};
bool main_lsb_info(LsbInfo& out);
bool fallback_lsb_info(Sys::LsbInfo& out);
void lsb_postprocess(Sys::LsbInfo& lsb, Sys::DistributionInfo& out);
Sys::DistributionInfo read_lsb_release();
QString _extract_distribution(const QString& x);
QString _extract_version(const QString& x);
Sys::DistributionInfo read_legacy_release();
Sys::DistributionInfo read_os_release();
} // namespace Sys

45
libraries/systeminfo/include/sys.h
View file

@ -1,45 +0,0 @@
#pragma once
#include <QString>
namespace Sys {
const uint64_t mebibyte = 1024ull * 1024ull;
enum class KernelType { Undetermined, Windows, Darwin, Linux };
struct KernelInfo {
QString kernelName;
QString kernelVersion;
KernelType kernelType = KernelType::Undetermined;
int kernelMajor = 0;
int kernelMinor = 0;
int kernelPatch = 0;
bool isCursed = false;
};
KernelInfo getKernelInfo();
struct DistributionInfo {
DistributionInfo operator+(const DistributionInfo& rhs) const
{
DistributionInfo out;
if (!distributionName.isEmpty()) {
out.distributionName = distributionName;
} else {
out.distributionName = rhs.distributionName;
}
if (!distributionVersion.isEmpty()) {
out.distributionVersion = distributionVersion;
} else {
out.distributionVersion = rhs.distributionVersion;
}
return out;
}
QString distributionName;
QString distributionVersion;
};
DistributionInfo getDistributionInfo();
uint64_t getSystemRam();
} // namespace Sys

242
libraries/systeminfo/src/distroutils.cpp
View file

@ -1,242 +0,0 @@
/*
Code has been taken from https://github.com/natefoo/lionshead and loosely
translated to C++ laced with Qt.
MIT License
Copyright (c) 2017 Nate Coraor
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#include "distroutils.h"
#include <QDebug>
#include <QDir>
#include <QFile>
#include <QMap>
#include <QProcess>
#include <QRegularExpression>
#include <QSettings>
#include <QStringList>
#include <functional>
static const QRegularExpression s_distoSplitRegex("\\s+");
Sys::DistributionInfo Sys::read_os_release()
{
Sys::DistributionInfo out;
QStringList files = { "/etc/os-release", "/usr/lib/os-release" };
QString name;
QString version;
for (auto& file : files) {
if (!QFile::exists(file)) {
continue;
}
QSettings settings(file, QSettings::IniFormat);
if (settings.contains("ID")) {
name = settings.value("ID").toString().toLower();
} else if (settings.contains("NAME")) {
name = settings.value("NAME").toString().toLower();
} else {
continue;
}
if (settings.contains("VERSION_ID")) {
version = settings.value("VERSION_ID").toString().toLower();
} else if (settings.contains("VERSION")) {
version = settings.value("VERSION").toString().toLower();
}
break;
}
if (name.isEmpty()) {
return out;
}
out.distributionName = name;
out.distributionVersion = version;
return out;
}
bool Sys::main_lsb_info(Sys::LsbInfo& out)
{
int status = 0;
QProcess lsbProcess;
QStringList arguments;
arguments << "-a";
lsbProcess.start("lsb_release", arguments);
lsbProcess.waitForFinished();
status = lsbProcess.exitStatus();
QString output = lsbProcess.readAllStandardOutput();
qDebug() << output;
lsbProcess.close();
if (status == 0) {
auto lines = output.split('\n');
for (auto line : lines) {
int index = line.indexOf(':');
auto key = line.left(index).trimmed();
auto value = line.mid(index + 1).toLower().trimmed();
if (key == "Distributor ID")
out.distributor = value;
else if (key == "Release")
out.version = value;
else if (key == "Description")
out.description = value;
else if (key == "Codename")
out.codename = value;
}
return !out.distributor.isEmpty();
}
return false;
}
bool Sys::fallback_lsb_info(Sys::LsbInfo& out)
{
// running lsb_release failed, try to read the file instead
// /etc/lsb-release format, if the file even exists, is non-standard.
// Only the `lsb_release` command is specified by LSB. Nonetheless, some
// distributions install an /etc/lsb-release as part of the base
// distribution, but `lsb_release` remains optional.
QString file = "/etc/lsb-release";
if (QFile::exists(file)) {
QSettings settings(file, QSettings::IniFormat);
if (settings.contains("DISTRIB_ID")) {
out.distributor = settings.value("DISTRIB_ID").toString().toLower();
}
if (settings.contains("DISTRIB_RELEASE")) {
out.version = settings.value("DISTRIB_RELEASE").toString().toLower();
}
return !out.distributor.isEmpty();
}
return false;
}
void Sys::lsb_postprocess(Sys::LsbInfo& lsb, Sys::DistributionInfo& out)
{
QString dist = lsb.distributor;
QString vers = lsb.version;
if (dist.startsWith("redhatenterprise")) {
dist = "rhel";
} else if (dist == "archlinux") {
dist = "arch";
} else if (dist.startsWith("suse")) {
if (lsb.description.startsWith("opensuse")) {
dist = "opensuse";
} else if (lsb.description.startsWith("suse linux enterprise")) {
dist = "sles";
}
} else if (dist == "debian" and vers == "testing") {
vers = lsb.codename;
} else {
// ubuntu, debian, gentoo, scientific, slackware, ... ?
auto parts = dist.split(s_distoSplitRegex, Qt::SkipEmptyParts);
if (parts.size()) {
dist = parts[0];
}
}
if (!dist.isEmpty()) {
out.distributionName = dist;
out.distributionVersion = vers;
}
}
Sys::DistributionInfo Sys::read_lsb_release()
{
LsbInfo lsb;
if (!main_lsb_info(lsb)) {
if (!fallback_lsb_info(lsb)) {
return Sys::DistributionInfo();
}
}
Sys::DistributionInfo out;
lsb_postprocess(lsb, out);
return out;
}
QString Sys::_extract_distribution(const QString& x)
{
QString release = x.toLower();
if (release.startsWith("red hat enterprise")) {
return "rhel";
}
if (release.startsWith("suse linux enterprise")) {
return "sles";
}
QStringList list = release.split(s_distoSplitRegex, Qt::SkipEmptyParts);
if (list.size()) {
return list[0];
}
return QString();
}
QString Sys::_extract_version(const QString& x)
{
static const QRegularExpression s_versionishString(QRegularExpression::anchoredPattern("\\d+(?:\\.\\d+)*$"));
QStringList list = x.split(s_distoSplitRegex, Qt::SkipEmptyParts);
for (int i = list.size() - 1; i >= 0; --i) {
QString chunk = list[i];
if (s_versionishString.match(chunk).hasMatch()) {
return chunk;
}
}
return QString();
}
Sys::DistributionInfo Sys::read_legacy_release()
{
struct checkEntry {
QString file;
std::function<QString(const QString&)> extract_distro;
std::function<QString(const QString&)> extract_version;
};
QList<checkEntry> checks = {
{ "/etc/arch-release", [](const QString&) { return "arch"; }, [](const QString&) { return "rolling"; } },
{ "/etc/slackware-version", &Sys::_extract_distribution, &Sys::_extract_version },
{ QString(), &Sys::_extract_distribution, &Sys::_extract_version },
{ "/etc/debian_version", [](const QString&) { return "debian"; }, [](const QString& x) { return x; } },
};
for (auto& check : checks) {
QStringList files;
if (check.file.isNull()) {
QDir etcDir("/etc");
etcDir.setNameFilters({ "*-release" });
etcDir.setFilter(QDir::Files | QDir::NoDot | QDir::NoDotDot | QDir::Readable | QDir::Hidden);
files = etcDir.entryList();
} else {
files.append(check.file);
}
for (auto file : files) {
QFile relfile(file);
if (!relfile.open(QIODevice::ReadOnly | QIODevice::Text))
continue;
QString contents = QString::fromUtf8(relfile.readLine()).trimmed();
QString dist = check.extract_distro(contents);
QString vers = check.extract_version(contents);
if (!dist.isEmpty()) {
Sys::DistributionInfo out;
out.distributionName = dist;
out.distributionVersion = vers;
return out;
}
}
}
return Sys::DistributionInfo();
}

57
libraries/systeminfo/src/sys_apple.cpp
View file

@ -1,57 +0,0 @@
#include "sys.h"
#include <sys/utsname.h>
#include <QDebug>
#include <QString>
#include <QStringList>
Sys::KernelInfo Sys::getKernelInfo()
{
Sys::KernelInfo out;
struct utsname buf;
uname(&buf);
out.kernelType = KernelType::Darwin;
out.kernelName = buf.sysname;
QString release = out.kernelVersion = buf.release;
// TODO: figure out how to detect cursed-ness (macOS emulated on linux via mad hacks and so on)
out.isCursed = false;
out.kernelMajor = 0;
out.kernelMinor = 0;
out.kernelPatch = 0;
auto sections = release.split('-');
if (sections.size() >= 1) {
auto versionParts = sections[0].split('.');
if (versionParts.size() >= 3) {
out.kernelMajor = versionParts[0].toInt();
out.kernelMinor = versionParts[1].toInt();
out.kernelPatch = versionParts[2].toInt();
} else {
qWarning() << "Not enough version numbers in " << sections[0] << " found " << versionParts.size();
}
} else {
qWarning() << "Not enough '-' sections in " << release << " found " << sections.size();
}
return out;
}
#include <sys/sysctl.h>
uint64_t Sys::getSystemRam()
{
uint64_t memsize;
size_t memsizesize = sizeof(memsize);
if (!sysctlbyname("hw.memsize", &memsize, &memsizesize, NULL, 0)) {
return memsize;
} else {
return 0;
}
}
Sys::DistributionInfo Sys::getDistributionInfo()
{
DistributionInfo result;
return result;
}

28
libraries/systeminfo/src/sys_test.cpp
View file

@ -1,28 +0,0 @@
#include <QTest>
#include <sys.h>
class SysTest : public QObject {
Q_OBJECT
private slots:
void test_kernelNotNull()
{
auto kinfo = Sys::getKernelInfo();
QVERIFY(!kinfo.kernelName.isEmpty());
QVERIFY(kinfo.kernelVersion != "0.0");
}
/*
void test_systemDistroNotNull()
{
auto kinfo = Sys::getDistributionInfo();
QVERIFY(!kinfo.distributionName.isEmpty());
QVERIFY(!kinfo.distributionVersion.isEmpty());
qDebug() << "Distro: " << kinfo.distributionName << "version" << kinfo.distributionVersion;
}
*/
};
QTEST_GUILESS_MAIN(SysTest)
#include "sys_test.moc"

93
libraries/systeminfo/src/sys_unix.cpp
View file

@ -1,93 +0,0 @@
#include "sys.h"
#include "distroutils.h"
#include <sys/utsname.h>
#include <fstream>
#include <limits>
#include <QDebug>
#include <QString>
#include <QStringList>
Sys::KernelInfo Sys::getKernelInfo()
{
Sys::KernelInfo out;
struct utsname buf;
uname(&buf);
// NOTE: we assume linux here. this needs further elaboration
out.kernelType = KernelType::Linux;
out.kernelName = buf.sysname;
QString release = out.kernelVersion = buf.release;
// linux binary running on WSL is cursed.
out.isCursed = release.contains("WSL", Qt::CaseInsensitive) || release.contains("Microsoft", Qt::CaseInsensitive);
out.kernelMajor = 0;
out.kernelMinor = 0;
out.kernelPatch = 0;
auto sections = release.split('-');
if (sections.size() >= 1) {
auto versionParts = sections[0].split('.');
if (versionParts.size() >= 3) {
out.kernelMajor = versionParts[0].toInt();
out.kernelMinor = versionParts[1].toInt();
out.kernelPatch = versionParts[2].toInt();
} else {
qWarning() << "Not enough version numbers in " << sections[0] << " found " << versionParts.size();
}
} else {
qWarning() << "Not enough '-' sections in " << release << " found " << sections.size();
}
return out;
}
uint64_t Sys::getSystemRam()
{
std::string token;
#ifdef Q_OS_LINUX
std::ifstream file("/proc/meminfo");
while (file >> token) {
if (token == "MemTotal:") {
uint64_t mem;
if (file >> mem) {
return mem * 1024ull;
} else {
return 0;
}
}
// ignore rest of the line
file.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
}
#elif defined(Q_OS_FREEBSD)
char buff[512];
FILE* fp = popen("sysctl hw.physmem", "r");
if (fp != NULL) {
while (fgets(buff, 512, fp) != NULL) {
std::string str(buff);
uint64_t mem = std::stoull(str.substr(12, std::string::npos));
return mem * 1024ull;
}
}
#endif
return 0; // nothing found
}
Sys::DistributionInfo Sys::getDistributionInfo()
{
DistributionInfo systemd_info = read_os_release();
DistributionInfo lsb_info = read_lsb_release();
DistributionInfo legacy_info = read_legacy_release();
DistributionInfo result = systemd_info + lsb_info + legacy_info;
if (result.distributionName.isNull()) {
result.distributionName = "unknown";
}
if (result.distributionVersion.isNull()) {
if (result.distributionName == "arch") {
result.distributionVersion = "rolling";
} else {
result.distributionVersion = "unknown";
}
}
return result;
}

34
libraries/systeminfo/src/sys_win32.cpp
View file

@ -1,34 +0,0 @@
#include "sys.h"
#include <windows.h>
Sys::KernelInfo Sys::getKernelInfo()
{
Sys::KernelInfo out;
out.kernelType = KernelType::Windows;
out.kernelName = "Windows";
OSVERSIONINFOW osvi;
ZeroMemory(&osvi, sizeof(OSVERSIONINFOW));
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
GetVersionExW(&osvi);
out.kernelVersion = QString("%1.%2").arg(osvi.dwMajorVersion).arg(osvi.dwMinorVersion);
out.kernelMajor = osvi.dwMajorVersion;
out.kernelMinor = osvi.dwMinorVersion;
out.kernelPatch = osvi.dwBuildNumber;
return out;
}
uint64_t Sys::getSystemRam()
{
MEMORYSTATUSEX status;
status.dwLength = sizeof(status);
GlobalMemoryStatusEx(&status);
// bytes
return (uint64_t)status.ullTotalPhys;
}
Sys::DistributionInfo Sys::getDistributionInfo()
{
DistributionInfo result;
return result;
}