hcq/MaxScale
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

MXS-2067: Remove spinlock.hh

Browse Source 
Replaced the C++ versions with standard library mutexes.
This commit is contained in:
Markus Mäkelä
2018-09-26 00:02:06 +03:00
parent fc1e36429c
commit 50451166bb
15 changed files with 84 additions and 214 deletions
Download Patch File Download Diff File Expand all files Collapse all files

120
include/maxscale/spinlock.hh
View File

@ -1,120 +0,0 @@
/*
* Copyright (c) 2018 MariaDB Corporation Ab
*
* Use of this software is governed by the Business Source License included
* in the LICENSE.TXT file and at www.mariadb.com/bsl11.
*
* Change Date: 2022-01-01
*
* On the date above, in accordance with the Business Source License, use
* of this software will be governed by version 2 or later of the General
* Public License.
*/
#pragma once
#include <maxscale/ccdefs.hh>
#include <maxscale/spinlock.h>
namespace maxscale
{
class SpinLockGuard;
/**
* @class SpinLock spinlock.hh <maxscale/spinlock.hh>
*
* The class SpinLock is a simple class that wraps a regular SPINLOCK
* and provides equivalent functionality.
*/
class SpinLock
{
public:
friend class SpinLockGuard;
/**
* Creates a spinlock.
*/
SpinLock()
{
spinlock_init(&m_lock);
}
~SpinLock()
{
}
/**
* Acquires the spinlock.
*/
void acquire() const
{
spinlock_acquire(&m_lock);
}
/**
* Releases the spinlock.
*/
void release() const
{
spinlock_release(&m_lock);
}
private:
SpinLock(const SpinLock&) /* = delete */;
SpinLock& operator=(const SpinLock&) /* = delete */;
private:
mutable SPINLOCK m_lock;
};
/**
* @class SpinLockGuard spinlock.hh <maxscale/spinlock.hh>
*
* The class SpinLockGuard is a spinlock wrapper that provides a RAII-style
* mechanism for owning a spinlock for the duration of a scoped block. When
* a SpinLockGuard object is created, it attempts to take ownership of the
* spinlock it is given. When control leaves the scope in which the
* SpinLockGuard object was created, the SpinLockGuard is destructed and the
* mutex is released.
*/
class SpinLockGuard
{
public:
/**
* Creates the guard and locks the provided lock.
*
* @param lock The spinlock to lock.
*/
SpinLockGuard(const SPINLOCK& lock)
: m_lock(lock)
{
spinlock_acquire(&m_lock);
}
/**
* Creates the guard and locks the provided lock.
*
* @param lock The spinlock to lock.
*/
SpinLockGuard(const SpinLock& lock)
: m_lock(lock.m_lock)
{
spinlock_acquire(&m_lock);
}
/**
* Destroys the guard and unlocks the lock that was provided when
* the guard was created.
*/
~SpinLockGuard()
{
spinlock_release(&m_lock);
}
private:
SpinLockGuard(const SpinLockGuard&) /* = delete */;
SpinLockGuard& operator=(const SpinLockGuard&) /* = delete */;
const SPINLOCK& m_lock;
};
}

37
server/core/config_runtime.cc
View File

@ -32,7 +32,6 @@
#include <maxscale/json_api.h>
#include <maxscale/paths.h>
#include <maxscale/router.h>
#include <maxscale/spinlock.hh>
#include <maxscale/users.h>
#include "internal/config.hh"
@ -46,7 +45,7 @@ typedef std::vector<std::string> StringVector;
using std::tie;
static mxs::SpinLock crt_lock;
static std::mutex crt_lock;
#define RUNTIME_ERRMSG_BUFSIZE 512
thread_local char runtime_errmsg[RUNTIME_ERRMSG_BUFSIZE];
@ -133,7 +132,7 @@ static std::pair<bool, MXS_CONFIG_PARAMETER*> load_defaults(const char* name,
bool runtime_link_server(SERVER* server, const char* target)
{
mxs::SpinLockGuard guard(crt_lock);
std::lock_guard<std::mutex> guard(crt_lock);
bool rval = false;
Service* service = service_internal_find(target);
@ -177,7 +176,7 @@ bool runtime_link_server(SERVER* server, const char* target)
bool runtime_unlink_server(SERVER* server, const char* target)
{
mxs::SpinLockGuard guard(crt_lock);
std::lock_guard<std::mutex> guard(crt_lock);
bool rval = false;
Service* service = service_internal_find(target);
@ -211,7 +210,7 @@ bool runtime_create_server(const char* name,
const char* protocol,
const char* authenticator)
{
mxs::SpinLockGuard guard(crt_lock);
std::lock_guard<std::mutex> guard(crt_lock);
bool rval = false;
if (server_find_by_unique_name(name) == NULL)
@ -274,7 +273,7 @@ bool runtime_create_server(const char* name,
bool runtime_destroy_server(SERVER* server)
{
mxs::SpinLockGuard guard(crt_lock);
std::lock_guard<std::mutex> guard(crt_lock);
bool rval = false;
if (service_server_in_use(server) || monitor_server_in_use(server))
@ -370,7 +369,7 @@ bool runtime_enable_server_ssl(SERVER* server,
if (key && cert && ca)
{
mxs::SpinLockGuard guard(crt_lock);
std::lock_guard<std::mutex> guard(crt_lock);
SSL_LISTENER* ssl = create_ssl(server->name, key, cert, ca, version, depth, verify);
if (ssl)
@ -465,7 +464,7 @@ bool runtime_alter_server(SERVER* server, const char* key, const char* value)
return false;
}
mxs::SpinLockGuard guard(crt_lock);
std::lock_guard<std::mutex> guard(crt_lock);
server_set_parameter(server, key, value);
if (strcmp(key, CN_ADDRESS) == 0)
@ -557,7 +556,7 @@ bool do_alter_monitor(MXS_MONITOR* monitor, const char* key, const char* value,
return false;
}
mxs::SpinLockGuard guard(crt_lock);
std::lock_guard<std::mutex> guard(crt_lock);
if (restart_monitor)
{
@ -671,7 +670,7 @@ bool runtime_alter_service(Service* service, const char* zKey, const char* zValu
return false;
}
mxs::SpinLockGuard guard(crt_lock);
std::lock_guard<std::mutex> guard(crt_lock);
bool rval = true;
if (service->is_basic_parameter(key))
@ -728,7 +727,7 @@ bool runtime_alter_maxscale(const char* name, const char* value)
std::string key = name;
bool rval = false;
mxs::SpinLockGuard guard(crt_lock);
std::lock_guard<std::mutex> guard(crt_lock);
if (key == CN_AUTH_CONNECT_TIMEOUT)
{
@ -927,7 +926,7 @@ bool runtime_create_listener(Service* service,
unsigned short u_port = atoi(port);
bool rval = false;
mxs::SpinLockGuard guard(crt_lock);
std::lock_guard<std::mutex> guard(crt_lock);
if (!serviceHasListener(service, name, proto, addr, u_port))
{
@ -997,7 +996,7 @@ bool runtime_destroy_listener(Service* service, const char* name)
char filename[PATH_MAX];
snprintf(filename, sizeof(filename), "%s/%s.cnf", get_config_persistdir(), name);
mxs::SpinLockGuard guard(crt_lock);
std::lock_guard<std::mutex> guard(crt_lock);
if (unlink(filename) == -1)
{
@ -1037,7 +1036,7 @@ bool runtime_destroy_listener(Service* service, const char* name)
bool runtime_create_monitor(const char* name, const char* module)
{
mxs::SpinLockGuard guard(crt_lock);
std::lock_guard<std::mutex> guard(crt_lock);
bool rval = false;
if (monitor_find(name) == NULL)
@ -1089,7 +1088,7 @@ bool runtime_create_monitor(const char* name, const char* module)
bool runtime_create_filter(const char* name, const char* module, MXS_CONFIG_PARAMETER* params)
{
mxs::SpinLockGuard guard(crt_lock);
std::lock_guard<std::mutex> guard(crt_lock);
bool rval = false;
if (!filter_find(name))
@ -1139,7 +1138,7 @@ bool runtime_destroy_filter(const SFilterDef& filter)
{
mxb_assert(filter);
bool rval = false;
mxs::SpinLockGuard guard(crt_lock);
std::lock_guard<std::mutex> guard(crt_lock);
if (filter_can_be_destroyed(filter))
{
@ -1158,7 +1157,7 @@ bool runtime_destroy_filter(const SFilterDef& filter)
static bool runtime_create_service(const char* name, const char* router, MXS_CONFIG_PARAMETER* params)
{
mxs::SpinLockGuard guard(crt_lock);
std::lock_guard<std::mutex> guard(crt_lock);
bool rval = false;
if (service_internal_find(name) == NULL)
@ -1207,7 +1206,7 @@ static bool runtime_create_service(const char* name, const char* router, MXS_CON
bool runtime_destroy_service(Service* service)
{
bool rval = false;
mxs::SpinLockGuard guard(crt_lock);
std::lock_guard<std::mutex> guard(crt_lock);
mxb_assert(service && service->active);
if (service_can_be_destroyed(service))
@ -1231,7 +1230,7 @@ bool runtime_destroy_monitor(MXS_MONITOR* monitor)
char filename[PATH_MAX];
snprintf(filename, sizeof(filename), "%s/%s.cnf", get_config_persistdir(), monitor->name);
mxs::SpinLockGuard guard(crt_lock);
std::lock_guard<std::mutex> guard(crt_lock);
if (unlink(filename) == -1 && errno != ENOENT)
{

14
server/core/housekeeper.cc
View File

@ -17,6 +17,7 @@
#include <string.h>
#include <string>
#include <thread>
#include <mutex>
#include <maxbase/semaphore.h>
#include <maxscale/alloc.h>
@ -27,7 +28,6 @@
#include <maxscale/json_api.h>
#include <maxscale/query_classifier.h>
#include <maxscale/spinlock.h>
#include <maxscale/spinlock.hh>
/**
* @file housekeeper.cc Provide a mechanism to run periodic tasks
@ -117,7 +117,7 @@ private:
std::thread m_thread;
uint32_t m_running;
std::list<Task> m_tasks;
mxs::SpinLock m_lock;
std::mutex m_lock;
bool is_running() const
{
@ -172,7 +172,7 @@ void Housekeeper::run()
mxb::atomic::add(&mxs_clock_ticks, 1, mxb::atomic::RELAXED);
}
mxs::SpinLockGuard guard(m_lock);
std::lock_guard<std::mutex> guard(m_lock);
time_t now = time(0);
auto it = m_tasks.begin();
@ -205,19 +205,19 @@ void Housekeeper::stop()
void Housekeeper::add(const Task& task)
{
mxs::SpinLockGuard guard(m_lock);
std::lock_guard<std::mutex> guard(m_lock);
m_tasks.push_back(task);
}
void Housekeeper::remove(std::string name)
{
mxs::SpinLockGuard guard(m_lock);
std::lock_guard<std::mutex> guard(m_lock);
m_tasks.remove_if(Task::NameMatch(name));
}
void Housekeeper::print_tasks(DCB* pDcb)
{
mxs::SpinLockGuard guard(m_lock);
std::lock_guard<std::mutex> guard(m_lock);
dcb_printf(pDcb, "%-25s | Type | Frequency | Next Due\n", "Name");
dcb_printf(pDcb, "--------------------------+----------+-----------+-------------------------\n");
@ -235,7 +235,7 @@ json_t* Housekeeper::tasks_json(const char* host)
{
json_t* arr = json_array();
mxs::SpinLockGuard guard(m_lock);
std::lock_guard<std::mutex> guard(m_lock);
for (auto ptr = m_tasks.begin(); ptr != m_tasks.end(); ptr++)
{

4
server/core/resource.cc
View File

@ -24,7 +24,6 @@
#include <maxscale/json_api.h>
#include <maxscale/modulecmd.h>
#include <maxscale/server.hh>
#include <maxscale/spinlock.hh>
#include <maxscale/routingworker.hh>
#include "internal/config_runtime.h"
@ -41,8 +40,6 @@ using std::list;
using std::map;
using std::string;
using std::stringstream;
using mxs::SpinLock;
using mxs::SpinLockGuard;
Resource::Resource(ResourceCallback cb, int components, ...)
: m_cb(cb)
@ -1205,7 +1202,6 @@ private:
static RootResource resources; /**< Core resource set */
static ResourceWatcher watcher; /**< Modification watcher */
static SpinLock resource_lock;
static bool request_modifies_data(const string& verb)
{

28
server/core/users.cc
View File

@ -13,15 +13,15 @@
#include <maxscale/ccdefs.hh>
#include <algorithm>
#include <mutex>
#include <new>
#include <unordered_map>
#include <set>
#include <string>
#include <algorithm>
#include <unordered_map>
#include <maxscale/users.h>
#include <maxscale/authenticator.h>
#include <maxscale/spinlock.hh>
#include <maxscale/log.h>
#include <maxscale/jansson.hh>
@ -67,13 +67,13 @@ public:
bool add(std::string user, std::string password, user_account_type perm)
{
mxs::SpinLockGuard guard(m_lock);
std::lock_guard<std::mutex> guard(m_lock);
return m_data.insert(std::make_pair(user, UserInfo(password, perm))).second;
}
bool remove(std::string user)
{
mxs::SpinLockGuard guard(m_lock);
std::lock_guard<std::mutex> guard(m_lock);
bool rval = false;
UserMap::iterator it = m_data.find(user);
@ -88,7 +88,7 @@ public:
bool get(std::string user, UserInfo* output = NULL) const
{
mxs::SpinLockGuard guard(m_lock);
std::lock_guard<std::mutex> guard(m_lock);
UserMap::const_iterator it = m_data.find(user);
bool rval = false;
@ -112,7 +112,7 @@ public:
bool check_permissions(std::string user, user_account_type perm) const
{
mxs::SpinLockGuard guard(m_lock);
std::lock_guard<std::mutex> guard(m_lock);
UserMap::const_iterator it = m_data.find(user);
bool rval = false;
@ -126,7 +126,7 @@ public:
bool set_permissions(std::string user, user_account_type perm)
{
mxs::SpinLockGuard guard(m_lock);
std::lock_guard<std::mutex> guard(m_lock);
UserMap::iterator it = m_data.find(user);
bool rval = false;
@ -141,7 +141,7 @@ public:
json_t* diagnostic_json() const
{
mxs::SpinLockGuard guard(m_lock);
std::lock_guard<std::mutex> guard(m_lock);
json_t* rval = json_array();
for (UserMap::const_iterator it = m_data.begin(); it != m_data.end(); it++)
@ -157,7 +157,7 @@ public:
void diagnostic(DCB* dcb) const
{
mxs::SpinLockGuard guard(m_lock);
std::lock_guard<std::mutex> guard(m_lock);
if (m_data.size())
{
const char* sep = "";
@ -178,14 +178,14 @@ public:
bool empty() const
{
mxs::SpinLockGuard guard(m_lock);
std::lock_guard<std::mutex> guard(m_lock);
return m_data.size() > 0;
}
json_t* to_json() const
{
json_t* arr = json_array();
mxs::SpinLockGuard guard(m_lock);
std::lock_guard<std::mutex> guard(m_lock);
for (UserMap::const_iterator it = m_data.begin(); it != m_data.end(); it++)
{
@ -241,8 +241,8 @@ private:
}
}
mxs::SpinLock m_lock;
UserMap m_data;
mutable std::mutex m_lock;
UserMap m_data;
};
}

9
server/modules/filter/cache/cachemt.cc vendored
View File

@ -16,7 +16,6 @@
#include "storage.hh"
#include "storagefactory.hh"
using maxscale::SpinLockGuard;
using std::shared_ptr;
CacheMT::CacheMT(const std::string& name,
@ -26,8 +25,6 @@ CacheMT::CacheMT(const std::string& name,
Storage* pStorage)
: CacheSimple(name, pConfig, rules, sFactory, pStorage)
{
spinlock_init(&m_lock_pending);
MXS_NOTICE("Created multi threaded cache.");
}
@ -56,21 +53,21 @@ CacheMT* CacheMT::Create(const std::string& name, const CACHE_CONFIG* pConfig)
json_t* CacheMT::get_info(uint32_t flags) const
{
SpinLockGuard guard(m_lock_pending);
std::lock_guard<std::mutex> guard(m_lock_pending);
return CacheSimple::do_get_info(flags);
}
bool CacheMT::must_refresh(const CACHE_KEY& key, const CacheFilterSession* pSession)
{
SpinLockGuard guard(m_lock_pending);
std::lock_guard<std::mutex> guard(m_lock_pending);
return do_must_refresh(key, pSession);
}
void CacheMT::refreshed(const CACHE_KEY& key, const CacheFilterSession* pSession)
{
SpinLockGuard guard(m_lock_pending);
std::lock_guard<std::mutex> guard(m_lock_pending);
do_refreshed(key, pSession);
}

6
server/modules/filter/cache/cachemt.hh vendored
View File

@ -13,7 +13,9 @@
#pragma once
#include <maxscale/ccdefs.hh>
#include <maxscale/spinlock.hh>
#include <mutex>
#include "cachesimple.hh"
class CacheMT : public CacheSimple
@ -46,5 +48,5 @@ private:
CacheMT& operator=(const CacheMT&);
private:
mutable SPINLOCK m_lock_pending; // Lock used for protecting 'pending'.
mutable std::mutex m_lock_pending; // Lock used for protecting 'pending'.
};

20
server/modules/filter/cache/lrustoragemt.cc vendored
View File

@ -14,13 +14,9 @@
#define MXS_MODULE_NAME "cache"
#include "lrustoragemt.hh"
using maxscale::SpinLockGuard;
LRUStorageMT::LRUStorageMT(const CACHE_STORAGE_CONFIG& config, Storage* pStorage)
: LRUStorage(config, pStorage)
{
spinlock_init(&m_lock);
MXS_NOTICE("Created multi threaded LRU storage.");
}
@ -40,7 +36,7 @@ LRUStorageMT* LRUStorageMT::create(const CACHE_STORAGE_CONFIG& config, Storage*
cache_result_t LRUStorageMT::get_info(uint32_t what,
json_t** ppInfo) const
{
SpinLockGuard guard(m_lock);
std::lock_guard<std::mutex> guard(m_lock);
return LRUStorage::do_get_info(what, ppInfo);
}
@ -51,49 +47,49 @@ cache_result_t LRUStorageMT::get_value(const CACHE_KEY& key,
uint32_t hard_ttl,
GWBUF** ppValue) const
{
SpinLockGuard guard(m_lock);
std::lock_guard<std::mutex> guard(m_lock);
return do_get_value(key, flags, soft_ttl, hard_ttl, ppValue);
}
cache_result_t LRUStorageMT::put_value(const CACHE_KEY& key, const GWBUF* pValue)
{
SpinLockGuard guard(m_lock);
std::lock_guard<std::mutex> guard(m_lock);
return do_put_value(key, pValue);
}
cache_result_t LRUStorageMT::del_value(const CACHE_KEY& key)
{
SpinLockGuard guard(m_lock);
std::lock_guard<std::mutex> guard(m_lock);
return do_del_value(key);
}
cache_result_t LRUStorageMT::get_head(CACHE_KEY* pKey, GWBUF** ppHead) const
{
SpinLockGuard guard(m_lock);
std::lock_guard<std::mutex> guard(m_lock);
return LRUStorage::do_get_head(pKey, ppHead);
}
cache_result_t LRUStorageMT::get_tail(CACHE_KEY* pKey, GWBUF** ppTail) const
{
SpinLockGuard guard(m_lock);
std::lock_guard<std::mutex> guard(m_lock);
return LRUStorage::do_get_tail(pKey, ppTail);
}
cache_result_t LRUStorageMT::get_size(uint64_t* pSize) const
{
SpinLockGuard guard(m_lock);
std::lock_guard<std::mutex> guard(m_lock);
return LRUStorage::do_get_size(pSize);
}
cache_result_t LRUStorageMT::get_items(uint64_t* pItems) const
{
SpinLockGuard guard(m_lock);
std::lock_guard<std::mutex> guard(m_lock);
return LRUStorage::do_get_items(pItems);
}

6
server/modules/filter/cache/lrustoragemt.hh vendored
View File

@ -13,7 +13,9 @@
#pragma once
#include <maxscale/ccdefs.hh>
#include <maxscale/spinlock.hh>
#include <mutex>
#include "lrustorage.hh"
class LRUStorageMT : public LRUStorage
@ -54,5 +56,5 @@ private:
LRUStorageMT& operator=(const LRUStorageMT&);
private:
mutable SPINLOCK m_lock;
mutable std::mutex m_lock;
};

10
server/modules/filter/cache/storage/storage_inmemory/inmemorystoragemt.cc vendored
View File

@ -14,14 +14,12 @@
#define MXS_MODULE_NAME "storage_inmemory"
#include "inmemorystoragemt.hh"
using maxscale::SpinLockGuard;
using std::auto_ptr;
InMemoryStorageMT::InMemoryStorageMT(const std::string& name,
const CACHE_STORAGE_CONFIG& config)
: InMemoryStorage(name, config)
{
spinlock_init(&m_lock);
}
InMemoryStorageMT::~InMemoryStorageMT()
@ -38,7 +36,7 @@ auto_ptr<InMemoryStorageMT> InMemoryStorageMT::Create(const std::string& name,
cache_result_t InMemoryStorageMT::get_info(uint32_t what, json_t** ppInfo) const
{
SpinLockGuard guard(m_lock);
std::lock_guard<std::mutex> guard(m_lock);
return do_get_info(what, ppInfo);
}
@ -49,21 +47,21 @@ cache_result_t InMemoryStorageMT::get_value(const CACHE_KEY& key,
uint32_t hard_ttl,
GWBUF** ppResult)
{
SpinLockGuard guard(m_lock);
std::lock_guard<std::mutex> guard(m_lock);
return do_get_value(key, flags, soft_ttl, hard_ttl, ppResult);
}
cache_result_t InMemoryStorageMT::put_value(const CACHE_KEY& key, const GWBUF& value)
{
SpinLockGuard guard(m_lock);
std::lock_guard<std::mutex> guard(m_lock);
return do_put_value(key, value);
}
cache_result_t InMemoryStorageMT::del_value(const CACHE_KEY& key)
{
SpinLockGuard guard(m_lock);
std::lock_guard<std::mutex> guard(m_lock);
return do_del_value(key);
}

6
server/modules/filter/cache/storage/storage_inmemory/inmemorystoragemt.hh vendored
View File

@ -13,7 +13,9 @@
#pragma once
#include <maxscale/ccdefs.hh>
#include <maxscale/spinlock.hh>
#include <mutex>
#include "inmemorystorage.hh"
class InMemoryStorageMT : public InMemoryStorage
@ -45,5 +47,5 @@ private:
InMemoryStorageMT& operator=(const InMemoryStorageMT&);
private:
mutable SPINLOCK m_lock;
mutable std::mutex m_lock;
};

6
server/modules/filter/dbfwfilter/dbfwfilter.cc
View File

@ -76,7 +76,6 @@
#include <maxscale/protocol/mysql.h>
#include <maxscale/pcre2.h>
#include <maxscale/alloc.h>
#include <maxscale/spinlock.hh>
#include <maxscale/utils.h>
#include "rules.hh"
@ -1201,7 +1200,6 @@ int global_version = 1;
Dbfw::Dbfw(MXS_CONFIG_PARAMETER* params)
: m_action((enum fw_actions)config_get_enum(params, "action", action_values))
, m_log_match(0)
, m_lock(SPINLOCK_INIT)
, m_filename(config_get_string(params, "rules"))
, m_version(atomic_add(&global_version, 1))
{
@ -1252,7 +1250,7 @@ int Dbfw::get_log_bitmask() const
std::string Dbfw::get_rule_file() const
{
mxs::SpinLockGuard guard(m_lock);
std::lock_guard<std::mutex> guard(m_lock);
return m_filename;
}
@ -1296,7 +1294,7 @@ bool Dbfw::do_reload_rules(std::string filename)
bool Dbfw::reload_rules(std::string filename)
{
mxs::SpinLockGuard guard(m_lock);
std::lock_guard<std::mutex> guard(m_lock);
return do_reload_rules(filename);
}

17
server/modules/filter/dbfwfilter/dbfwfilter.hh
View File

@ -16,15 +16,16 @@
#include <maxscale/ccdefs.hh>
#include <time.h>
#include <string>
#include <list>
#include <vector>
#include <memory>
#include <mutex>
#include <string>
#include <unordered_map>
#include <vector>
#include <maxscale/filter.hh>
#include <maxscale/query_classifier.h>
#include <maxscale/spinlock.h>
#include "dbfwfilter.h"
@ -264,11 +265,11 @@ public:
}
private:
fw_actions m_action; /*< Default operation mode, defaults to deny */
int m_log_match;/*< Log matching and/or non-matching queries */
SPINLOCK m_lock; /*< Instance spinlock */
std::string m_filename; /*< Path to the rule file */
int m_version; /*< Latest rule file version, incremented on reload */
fw_actions m_action; /*< Default operation mode, defaults to deny */
int m_log_match; /*< Log matching and/or non-matching queries */
mutable std::mutex m_lock; /*< Instance spinlock */
std::string m_filename; /*< Path to the rule file */
int m_version; /*< Latest rule file version, incremented on reload */
Dbfw(MXS_CONFIG_PARAMETER* param);
bool do_reload_rules(std::string filename);

5
server/modules/routing/schemarouter/shard_map.cc
View File

@ -172,7 +172,6 @@ bool Shard::newer_than(const Shard& shard) const
ShardManager::ShardManager()
{
spinlock_init(&m_lock);
}
ShardManager::~ShardManager()
@ -181,7 +180,7 @@ ShardManager::~ShardManager()
Shard ShardManager::get_shard(std::string user, double max_interval)
{
mxs::SpinLockGuard guard(m_lock);
std::lock_guard<std::mutex> guard(m_lock);
ShardMap::iterator iter = m_maps.find(user);
@ -203,7 +202,7 @@ Shard ShardManager::get_shard(std::string user, double max_interval)
void ShardManager::update_shard(Shard& shard, std::string user)
{
mxs::SpinLockGuard guard(m_lock);
std::lock_guard<std::mutex> guard(m_lock);
ShardMap::iterator iter = m_maps.find(user);
if (iter == m_maps.end() || shard.newer_than(iter->second))

10
server/modules/routing/schemarouter/shard_map.hh
View File

@ -14,12 +14,12 @@
#include <maxscale/ccdefs.hh>
#include <unordered_map>
#include <string>
#include <list>
#include <mutex>
#include <string>
#include <unordered_map>
#include <maxscale/service.h>
#include <maxscale/spinlock.hh>
using namespace maxscale;
@ -142,6 +142,6 @@ public:
void update_shard(Shard& shard, std::string user);
private:
SPINLOCK m_lock;
ShardMap m_maps;
mutable std::mutex m_lock;
ShardMap m_maps;
};