Remove unnecessary unique_lock from read operation

[platform/core/appfw/pkgmgr-info.git] / src / server / database / db_handle_provider.cc

diff --git a/src/server/database/db_handle_provider.cc b/src/server/database/db_handle_provider.cc
index 14c3f30..375c3eb 100644 (file)
--- a/src/server/database/db_handle_provider.cc
+++ b/src/server/database/db_handle_provider.cc
@@ -100,7 +100,7 @@ std::string DBHandleProvider::global_parser_filedb_path_;
 std::string DBHandleProvider::cert_filedb_path_;
 std::unordered_set<pid_t> DBHandleProvider::writer_pid_list_;
 std::recursive_mutex DBHandleProvider::lock_;
-std::mutex DBHandleProvider::pid_list_lock_;
+std::shared_mutex DBHandleProvider::pid_list_lock_;
 
 DBHandleProvider::DBHandleProvider(uid_t uid)
     : uid_(uid),
@@ -130,10 +130,16 @@ DBHandleProvider::DBHandleProvider(uid_t uid)
 }
 
 DBHandleProvider& DBHandleProvider::GetInst(uid_t uid) {
-  static std::mutex singleton_lock_;
-  std::unique_lock<std::mutex> u(singleton_lock_);
+  static std::shared_mutex singleton_lock_;
+  std::shared_lock<std::shared_mutex> s(singleton_lock_);
 
   uid = ConvertUID(uid);
+  auto it = provider_map_.find(uid);
+  if (it != provider_map_.end())
+    return *(it->second);
+
+  s.unlock();
+  std::unique_lock<std::shared_mutex> u(singleton_lock_);
   auto& prov = provider_map_[uid];
   if (prov == nullptr)
     prov.reset(new DBHandleProvider(uid));
@@ -142,7 +148,7 @@ DBHandleProvider& DBHandleProvider::GetInst(uid_t uid) {
 }
 
 bool DBHandleProvider::IsCrashedWriteRequest() {
-  std::unique_lock<std::mutex> u(pid_list_lock_);
+  std::unique_lock<std::shared_mutex> u(pid_list_lock_);
 
   if (writer_pid_list_.empty())
     return false;
@@ -296,7 +302,7 @@ void DBHandleProvider::UnsetMemoryMode(pid_t pid) {
 }
 
 bool DBHandleProvider::IsMemoryDBActive(pid_t pid, bool write) {
-  std::unique_lock<std::mutex> u(pid_list_lock_);
+  std::unique_lock<std::shared_mutex> u(pid_list_lock_);
   if (!is_user_memdb_set_)
     return false;
 
@@ -327,7 +333,7 @@ void DBHandleProvider::ReleaseCache() {
 }
 
 bool DBHandleProvider::IsWriter(pid_t pid) {
-  std::unique_lock<std::mutex> u(pid_list_lock_);
+  std::unique_lock<std::shared_mutex> s(pid_list_lock_);
   return writer_pid_list_.find(pid) != writer_pid_list_.end();
 }
 
@@ -355,6 +361,7 @@ int DBHandleProvider::UpdateCache(sqlite3* db, pid_t pid, uid_t uid, bool write,
   }
 
   pkgmgrinfo_filter_x tmp_filter = { 0, };
+  tmp_filter.cache_flag = true;
   int ret = pkginfo_internal_filter_get_list(db, &tmp_filter, uid_,
                                              locale.c_str(), list);
   if (ret == PMINFO_R_OK) {
@@ -413,13 +420,21 @@ int DBHandleProvider::UpdateCache(sqlite3* db, pid_t pid, uid_t uid, bool write,
 }
 
 std::vector<std::shared_ptr<package_x>> DBHandleProvider::GetPackages(
-    pid_t pid, bool write, pkgmgrinfo_filter_x* filter,
+    pid_t pid, pkgmgrinfo_filter_x* filter,
     const std::string& package) {
   std::vector<std::shared_ptr<package_x>> ret;
   auto map_it = pkg_map_.find(package);
   if (map_it == pkg_map_.end())
     return ret;
 
+  if (__check_package_storage_status(filter)) {
+    if (pkgmgrinfo_pkginfo_filter_add_bool(filter,
+        PMINFO_PKGINFO_PROP_PACKAGE_CHECK_STORAGE, true) != PMINFO_R_OK) {
+      LOG(ERROR) << "Fail to add check storage value to filter";
+      return {};
+    }
+  }
+
   for (auto& info : map_it->second) {
     bool pass = true;
     for (auto* it = filter->list; it != nullptr; it = g_slist_next(it)) {
@@ -445,7 +460,7 @@ void DBHandleProvider::AddPackage(std::string package, package_x* info) {
 }
 
 std::vector<std::shared_ptr<application_x>> DBHandleProvider::GetApplications(
-    pid_t pid, bool write, pkgmgrinfo_filter_x* filter,
+    pid_t pid, pkgmgrinfo_filter_x* filter,
     const std::string& app) {
   /* make metadata filter map */
   std::unordered_map<std::string, std::string> metadata_map;
@@ -462,6 +477,14 @@ std::vector<std::shared_ptr<application_x>> DBHandleProvider::GetApplications(
   if (map_it == app_map_.end())
     return ret;
 
+  if (pkgmgr_server::internal::check_app_storage_status(filter)) {
+    if (pkgmgrinfo_appinfo_filter_add_bool(filter,
+        PMINFO_APPINFO_PROP_APP_CHECK_STORAGE, true) != PMINFO_R_OK) {
+      LOG(ERROR) << "Fail to add check storage value to filter";
+      return {};
+    }
+  }
+
   for (auto& info : map_it->second) {
     bool pass = true;
     for (auto* it = filter->list; it != nullptr; it = g_slist_next(it)) {
@@ -507,13 +530,13 @@ void DBHandleProvider::AddApplication(std::string app, std::shared_ptr<applicati
 }
 
 void DBHandleProvider::InsertPID(pid_t pid) {
-  std::unique_lock<std::mutex> u(pid_list_lock_);
+  std::unique_lock<std::shared_mutex> u(pid_list_lock_);
 
   writer_pid_list_.insert(pid);
 }
 
 bool DBHandleProvider::ErasePID(pid_t pid) {
-  std::unique_lock<std::mutex> u(pid_list_lock_);
+  std::unique_lock<std::shared_mutex> u(pid_list_lock_);
 
   return writer_pid_list_.erase(pid) == 1;
 }