From 0251f35c93e3f0e0a6853a50fb5bd82c1b9e4187 Mon Sep 17 00:00:00 2001 From: saturneric Date: Mon, 6 Nov 2023 17:17:47 +0800 Subject: refactor: clean up core's codes --- src/core/function/basic/SingletonStorage.cpp | 118 +++++++++++++++++++++++++++ 1 file changed, 118 insertions(+) create mode 100644 src/core/function/basic/SingletonStorage.cpp (limited to 'src/core/function/basic/SingletonStorage.cpp') diff --git a/src/core/function/basic/SingletonStorage.cpp b/src/core/function/basic/SingletonStorage.cpp new file mode 100644 index 00000000..567d3572 --- /dev/null +++ b/src/core/function/basic/SingletonStorage.cpp @@ -0,0 +1,118 @@ +/** + * Copyright (C) 2021 Saturneric + * + * This file is part of GpgFrontend. + * + * GpgFrontend 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, either version 3 of the License, or + * (at your option) any later version. + * + * GpgFrontend 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 GpgFrontend. If not, see . + * + * The initial version of the source code is inherited from + * the gpg4usb project, which is under GPL-3.0-or-later. + * + * All the source code of GpgFrontend was modified and released by + * Saturneric starting on May 12, 2021. + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#include "SingletonStorage.h" + +#include + +#include "core/function/basic/ChannelObject.h" + +namespace GpgFrontend { + +class SingletonStorage::Impl { + public: + void ReleaseChannel(int channel) { + decltype(instances_map_.end()) ins_it; + { + std::shared_lock lock(instances_mutex_); + ins_it = instances_map_.find(channel); + } + if (ins_it != instances_map_.end()) instances_map_.erase(ins_it); + } + + auto FindObjectInChannel(int channel) -> GpgFrontend::ChannelObject* { + // read instances_map_ + decltype(instances_map_.end()) ins_it; + { + std::shared_lock lock(instances_mutex_); + ins_it = instances_map_.find(channel); + if (ins_it == instances_map_.end()) { + return nullptr; + } + return ins_it->second.get(); + } + } + + auto GetAllChannelId() -> std::vector { + std::vector channels; + channels.reserve(instances_map_.size()); + for (const auto& [key, value] : instances_map_) { + channels.push_back(key); + } + return channels; + } + + auto SetObjectInChannel(int channel, std::unique_ptr p_obj) + -> GpgFrontend::ChannelObject* { + { + SPDLOG_TRACE("set channel: {} instance address: {}", channel, + static_cast(&instances_map_)); + + assert(p_obj != nullptr); + if (p_obj == nullptr) return nullptr; + + auto* raw_obj = p_obj.get(); + p_obj->SetChannel(channel); + { + std::unique_lock lock(instances_mutex_); + instances_map_.insert({channel, std::move(p_obj)}); + } + return raw_obj; + } + } + + private: + std::shared_mutex instances_mutex_; ///< mutex for _instances_map + std::map> + instances_map_; ///< map of singleton instances +}; + +SingletonStorage::SingletonStorage() noexcept : p_(std::make_unique()) {} + +SingletonStorage::~SingletonStorage() = default; + +void SingletonStorage::ReleaseChannel(int channel) { + p_->ReleaseChannel(channel); +} + +auto SingletonStorage::FindObjectInChannel(int channel) + -> GpgFrontend::ChannelObject* { + return p_->FindObjectInChannel(channel); +} + +auto SingletonStorage::GetAllChannelId() -> std::vector { + return p_->GetAllChannelId(); +} + +auto SingletonStorage::SetObjectInChannel(int channel, + std::unique_ptr p_obj) + -> GpgFrontend::ChannelObject* { + return p_->SetObjectInChannel(channel, std::move(p_obj)); +} + +}; // namespace GpgFrontend \ No newline at end of file -- cgit v1.2.3 From ae2717c3787a34a2c60d6aeef2d0b8bb8e551a1e Mon Sep 17 00:00:00 2001 From: saturneric Date: Sun, 3 Dec 2023 04:27:47 -0800 Subject: feat: improve memory security of function framework --- src/core/function/basic/SingletonStorage.cpp | 22 ++++++++++++++-------- 1 file changed, 14 insertions(+), 8 deletions(-) (limited to 'src/core/function/basic/SingletonStorage.cpp') diff --git a/src/core/function/basic/SingletonStorage.cpp b/src/core/function/basic/SingletonStorage.cpp index 567d3572..a067090e 100644 --- a/src/core/function/basic/SingletonStorage.cpp +++ b/src/core/function/basic/SingletonStorage.cpp @@ -52,6 +52,7 @@ class SingletonStorage::Impl { std::shared_lock lock(instances_mutex_); ins_it = instances_map_.find(channel); if (ins_it == instances_map_.end()) { + SPDLOG_TRACE("cannot find channel object, channel :{}", channel); return nullptr; } return ins_it->second.get(); @@ -67,28 +68,34 @@ class SingletonStorage::Impl { return channels; } - auto SetObjectInChannel(int channel, std::unique_ptr p_obj) + auto SetObjectInChannel(int channel, ChannelObjectPtr p_obj) -> GpgFrontend::ChannelObject* { { - SPDLOG_TRACE("set channel: {} instance address: {}", channel, - static_cast(&instances_map_)); + SPDLOG_TRACE("set channel: {}, channel object address: {}", channel, + static_cast(p_obj.get())); assert(p_obj != nullptr); - if (p_obj == nullptr) return nullptr; + if (p_obj == nullptr) { + return nullptr; + } - auto* raw_obj = p_obj.get(); p_obj->SetChannel(channel); + auto* raw_obj = p_obj.get(); { std::unique_lock lock(instances_mutex_); instances_map_.insert({channel, std::move(p_obj)}); } + + SPDLOG_TRACE( + "set channel: {} success, current channel object address: {}", + channel, static_cast(raw_obj)); return raw_obj; } } private: std::shared_mutex instances_mutex_; ///< mutex for _instances_map - std::map> + std::map instances_map_; ///< map of singleton instances }; @@ -109,8 +116,7 @@ auto SingletonStorage::GetAllChannelId() -> std::vector { return p_->GetAllChannelId(); } -auto SingletonStorage::SetObjectInChannel(int channel, - std::unique_ptr p_obj) +auto SingletonStorage::SetObjectInChannel(int channel, ChannelObjectPtr p_obj) -> GpgFrontend::ChannelObject* { return p_->SetObjectInChannel(channel, std::move(p_obj)); } -- cgit v1.2.3 From be376458b1ddaccac41022765bea96126707c421 Mon Sep 17 00:00:00 2001 From: saturneric Date: Wed, 13 Dec 2023 18:10:37 +0800 Subject: fix: add some logs in setting channel object --- src/core/function/basic/SingletonStorage.cpp | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) (limited to 'src/core/function/basic/SingletonStorage.cpp') diff --git a/src/core/function/basic/SingletonStorage.cpp b/src/core/function/basic/SingletonStorage.cpp index a067090e..2497cec4 100644 --- a/src/core/function/basic/SingletonStorage.cpp +++ b/src/core/function/basic/SingletonStorage.cpp @@ -71,7 +71,7 @@ class SingletonStorage::Impl { auto SetObjectInChannel(int channel, ChannelObjectPtr p_obj) -> GpgFrontend::ChannelObject* { { - SPDLOG_TRACE("set channel: {}, channel object address: {}", channel, + SPDLOG_TRACE("set channel object in channel: {}, address: {}", channel, static_cast(p_obj.get())); assert(p_obj != nullptr); @@ -81,10 +81,13 @@ class SingletonStorage::Impl { p_obj->SetChannel(channel); auto* raw_obj = p_obj.get(); - { - std::unique_lock lock(instances_mutex_); - instances_map_.insert({channel, std::move(p_obj)}); - } + + SPDLOG_TRACE( + "register channel object to instances map, " + "channel: {}, address: {}", + channel, static_cast(p_obj.get())); + std::unique_lock lock(instances_mutex_); + instances_map_.insert({channel, std::move(p_obj)}); SPDLOG_TRACE( "set channel: {} success, current channel object address: {}", -- cgit v1.2.3 From d74765b42206a83c0ade8617e8100794eb169f37 Mon Sep 17 00:00:00 2001 From: saturneric Date: Wed, 13 Dec 2023 20:02:24 +0800 Subject: feat: mimalloc support valgrind --- src/core/function/basic/SingletonStorage.cpp | 2 ++ 1 file changed, 2 insertions(+) (limited to 'src/core/function/basic/SingletonStorage.cpp') diff --git a/src/core/function/basic/SingletonStorage.cpp b/src/core/function/basic/SingletonStorage.cpp index 2497cec4..211a51b3 100644 --- a/src/core/function/basic/SingletonStorage.cpp +++ b/src/core/function/basic/SingletonStorage.cpp @@ -76,6 +76,8 @@ class SingletonStorage::Impl { assert(p_obj != nullptr); if (p_obj == nullptr) { + SPDLOG_ERROR("cannot set a nullptr as a channel obejct of channel: {}", + channel); return nullptr; } -- cgit v1.2.3 From 79783510863445b5068eef092a1f2650733a5b02 Mon Sep 17 00:00:00 2001 From: saturneric Date: Thu, 14 Dec 2023 16:58:53 +0800 Subject: fix: slove some memory issues --- src/core/function/basic/SingletonStorage.cpp | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) (limited to 'src/core/function/basic/SingletonStorage.cpp') diff --git a/src/core/function/basic/SingletonStorage.cpp b/src/core/function/basic/SingletonStorage.cpp index 211a51b3..4786ad93 100644 --- a/src/core/function/basic/SingletonStorage.cpp +++ b/src/core/function/basic/SingletonStorage.cpp @@ -71,7 +71,8 @@ class SingletonStorage::Impl { auto SetObjectInChannel(int channel, ChannelObjectPtr p_obj) -> GpgFrontend::ChannelObject* { { - SPDLOG_TRACE("set channel object in channel: {}, address: {}", channel, + SPDLOG_TRACE("set channel object, type: {} in channel: {}, address: {}", + typeid(p_obj.get()).name(), channel, static_cast(p_obj.get())); assert(p_obj != nullptr); @@ -84,12 +85,14 @@ class SingletonStorage::Impl { p_obj->SetChannel(channel); auto* raw_obj = p_obj.get(); - SPDLOG_TRACE( - "register channel object to instances map, " - "channel: {}, address: {}", - channel, static_cast(p_obj.get())); - std::unique_lock lock(instances_mutex_); - instances_map_.insert({channel, std::move(p_obj)}); + { + SPDLOG_TRACE( + "register channel object to instances map, " + "channel: {}, address: {}", + channel, static_cast(p_obj.get())); + std::unique_lock lock(instances_mutex_); + instances_map_[channel] = std::move(p_obj); + } SPDLOG_TRACE( "set channel: {} success, current channel object address: {}", -- cgit v1.2.3 From f9a49043c35e73fc2d4ffb3ed9b39c33849c43b3 Mon Sep 17 00:00:00 2001 From: saturneric Date: Fri, 15 Dec 2023 21:14:17 +0800 Subject: fix: slove threading and memory issues --- src/core/function/basic/SingletonStorage.cpp | 49 +++++++++++++--------------- 1 file changed, 23 insertions(+), 26 deletions(-) (limited to 'src/core/function/basic/SingletonStorage.cpp') diff --git a/src/core/function/basic/SingletonStorage.cpp b/src/core/function/basic/SingletonStorage.cpp index 4786ad93..73e19ddd 100644 --- a/src/core/function/basic/SingletonStorage.cpp +++ b/src/core/function/basic/SingletonStorage.cpp @@ -52,7 +52,7 @@ class SingletonStorage::Impl { std::shared_lock lock(instances_mutex_); ins_it = instances_map_.find(channel); if (ins_it == instances_map_.end()) { - SPDLOG_TRACE("cannot find channel object, channel :{}", channel); + SPDLOG_TRACE("cannot find channel object, channel: {}", channel); return nullptr; } return ins_it->second.get(); @@ -70,35 +70,32 @@ class SingletonStorage::Impl { auto SetObjectInChannel(int channel, ChannelObjectPtr p_obj) -> GpgFrontend::ChannelObject* { - { - SPDLOG_TRACE("set channel object, type: {} in channel: {}, address: {}", - typeid(p_obj.get()).name(), channel, - static_cast(p_obj.get())); - - assert(p_obj != nullptr); - if (p_obj == nullptr) { - SPDLOG_ERROR("cannot set a nullptr as a channel obejct of channel: {}", - channel); - return nullptr; - } - - p_obj->SetChannel(channel); - auto* raw_obj = p_obj.get(); + SPDLOG_TRACE("set channel object, type: {} in channel: {}, address: {}", + typeid(p_obj.get()).name(), channel, + static_cast(p_obj.get())); + + assert(p_obj != nullptr); + if (p_obj == nullptr) { + SPDLOG_ERROR("cannot set a nullptr as a channel obejct of channel: {}", + channel); + return nullptr; + } - { - SPDLOG_TRACE( - "register channel object to instances map, " - "channel: {}, address: {}", - channel, static_cast(p_obj.get())); - std::unique_lock lock(instances_mutex_); - instances_map_[channel] = std::move(p_obj); - } + p_obj->SetChannel(channel); + auto* raw_obj = p_obj.get(); + { SPDLOG_TRACE( - "set channel: {} success, current channel object address: {}", - channel, static_cast(raw_obj)); - return raw_obj; + "register channel object to instances map, " + "channel: {}, address: {}", + channel, static_cast(p_obj.get())); + std::unique_lock lock(instances_mutex_); + instances_map_[channel] = std::move(p_obj); } + + SPDLOG_TRACE("set channel: {} success, current channel object address: {}", + channel, static_cast(raw_obj)); + return raw_obj; } private: -- cgit v1.2.3 From 37215a895a649345165027971690dfdcd9106a32 Mon Sep 17 00:00:00 2001 From: saturneric Date: Fri, 15 Dec 2023 21:53:03 -0800 Subject: fix: use secure memory management at impl class --- src/core/function/basic/SingletonStorage.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'src/core/function/basic/SingletonStorage.cpp') diff --git a/src/core/function/basic/SingletonStorage.cpp b/src/core/function/basic/SingletonStorage.cpp index 73e19ddd..f6507567 100644 --- a/src/core/function/basic/SingletonStorage.cpp +++ b/src/core/function/basic/SingletonStorage.cpp @@ -31,6 +31,7 @@ #include #include "core/function/basic/ChannelObject.h" +#include "utils/MemoryUtils.h" namespace GpgFrontend { @@ -104,7 +105,8 @@ class SingletonStorage::Impl { instances_map_; ///< map of singleton instances }; -SingletonStorage::SingletonStorage() noexcept : p_(std::make_unique()) {} +SingletonStorage::SingletonStorage() noexcept + : p_(SecureCreateUniqueObject()) {} SingletonStorage::~SingletonStorage() = default; -- cgit v1.2.3 From 644aa4397b03dbef73f8bfedc13925b51cad836b Mon Sep 17 00:00:00 2001 From: saturneric Date: Fri, 5 Jan 2024 20:55:15 +0800 Subject: feat: integrate logging api to core --- src/core/function/basic/SingletonStorage.cpp | 20 +++++++++++--------- 1 file changed, 11 insertions(+), 9 deletions(-) (limited to 'src/core/function/basic/SingletonStorage.cpp') diff --git a/src/core/function/basic/SingletonStorage.cpp b/src/core/function/basic/SingletonStorage.cpp index f6507567..eab71e0f 100644 --- a/src/core/function/basic/SingletonStorage.cpp +++ b/src/core/function/basic/SingletonStorage.cpp @@ -53,7 +53,8 @@ class SingletonStorage::Impl { std::shared_lock lock(instances_mutex_); ins_it = instances_map_.find(channel); if (ins_it == instances_map_.end()) { - SPDLOG_TRACE("cannot find channel object, channel: {}", channel); + GF_DEFAULT_LOG_TRACE("cannot find channel object, channel: {}", + channel); return nullptr; } return ins_it->second.get(); @@ -71,14 +72,14 @@ class SingletonStorage::Impl { auto SetObjectInChannel(int channel, ChannelObjectPtr p_obj) -> GpgFrontend::ChannelObject* { - SPDLOG_TRACE("set channel object, type: {} in channel: {}, address: {}", - typeid(p_obj.get()).name(), channel, - static_cast(p_obj.get())); + GF_DEFAULT_LOG_TRACE( + "set channel object, type: {} in channel: {}, address: {}", + typeid(p_obj.get()).name(), channel, static_cast(p_obj.get())); assert(p_obj != nullptr); if (p_obj == nullptr) { - SPDLOG_ERROR("cannot set a nullptr as a channel obejct of channel: {}", - channel); + GF_DEFAULT_LOG_ERROR( + "cannot set a nullptr as a channel obejct of channel: {}", channel); return nullptr; } @@ -86,7 +87,7 @@ class SingletonStorage::Impl { auto* raw_obj = p_obj.get(); { - SPDLOG_TRACE( + GF_DEFAULT_LOG_TRACE( "register channel object to instances map, " "channel: {}, address: {}", channel, static_cast(p_obj.get())); @@ -94,8 +95,9 @@ class SingletonStorage::Impl { instances_map_[channel] = std::move(p_obj); } - SPDLOG_TRACE("set channel: {} success, current channel object address: {}", - channel, static_cast(raw_obj)); + GF_DEFAULT_LOG_TRACE( + "set channel: {} success, current channel object address: {}", channel, + static_cast(raw_obj)); return raw_obj; } -- cgit v1.2.3