Merge branch '2.2' into develop

Documentation/Release-Notes/MaxScale-2.1.13-Release-Notes.md

@@ -1,4 +1,4 @@
-# MariaDB MaxScale 2.1.13 Release Notes
+# MariaDB MaxScale 2.1.13 Release Notes  -- 2017-01-05
 
 Release 2.1.13 is a GA release.
 

maxscale-system-test/.gitignore

@@ -180,6 +180,7 @@ mysqlmon_failover_auto
 mysqlmon_failover_manual
 mysqlmon_rejoin_good
 mysqlmon_rejoin_bad
+mysqlmon_rejoin_bad2
 namedserverfilter
 no_password
 non_native_setup

maxscale-system-test/CMakeLists.txt

@@ -278,6 +278,9 @@ add_test_executable(mysqlmon_rejoin_good.cpp mysqlmon_rejoin_good mysqlmon_rejoi
 # MySQL Monitor Rejoin (bad) Test, use template for Rejoin (good)
 add_test_executable(mysqlmon_rejoin_bad.cpp mysqlmon_rejoin_bad mysqlmon_rejoin_good LABELS mysqlmon REPL_BACKEND)
 
+# MySQL Monitor Rejoin (bad2) Test, use template for Rejoin (good)
+add_test_executable(mysqlmon_rejoin_bad2.cpp mysqlmon_rejoin_bad2 mysqlmon_rejoin_good LABELS mysqlmon REPL_BACKEND)
+
 # MySQL Monitor rolling master
 add_test_executable(mysqlmon_failover_rolling_master.cpp mysqlmon_failover_rolling_master mysqlmon_failover_rolling_master LABELS mysqlmon REPL_BACKEND)
 

maxscale-system-test/mysqlmon_rejoin_bad2.cpp

@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) 2016 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: 2020-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.
+ */
+
+#include <vector>
+#include <iostream>
+#include <iterator>
+
+#include "testconnections.h"
+#include "fail_switch_rejoin_common.cpp"
+
+using std::string;
+using std::cout;
+using std::endl;
+
+static void expect(TestConnections& test, const char* zServer, const StringSet& expected)
+{
+    StringSet found = test.get_server_status(zServer);
+
+    std::ostream_iterator<string> oi(cout, ", ");
+
+    cout << zServer
+         << ", expected states: ";
+    std::copy(expected.begin(), expected.end(), oi);
+    cout << endl;
+
+    cout << zServer
+         << ", found states   : ";
+    std::copy(found.begin(), found.end(), oi);
+    cout << endl;
+
+    if (found != expected)
+    {
+        cout << "ERROR, found states are not the same as the expected ones." << endl;
+        ++test.global_result;
+    }
+
+    cout << endl;
+}
+
+static void expect(TestConnections& test, const char* zServer, const char* zState)
+{
+    StringSet s;
+    s.insert(zState);
+
+    expect(test, zServer, s);
+}
+
+static void expect(TestConnections& test, const char* zServer, const char* zState1, const char* zState2)
+{
+    StringSet s;
+    s.insert(zState1);
+    s.insert(zState2);
+
+    expect(test, zServer, s);
+}
+
+int main(int argc, char** argv)
+{
+    char result_tmp[bufsize];
+    interactive = strcmp(argv[argc - 1], "interactive") == 0;
+    Mariadb_nodes::require_gtid(true);
+    TestConnections test(argc, argv);
+    MYSQL* maxconn = test.maxscales->open_rwsplit_connection(0);
+
+    // Set up test table
+    basic_test(test);
+    // Delete binlogs to sync gtid:s
+    delete_slave_binlogs(test);
+    // Advance gtid:s a bit to so gtid variables are updated.
+    generate_traffic_and_check(test, maxconn, 5);
+    test.repl->sync_slaves(0);
+    get_output(test);
+
+    print_gtids(test);
+    get_input();
+    mysql_close(maxconn);
+
+    // Stop master, wait for failover
+    cout << "Stopping master, should auto-failover." << endl;
+    int master_id_old = get_master_server_id(test);
+    test.repl->stop_node(0);
+    sleep(5);
+    get_output(test);
+    int master_id_new = get_master_server_id(test);
+    cout << "Master server id is " << master_id_new << endl;
+    test.assert(master_id_new > 0 && master_id_new != master_id_old,
+        "Failover did not promote a new master.");
+    if (test.global_result != 0)
+    {
+        return test.global_result;
+    }
+
+    // Stop maxscale to prevent an unintended rejoin.
+    if (test.stop_maxscale(0))
+    {
+        test.assert(false, "Could not stop MaxScale.");
+        return test.global_result;
+    }
+    // Restart old master. Then add some events to it.
+    test.repl->start_node(0, (char*)"");
+    sleep(3);
+    test.repl->connect();
+    cout << "Adding more events to node 0. It should not join the cluster." << endl;
+    generate_traffic_and_check(test, test.repl->nodes[0], 5);
+    print_gtids(test);
+    // Restart maxscale. Should not rejoin old master.
+    if (test.start_maxscale(0))
+    {
+        test.assert(false, "Could not start MaxScale.");
+        return test.global_result;
+    }
+    sleep(5);
+    get_output(test);
+
+    expect(test, "server1", "Running");
+    if (test.global_result != 0)
+    {
+        cout << "Old master is a member or the cluster when it should not be." << endl;
+        return test.global_result;
+    }
+
+    // Manually set current master to replicate from the old master to quickly fix the cluster.
+    cout << "Setting server " << master_id_new << " to replicate from server 1. Auto-rejoin should redirect "
+        "servers so that in the end server 1 is master and all others are slaves." << endl;
+    const char CHANGE_CMD_FMT[] = "CHANGE MASTER TO MASTER_HOST = '%s', MASTER_PORT = %d, "
+        "MASTER_USE_GTID = current_pos, MASTER_USER='repl', MASTER_PASSWORD = 'repl';";
+    char cmd[256];
+    int ind = master_id_new - 1;
+    snprintf(cmd, sizeof(cmd), CHANGE_CMD_FMT, test.repl->IP[0], test.repl->port[0]);
+    MYSQL** nodes = test.repl->nodes;
+    mysql_query(nodes[ind], cmd);
+    mysql_query(nodes[ind], "START SLAVE;");
+    sleep(5);
+    get_output(test);
+
+    expect(test, "server1", "Master", "Running");
+    expect(test, "server2", "Slave", "Running");
+    expect(test, "server3", "Slave", "Running");
+    expect(test, "server4", "Slave", "Running");
+    return test.global_result;
+}

maxscale-system-test/testconnections.cpp

@@ -316,7 +316,7 @@ TestConnections::~TestConnections()
 
     copy_all_logs();
 
-/*  Temporary commnted out due to Galera failure in case of revert
+    /* Temporary disable snapshot revert due to Galera failures
     if (global_result != 0 )
     {
         if (no_vm_revert)
@@ -328,7 +328,8 @@ TestConnections::~TestConnections()
             tprintf("Reverting snapshot\n");
             revert_snapshot((char*) "clean");
         }
-    }*/
+    }
+    */
 
     delete repl;
     if (!no_galera)

query_classifier/qc_sqlite/qc_sqlite.cc

@@ -156,12 +156,15 @@ static thread_local struct
     sqlite3* pDb;                            // Thread specific database handle.
     qc_sql_mode_t sql_mode;                  // What sql_mode is used.
     QcSqliteInfo* pInfo;                     // The information for the current statement being classified.
+    uint64_t version;                        // Encoded version number
     uint32_t version_major;
     uint32_t version_minor;
     uint32_t version_patch;
     QC_NAME_MAPPING* pFunction_name_mappings; // How function names should be mapped.
 } this_thread;
 
+const uint64_t VERSION_103 = 10 * 10000 + 3 * 100;
+
 /**
  * HELPERS
  */
@@ -492,7 +495,10 @@ public:
      */
     bool must_check_sequence_related_functions() const
     {
-        return (m_sql_mode == QC_SQL_MODE_ORACLE) || (this_unit.parse_as == QC_PARSE_AS_103);
+        return
+            (m_sql_mode == QC_SQL_MODE_ORACLE) ||
+            (this_unit.parse_as == QC_PARSE_AS_103) ||
+            (this_thread.version >= VERSION_103);
     }
 
     /**
@@ -530,7 +536,7 @@ public:
             }
         }
 
-        if (!rv && (this_unit.parse_as == QC_PARSE_AS_103))
+        if (!rv && ((this_unit.parse_as == QC_PARSE_AS_103) || (this_thread.version >= VERSION_103)))
         {
             if ((strcasecmp(zFunc_name, "lastval") == 0) ||
                 (strcasecmp(zFunc_name, "nextval") == 0))
@@ -4942,6 +4948,7 @@ static void qc_sqlite_set_server_version(uint64_t version)
     uint32_t minor = (version - major * 10000) / 100;
     uint32_t patch = version - major * 10000 - minor * 100;
 
+    this_thread.version = version;
     this_thread.version_major = major;
     this_thread.version_minor = minor;
     this_thread.version_patch = patch;
@@ -4951,10 +4958,7 @@ static void qc_sqlite_get_server_version(uint64_t* pVersion)
 {
     QC_TRACE();
 
-    *pVersion =
+    *pVersion = this_thread.version;
-        this_thread.version_major * 10000 +
-        this_thread.version_minor * 100 +
-        this_thread.version_patch;
 }
 
 

query_classifier/qc_sqlite/sqlite-src-3110100/src/parse.y

@@ -623,7 +623,7 @@ columnid(A) ::= nm(X). {
   /*KEY*/
   /*LIKE_KW*/
   MASTER /*MATCH*/ MERGE
-  NAMES
+  NAMES NEXT
   NO
   OF OFFSET OPEN
   QUICK
@@ -1207,6 +1207,14 @@ selcollist(A) ::= sclp(P) nm(X) DOT STAR(Y). {
   A = sqlite3ExprListAppend(pParse,P, pDot);
 }
 %ifdef MAXSCALE
+selcollist(A) ::= sclp(P) NEXT VALUE FOR nm(X) as(Y).     {
+  Expr* pSeq = sqlite3PExpr(pParse, TK_ID, 0, 0, &X);
+  ExprList* pArgs = sqlite3ExprListAppend(pParse, NULL, pSeq);
+  Token nextval = { "nextval", 7 };
+  Expr* pFunc = sqlite3ExprFunction(pParse, pArgs, &nextval);
+  if( Y.n>0 ) sqlite3ExprListSetName(pParse, A, &Y, 1);
+  A = sqlite3ExprListAppend(pParse, P, pFunc);
+}
 selcollist(A) ::= sclp(P) DEFAULT LP nm RP as. {
   A = P;
 }

query_classifier/qc_sqlite/sqlite-src-3110100/tool/mkkeywordhash.c

@@ -269,7 +269,11 @@ static Keyword aKeywordTable[] = {
   { "FLUSH",            "TK_FLUSH",        ALWAYS                 },
   { "FOLLOWING",        "TK_FOLLOWING",    ALWAYS                 },
 #endif
+#ifdef MAXSCALE
+  { "FOR",              "TK_FOR",          ALWAYS                 },
+#else
   { "FOR",              "TK_FOR",          TRIGGER                },
+#endif
 #ifdef MAXSCALE
   { "FORCE",            "TK_FORCE",        ALWAYS                 },
 #endif
@@ -342,6 +346,9 @@ static Keyword aKeywordTable[] = {
   { "NAMES",            "TK_NAMES",        ALWAYS                 },
 #endif
   { "NATURAL",          "TK_JOIN_KW",      ALWAYS                 },
+#ifdef MAXSCALE
+  { "NEXT",             "TK_NEXT",         ALWAYS                 },
+#endif
   { "NO",               "TK_NO",           FKEY                   },
   { "NOT",              "TK_NOT",          ALWAYS                 },
   { "NOTNULL",          "TK_NOTNULL",      ALWAYS                 },

query_classifier/test/CMakeLists.txt

@@ -32,7 +32,9 @@ if (BUILD_QC_MYSQLEMBEDDED)
 
   add_test(TestQC_Crash_qcsqlite crash_qc_sqlite)
 
-  add_test(TestQC_MySQLEmbedded classify qc_mysqlembedded ${CMAKE_CURRENT_SOURCE_DIR}/input.sql ${CMAKE_CURRENT_SOURCE_DIR}/expected.sql)
+  # TestQC_MySQLEmbedded excluded, classify is now solely used for verifying the
+  # functionality of qc_sqlite.
+  #add_test(TestQC_MySQLEmbedded classify qc_mysqlembedded ${CMAKE_CURRENT_SOURCE_DIR}/input.sql ${CMAKE_CURRENT_SOURCE_DIR}/expected.sql)
   add_test(TestQC_SqLite classify qc_sqlite ${CMAKE_CURRENT_SOURCE_DIR}/input.sql ${CMAKE_CURRENT_SOURCE_DIR}/expected.sql)
 
   add_test(TestQC_CompareCreate compare -v 2 ${CMAKE_CURRENT_SOURCE_DIR}/create.test)

query_classifier/test/classify.c

@@ -317,6 +317,11 @@ int main(int argc, char** argv)
                 qc_process_init(QC_INIT_BOTH) &&
                 qc_thread_init(QC_INIT_BOTH))
             {
+                //  Version encoded as MariaDB encodes the version, i.e.:
+                //  version = major * 10000 + minor * 100 + patch
+                uint64_t version = 10 * 10000 + 3 * 100;
+
+                qc_set_server_version(version);
                 rc = run(input_name, expected_name);
                 qc_process_end(QC_INIT_BOTH);
             }

query_classifier/test/expected.sql

@@ -16,3 +16,6 @@ QUERY_TYPE_READ|QUERY_TYPE_MASTER_READ
 QUERY_TYPE_READ|QUERY_TYPE_MASTER_READ
 QUERY_TYPE_READ|QUERY_TYPE_MASTER_READ
 QUERY_TYPE_READ|QUERY_TYPE_SYSVAR_READ
+QUERY_TYPE_READ|QUERY_TYPE_WRITE
+QUERY_TYPE_READ|QUERY_TYPE_WRITE
+QUERY_TYPE_READ|QUERY_TYPE_WRITE

query_classifier/test/input.sql

@@ -16,3 +16,6 @@ select last_insert_id();
 select @@last_insert_id;
 select @@identity;
 select if(@@hostname='box02','prod_mariadb02','n');
+select next value for seq1;
+select nextval(seq1);
+select seq1.nextval;

server/core/gateway.cc

@@ -204,7 +204,7 @@ const DEBUG_ARGUMENT debug_arguments[] =
     {
         "disable-module-unloading", disable_module_unloading,
         "disable module unloading at exit. Will produce better\n"
-        SPACER "Valgring leak reports if leaked memory was allocated in\n"
+        SPACER "Valgrind leak reports if leaked memory was allocated in\n"
         SPACER "a shared library"
     },
     {

server/core/internal/skygw_utils.h

@@ -40,15 +40,6 @@ typedef struct simple_mutex_st
     skygw_chk_t     sm_chk_tail;
 } simple_mutex_t;
 
-typedef struct skygw_rwlock_st
-{
-    skygw_chk_t       srw_chk_top;
-    pthread_rwlock_t* srw_rwlock;
-    pthread_t         srw_rwlock_thr;
-    skygw_chk_t       srw_chk_tail;
-} skygw_rwlock_t;
-
-
 typedef enum { THR_INIT, THR_RUNNING, THR_STOPPED, THR_DONE } skygw_thr_state_t;
 typedef enum { MES_RC_FAIL, MES_RC_SUCCESS, MES_RC_TIMEOUT } skygw_mes_rc_t;
 
@@ -140,9 +131,6 @@ int skygw_file_write(skygw_file_t* file,
                      bool          flush);
 /** Skygw file routines */
 
-void acquire_lock(int* l);
-void release_lock(int* l);
-
 simple_mutex_t* simple_mutex_init(simple_mutex_t* mutexptr, const char* name);
 int simple_mutex_done(simple_mutex_t* sm);
 int simple_mutex_lock(simple_mutex_t* sm, bool block);
@@ -158,11 +146,6 @@ void skygw_message_reset(skygw_message_t* mes);
 
 /** Skygw message routines */
 
-int skygw_rwlock_wrlock(skygw_rwlock_t* rwlock);
-int skygw_rwlock_rdlock(skygw_rwlock_t* rwlock);
-int skygw_rwlock_unlock(skygw_rwlock_t* rwlock);
-int skygw_rwlock_init(skygw_rwlock_t** rwlock);
-
 size_t get_decimal_len(size_t s);
 
 MXS_END_DECLS

server/core/load_utils.cc

@@ -23,6 +23,7 @@
 #include <unistd.h>
 #include <string.h>
 #include <dlfcn.h>
+#include <algorithm>
 
 #include <maxscale/modinfo.h>
 #include <maxscale/log_manager.h>
@@ -139,9 +140,14 @@ void *load_module(const char *module, const char *type)
 
     if ((mod = find_module(module)) == NULL)
     {
+        size_t len = strlen(module);
+        char lc_module[len + 1];
+        lc_module[len] = 0;
+        std::transform(module, module + len, lc_module, tolower);
+
         /** The module is not already loaded, search for the shared object */
         char fname[MAXPATHLEN + 1];
-        snprintf(fname, MAXPATHLEN + 1, "%s/lib%s.so", get_libdir(), module);
+        snprintf(fname, MAXPATHLEN + 1, "%s/lib%s.so", get_libdir(), lc_module);
 
         if (access(fname, F_OK) == -1)
         {
@@ -219,7 +225,7 @@ find_module(const char *module)
     {
         while (mod)
         {
-            if (strcmp(mod->module, module) == 0)
+            if (strcasecmp(mod->module, module) == 0)
             {
                 return mod;
             }

server/core/log_manager.cc

@@ -154,7 +154,7 @@ typedef struct logmanager  logmanager_t;
  * Global log manager pointer and lock variable.
  * lmlock protects logmanager access.
  */
-static int lmlock;
+static SPINLOCK lmlock = SPINLOCK_INIT;
 static logmanager_t* lm;
 static bool flushall_flag;
 static bool flushall_started_flag;
@@ -370,7 +370,7 @@ struct logfile
     size_t           lf_buf_size;
     bool             lf_flushflag;
     bool             lf_rotateflag;
-    int              lf_spinlock; /**< lf_flushflag & lf_rotateflag */
+    SPINLOCK         lf_spinlock; /**< lf_flushflag & lf_rotateflag */
 #if defined(SS_DEBUG)
     skygw_chk_t      lf_chk_tail;
 #endif
@@ -599,7 +599,7 @@ bool mxs_log_init(const char* ident, const char* logdir, mxs_log_target_t target
 {
     bool succ = false;
 
-    acquire_lock(&lmlock);
+    spinlock_acquire(&lmlock);
 
     if (!lm)
     {
@@ -634,7 +634,7 @@ bool mxs_log_init(const char* ident, const char* logdir, mxs_log_target_t target
         succ = true;
     }
 
-    release_lock(&lmlock);
+    spinlock_release(&lmlock);
 
     return succ;
 }
@@ -693,7 +693,7 @@ static void logmanager_done_nomutex(void)
  */
 void mxs_log_finish(void)
 {
-    acquire_lock(&lmlock);
+    spinlock_acquire(&lmlock);
 
     if (lm)
     {
@@ -706,9 +706,9 @@ void mxs_log_finish(void)
          */
         while (lm != NULL && lm->lm_nlinks != 0)
         {
-            release_lock(&lmlock);
+            spinlock_release(&lmlock);
             sched_yield();
-            acquire_lock(&lmlock);
+            spinlock_acquire(&lmlock);
         }
 
         /** Shut down if not already shutted down. */
@@ -719,7 +719,7 @@ void mxs_log_finish(void)
         }
     }
 
-    release_lock(&lmlock);
+    spinlock_release(&lmlock);
 }
 
 static logfile_t* logmanager_get_logfile(logmanager_t* lmgr)
@@ -1330,7 +1330,7 @@ static bool logmanager_register(bool writep)
 {
     bool succ = true;
 
-    acquire_lock(&lmlock);
+    spinlock_acquire(&lmlock);
 
     if (lm == NULL || !lm->lm_enabled)
     {
@@ -1355,9 +1355,9 @@ static bool logmanager_register(bool writep)
          */
         while (lm != NULL && !lm->lm_enabled)
         {
-            release_lock(&lmlock);
+            spinlock_release(&lmlock);
             sched_yield();
-            acquire_lock(&lmlock);
+            spinlock_acquire(&lmlock);
         }
 
         if (lm == NULL)
@@ -1380,7 +1380,7 @@ return_succ:
     {
         fatal_error = true;
     }
-    release_lock(&lmlock);
+    spinlock_release(&lmlock);
     return succ;
 }
 
@@ -1399,12 +1399,12 @@ return_succ:
  */
 static void logmanager_unregister(void)
 {
-    acquire_lock(&lmlock);
+    spinlock_acquire(&lmlock);
 
     lm->lm_nlinks -= 1;
     ss_dassert(lm->lm_nlinks >= 0);
 
-    release_lock(&lmlock);
+    spinlock_release(&lmlock);
 }
 
 
@@ -1461,9 +1461,9 @@ static bool fnames_conf_init(fnames_conf_t* fn, const char* logdir)
 static void logfile_flush(logfile_t* lf)
 {
     CHK_LOGFILE(lf);
-    acquire_lock(&lf->lf_spinlock);
+    spinlock_acquire(&lf->lf_spinlock);
     lf->lf_flushflag = true;
-    release_lock(&lf->lf_spinlock);
+    spinlock_release(&lf->lf_spinlock);
     skygw_message_send(lf->lf_logmes);
 }
 
@@ -1476,9 +1476,9 @@ static void logfile_flush(logfile_t* lf)
 static void logfile_rotate(logfile_t* lf)
 {
     CHK_LOGFILE(lf);
-    acquire_lock(&lf->lf_spinlock);
+    spinlock_acquire(&lf->lf_spinlock);
     lf->lf_rotateflag = true;
-    release_lock(&lf->lf_spinlock);
+    spinlock_release(&lf->lf_spinlock);
     skygw_message_send(lf->lf_logmes);
 }
 
@@ -1867,7 +1867,7 @@ static bool logfile_init(logfile_t*    logfile,
     logfile->lf_lmgr = logmanager;
     logfile->lf_flushflag = false;
     logfile->lf_rotateflag = false;
-    logfile->lf_spinlock = 0;
+    logfile->lf_spinlock = SPINLOCK_INIT;
     logfile->lf_store_shmem = store_shmem;
     logfile->lf_buf_size = MAX_LOGSTRLEN;
     /**
@@ -2126,12 +2126,12 @@ static bool thr_flush_file(logmanager_t *lm, filewriter_t *fwr)
     /**
      * read and reset logfile's flush- and rotateflag
      */
-    acquire_lock(&lf->lf_spinlock);
+    spinlock_acquire(&lf->lf_spinlock);
     bool flush_logfile  = lf->lf_flushflag;
     bool rotate_logfile = lf->lf_rotateflag;
     lf->lf_flushflag  = false;
     lf->lf_rotateflag = false;
-    release_lock(&lf->lf_spinlock);
+    spinlock_release(&lf->lf_spinlock);
 
     // fwr->fwr_file may be NULL if an earlier log-rotation failed.
     if (rotate_logfile || !fwr->fwr_file)
@@ -2316,7 +2316,9 @@ static void* thr_filewriter_fun(void* data)
 
     /** Inform log manager about the state. */
     skygw_message_send(fwr->fwr_clientmes);
-    while (!skygw_thread_must_exit(thr))
+    bool running = true;
+
+    do
     {
         /**
          * Wait until new log arrival message appears.
@@ -2342,14 +2344,23 @@ static void* thr_filewriter_fun(void* data)
             }
         }
 
+        bool send_message = false;
+
         if (flushall_done_flag)
         {
             flushall_done_flag = false;
             flushall_logfiles(false);
-            skygw_message_send(fwr->fwr_clientmes);
+            send_message = true;
         }
 
-    } /* while (!skygw_thread_must_exit) */
+        running = !skygw_thread_must_exit(thr);
+
+        if (running && send_message)
+        {
+            skygw_message_send(fwr->fwr_clientmes);
+        }
+    }
+    while (running);
 
     ss_debug(skygw_thread_set_state(thr, THR_STOPPED));
     /** Inform log manager that file writer thread has stopped. */

server/core/maxscale_pcre2.cc

@@ -143,18 +143,14 @@ void mxs_pcre2_print_error(int errorcode, const char *module_name, const char *f
 {
     ss_dassert(filename);
     ss_dassert(func_name);
-
+    if (mxs_log_priority_is_enabled(LOG_ERR))
-    char errorbuf[100];
+    {
-    int err_msg_rval = pcre2_get_error_message(errorcode, (PCRE2_UCHAR*)errorbuf,
+        // 120 should be enough to contain any error message according to pcre2 manual.
-                                               sizeof(errorbuf));
+        const PCRE2_SIZE errbuf_len = 120;
-
+        PCRE2_UCHAR errorbuf[errbuf_len];
+        pcre2_get_error_message(errorcode, errorbuf, errbuf_len);
         mxs_log_message(LOG_ERR, module_name, filename, line_num, func_name,
                         "PCRE2 Error message: '%s'.", errorbuf);
-    if (err_msg_rval == PCRE2_ERROR_NOMEMORY)
-    {
-        mxs_log_message(LOG_ERR, module_name, filename, line_num, func_name,
-                        "PCRE2 error buffer was too small to contain the complete"
-                        "message.");
     }
 }
 

server/core/modulecmd.cc

@@ -323,7 +323,7 @@ static bool process_argument(const MODULECMD *cmd, modulecmd_arg_type_t *type, c
             if ((arg->value.monitor = monitor_find((char*)value)))
             {
                 const char* eff_name = mxs_module_get_effective_name(arg->value.monitor->module_name);
-                if (MODULECMD_ALLOW_NAME_MISMATCH(type) || strcmp(cmd->domain, eff_name) == 0)
+                if (MODULECMD_ALLOW_NAME_MISMATCH(type) || strcasecmp(cmd->domain, eff_name) == 0)
                 {
                     arg->type.type = MODULECMD_ARG_MONITOR;
                     rval = true;
@@ -343,7 +343,7 @@ static bool process_argument(const MODULECMD *cmd, modulecmd_arg_type_t *type, c
             if ((arg->value.filter = filter_def_find((char*)value)))
             {
                 const char* eff_name = mxs_module_get_effective_name(arg->value.filter->module);
-                if (MODULECMD_ALLOW_NAME_MISMATCH(type) || strcmp(cmd->domain, eff_name) == 0)
+                if (MODULECMD_ALLOW_NAME_MISMATCH(type) || strcasecmp(cmd->domain, eff_name) == 0)
                 {
                     arg->type.type = MODULECMD_ARG_FILTER;
                     rval = true;

server/core/server.cc

@@ -706,10 +706,6 @@ server_status(const SERVER *server)
     {
         strcat(status, "Slave of External Server, ");
     }
-    if (server_status & SERVER_STALE_STATUS)
-    {
-        strcat(status, "Stale Status, ");
-    }
     if (server_status & SERVER_MASTER_STICKINESS)
     {
         strcat(status, "Master Stickiness, ");

server/core/service.cc

@@ -1624,6 +1624,9 @@ int service_refresh_users(SERVICE *service)
     if ((service->capabilities & ACAP_TYPE_ASYNC) == 0)
     {
         spinlock_acquire(&service->spin);
+        // Use only one rate limitation for synchronous authenticators to keep
+        // rate limitations synchronous as well
+        self = 0;
     }
 
     /* Check if refresh rate limit has been exceeded */

server/core/skygw_utils.cc

@@ -43,117 +43,6 @@ static void simple_mutex_free_memory(simple_mutex_t* sm);
 static void thread_free_memory(skygw_thread_t* th, char* name);
 /** End of static function declarations */
 
-
-int skygw_rwlock_rdlock(skygw_rwlock_t* rwlock)
-{
-    int err = pthread_rwlock_rdlock(rwlock->srw_rwlock);
-
-    if (err == 0)
-    {
-        rwlock->srw_rwlock_thr = pthread_self();
-    }
-    else
-    {
-        rwlock->srw_rwlock_thr = 0;
-        ss_dfprintf(stderr,
-                    "* pthread_rwlock_rdlock : %s\n",
-                    mxs_strerror(err));
-    }
-    return err;
-}
-
-int skygw_rwlock_wrlock(skygw_rwlock_t* rwlock)
-{
-    int err = pthread_rwlock_wrlock(rwlock->srw_rwlock);
-
-    if (err == 0)
-    {
-        rwlock->srw_rwlock_thr = pthread_self();
-    }
-    else
-    {
-        rwlock->srw_rwlock_thr = 0;
-        ss_dfprintf(stderr,
-                    "* pthread_rwlock_wrlock : %s\n",
-                    mxs_strerror(err));
-    }
-    return err;
-}
-
-int skygw_rwlock_unlock(skygw_rwlock_t* rwlock)
-{
-    int err = pthread_rwlock_rdlock(rwlock->srw_rwlock);
-
-    if (err == 0)
-    {
-        rwlock->srw_rwlock_thr = 0;
-    }
-    else
-    {
-        ss_dfprintf(stderr, "* pthread_rwlock_unlock : %s\n",
-                    mxs_strerror(err));
-    }
-    return err;
-}
-
-int skygw_rwlock_destroy(skygw_rwlock_t* rwlock)
-{
-    int err;
-    /** Lock */
-    if ((err = pthread_rwlock_wrlock(rwlock->srw_rwlock)) != 0)
-    {
-        fprintf(stderr, "* Error : pthread_rwlock_wrlock failed due to %d, %s.\n",
-                err, mxs_strerror(err));
-        goto retblock;
-    }
-    /** Clean the struct */
-    rwlock->srw_rwlock_thr = 0;
-    /** Unlock */
-    pthread_rwlock_unlock(rwlock->srw_rwlock);
-    /** Destroy */
-    if ((err = pthread_rwlock_destroy(rwlock->srw_rwlock)) != 0)
-    {
-        fprintf(stderr, "* Error : pthread_rwlock_destroy failed due to %d,%s\n",
-                err, mxs_strerror(err));
-    }
-    else
-    {
-        rwlock->srw_rwlock = NULL;
-    }
-retblock:
-    return err;
-}
-
-int skygw_rwlock_init(skygw_rwlock_t** rwlock)
-{
-    skygw_rwlock_t* rwl;
-    int err;
-
-    rwl = (skygw_rwlock_t *) calloc(1, sizeof (skygw_rwlock_t));
-
-    if (rwl == NULL)
-    {
-        err = 1;
-        goto return_err;
-    }
-    rwl->srw_chk_top = CHK_NUM_RWLOCK;
-    rwl->srw_chk_tail = CHK_NUM_RWLOCK;
-    err = pthread_rwlock_init(rwl->srw_rwlock, NULL);
-    ss_dassert(err == 0);
-
-    if (err != 0)
-    {
-        free(rwl);
-        ss_dfprintf(stderr, "* Creating pthread_rwlock failed : %s\n",
-                    mxs_strerror(err));
-        goto return_err;
-    }
-    *rwlock = rwl;
-
-return_err:
-    return err;
-}
-
 size_t get_timestamp_len(void)
 {
     return timestamp_len;
@@ -429,7 +318,9 @@ bool skygw_thread_set_exitflag(skygw_thread_t* thr, skygw_message_t* sendmes,
         skygw_message_wait(recmes);
     }
 
+    ss_dassert(simple_mutex_lock(thr->sth_mutex, true) == 0);
     ss_dassert(thr->sth_state == THR_STOPPED);
+    ss_dassert(simple_mutex_unlock(thr->sth_mutex) == 0);
 
 return_succp:
     return succp;
@@ -447,29 +338,6 @@ bool skygw_thread_must_exit(skygw_thread_t* thr)
     return thr->sth_must_exit;
 }
 
-void acquire_lock(int* l)
-{
-    register int misscount = 0;
-    struct timespec ts1;
-    ts1.tv_sec = 0;
-
-    while (atomic_add(l, 1) != 0)
-    {
-        atomic_add(l, -1);
-        misscount += 1;
-        if (misscount > 10)
-        {
-            ts1.tv_nsec = misscount * 1000000;
-            nanosleep(&ts1, NULL);
-        }
-    }
-}
-
-void release_lock(int* l)
-{
-    atomic_add(l, -1);
-}
-
 /**
  * @node Create a simple_mutex structure which encapsulates pthread_mutex.
  *

server/core/test/test_log.cc

@@ -221,8 +221,6 @@ int main(int argc, char* argv[])
     err = MXS_NOTICE("%s", logstr);
     ss_dassert(err == 0);
 
-    succp = mxs_log_init(NULL, "/tmp", MXS_LOG_TARGET_FS);
-    ss_dassert(succp);
     skygw_log_enable(LOG_INFO);
     logstr = ("6.\tWrite to ERROR and thus also to MESSAGE and TRACE logs.");
     err = MXS_ERROR("%s", logstr);

server/modules/authenticator/CDCPlainAuth/CMakeLists.txt

@@ -1,4 +1,4 @@
-add_library(CDCPlainAuth SHARED cdc_plain_auth.c)
+add_library(cdcplainauth SHARED cdc_plain_auth.c)
-target_link_libraries(CDCPlainAuth maxscale-common)
+target_link_libraries(cdcplainauth maxscale-common)
-set_target_properties(CDCPlainAuth PROPERTIES VERSION "1.0.0")
+set_target_properties(cdcplainauth PROPERTIES VERSION "1.0.0")
-install_module(CDCPlainAuth core)
+install_module(cdcplainauth core)

server/modules/authenticator/GSSAPI/GSSAPIAuth/CMakeLists.txt

@@ -1,4 +1,4 @@
-add_library(GSSAPIAuth SHARED gssapi_auth.c ../gssapi_auth_common.c)
+add_library(gssapiauth SHARED gssapi_auth.c ../gssapi_auth_common.c)
-target_link_libraries(GSSAPIAuth maxscale-common ${GSSAPI_LIBS} ${SQLITE_LIBRARIES} MySQLCommon)
+target_link_libraries(gssapiauth maxscale-common ${GSSAPI_LIBS} ${SQLITE_LIBRARIES} mysqlcommon)
-set_target_properties(GSSAPIAuth PROPERTIES VERSION "1.0.0")
+set_target_properties(gssapiauth PROPERTIES VERSION "1.0.0")
-install_module(GSSAPIAuth core)
+install_module(gssapiauth core)

server/modules/authenticator/GSSAPI/GSSAPIBackendAuth/CMakeLists.txt

@@ -1,4 +1,4 @@
-add_library(GSSAPIBackendAuth SHARED gssapi_backend_auth.c ../gssapi_auth_common.c)
+add_library(gssapibackendauth SHARED gssapi_backend_auth.c ../gssapi_auth_common.c)
-target_link_libraries(GSSAPIBackendAuth maxscale-common  ${GSSAPI_LIBS} MySQLCommon)
+target_link_libraries(gssapibackendauth maxscale-common  ${GSSAPI_LIBS} mysqlcommon)
-set_target_properties(GSSAPIBackendAuth PROPERTIES VERSION "1.0.0")
+set_target_properties(gssapibackendauth PROPERTIES VERSION "1.0.0")
-install_module(GSSAPIBackendAuth core)
+install_module(gssapibackendauth core)

server/modules/authenticator/HTTPAuth/CMakeLists.txt

@@ -1,4 +1,4 @@
-add_library(HTTPAuth SHARED http_auth.c)
+add_library(httpauth SHARED http_auth.c)
-target_link_libraries(HTTPAuth maxscale-common)
+target_link_libraries(httpauth maxscale-common)
-set_target_properties(HTTPAuth PROPERTIES VERSION "1.0.0")
+set_target_properties(httpauth PROPERTIES VERSION "1.0.0")
-install_module(HTTPAuth core)
+install_module(httpauth core)

server/modules/authenticator/MaxAdminAuth/CMakeLists.txt

@@ -1,4 +1,4 @@
-add_library(MaxAdminAuth SHARED max_admin_auth.c)
+add_library(maxadminauth SHARED max_admin_auth.c)
-target_link_libraries(MaxAdminAuth maxscale-common)
+target_link_libraries(maxadminauth maxscale-common)
-set_target_properties(MaxAdminAuth PROPERTIES VERSION "1.0.0")
+set_target_properties(maxadminauth PROPERTIES VERSION "1.0.0")
-install_module(MaxAdminAuth core)
+install_module(maxadminauth core)

server/modules/authenticator/MySQLAuth/CMakeLists.txt

@@ -1,8 +1,8 @@
 if(SQLITE_VERSION VERSION_LESS 3.3)
   message(FATAL_ERROR "SQLite version 3.3 or higher is required")
 else()
-  add_library(MySQLAuth SHARED mysql_auth.c dbusers.c)
+  add_library(mysqlauth SHARED mysql_auth.c dbusers.c)
-  target_link_libraries(MySQLAuth maxscale-common MySQLCommon sqlite3)
+  target_link_libraries(mysqlauth maxscale-common mysqlcommon sqlite3)
-  set_target_properties(MySQLAuth PROPERTIES VERSION "1.0.0")
+  set_target_properties(mysqlauth PROPERTIES VERSION "1.0.0")
-  install_module(MySQLAuth core)
+  install_module(mysqlauth core)
 endif()

server/modules/authenticator/MySQLBackendAuth/CMakeLists.txt

@@ -1,4 +1,4 @@
-add_library(MySQLBackendAuth SHARED mysql_backend_auth.c)
+add_library(mysqlbackendauth SHARED mysql_backend_auth.c)
-target_link_libraries(MySQLBackendAuth maxscale-common MySQLCommon)
+target_link_libraries(mysqlbackendauth maxscale-common mysqlcommon)
-set_target_properties(MySQLBackendAuth PROPERTIES VERSION "1.0.0")
+set_target_properties(mysqlbackendauth PROPERTIES VERSION "1.0.0")
-install_module(MySQLBackendAuth core)
+install_module(mysqlbackendauth core)

server/modules/authenticator/NullAuthAllow/CMakeLists.txt

@@ -1,4 +1,4 @@
-add_library(NullAuthAllow SHARED null_auth_allow.c)
+add_library(nullauthallow SHARED null_auth_allow.c)
-target_link_libraries(NullAuthAllow maxscale-common MySQLCommon)
+target_link_libraries(nullauthallow maxscale-common mysqlcommon)
-set_target_properties(NullAuthAllow PROPERTIES VERSION "1.0.0")
+set_target_properties(nullauthallow PROPERTIES VERSION "1.0.0")
-install_module(NullAuthAllow core)
+install_module(nullauthallow core)

server/modules/authenticator/NullAuthDeny/CMakeLists.txt

@@ -1,4 +1,4 @@
-add_library(NullAuthDeny SHARED null_auth_deny.c)
+add_library(nullauthdeny SHARED null_auth_deny.c)
-target_link_libraries(NullAuthDeny maxscale-common)
+target_link_libraries(nullauthdeny maxscale-common)
-set_target_properties(NullAuthDeny PROPERTIES VERSION "1.0.0")
+set_target_properties(nullauthdeny PROPERTIES VERSION "1.0.0")
-install_module(NullAuthDeny core)
+install_module(nullauthdeny core)

server/modules/authenticator/PAM/PAMAuth/CMakeLists.txt

@@ -1,4 +1,4 @@
-add_library(PAMAuth SHARED pam_auth.cc ../pam_auth_common.cc pam_client_session.cc pam_instance.cc)
+add_library(pamauth SHARED pam_auth.cc ../pam_auth_common.cc pam_client_session.cc pam_instance.cc)
-target_link_libraries(PAMAuth maxscale-common ${PAM_LIBRARIES} ${SQLITE_LIBRARIES} MySQLCommon)
+target_link_libraries(pamauth maxscale-common ${PAM_LIBRARIES} ${SQLITE_LIBRARIES} mysqlcommon)
-set_target_properties(PAMAuth PROPERTIES VERSION "1.0.0")
+set_target_properties(pamauth PROPERTIES VERSION "1.0.0")
-install_module(PAMAuth core)
+install_module(pamauth core)

server/modules/authenticator/PAM/PAMAuth/pam_client_session.cc

@@ -203,9 +203,9 @@ PamClientSession:: ~PamClientSession()
 
 PamClientSession* PamClientSession::create(const PamInstance& inst)
 {
-    int db_flags = SQLITE_OPEN_READONLY | SQLITE_OPEN_SHAREDCACHE;
+    // This handle is only used from one thread, can define no_mutex.
     sqlite3* dbhandle = NULL;
-    // This handle is only used from one thread
+    int db_flags = SQLITE_OPEN_READONLY | SQLITE_OPEN_SHAREDCACHE |  SQLITE_OPEN_NOMUTEX;
     if (sqlite3_open_v2(inst.m_dbname.c_str(), &dbhandle, db_flags, NULL) == SQLITE_OK)
     {
         sqlite3_busy_timeout(dbhandle, 1000);

server/modules/authenticator/PAM/PAMBackendAuth/CMakeLists.txt

@@ -1,4 +1,4 @@
-add_library(PAMBackendAuth SHARED pam_backend_auth.cc ../pam_auth_common.cc pam_backend_session.cc)
+add_library(pambackendauth SHARED pam_backend_auth.cc ../pam_auth_common.cc pam_backend_session.cc)
-target_link_libraries(PAMBackendAuth maxscale-common MySQLCommon ${SQLITE_LIBRARIES})
+target_link_libraries(pambackendauth maxscale-common mysqlcommon ${SQLITE_LIBRARIES})
-set_target_properties(PAMBackendAuth PROPERTIES VERSION "1.0.0")
+set_target_properties(pambackendauth PROPERTIES VERSION "1.0.0")
-install_module(PAMBackendAuth core)
+install_module(pambackendauth core)

server/modules/filter/cache/CMakeLists.txt

@@ -17,7 +17,7 @@ if (JANSSON_FOUND)
     storagefactory.cc
     storagereal.cc
     )
-  target_link_libraries(cache maxscale-common ${JANSSON_LIBRARIES} MySQLCommon)
+  target_link_libraries(cache maxscale-common ${JANSSON_LIBRARIES} mysqlcommon)
   set_target_properties(cache PROPERTIES VERSION "1.0.0")
   set_target_properties(cache PROPERTIES LINK_FLAGS -Wl,-z,defs)
   install_module(cache core)

server/modules/filter/dbfwfilter/CMakeLists.txt

@@ -12,13 +12,13 @@ if(BISON_FOUND AND FLEX_FOUND)
   add_dependencies(dbfwfilter-core pcre2 connector-c)
 
   add_library(dbfwfilter SHARED dbfwfilter.cc)
-  target_link_libraries(dbfwfilter maxscale-common MySQLCommon dbfwfilter-core)
+  target_link_libraries(dbfwfilter maxscale-common mysqlcommon dbfwfilter-core)
   set_target_properties(dbfwfilter PROPERTIES VERSION "1.0.0")
   install_module(dbfwfilter core)
 
   # The offline rule check utility
   add_executable(dbfwchk dbfw_rule_check.cc)
-  target_link_libraries(dbfwchk maxscale-common MySQLCommon dbfwfilter-core)
+  target_link_libraries(dbfwchk maxscale-common mysqlcommon dbfwfilter-core)
   install_executable(dbfwchk core)
 
   if(BUILD_TESTS)

server/modules/filter/insertstream/CMakeLists.txt

@@ -1,4 +1,4 @@
 add_library(insertstream SHARED insertstream.c)
-target_link_libraries(insertstream maxscale-common MySQLCommon)
+target_link_libraries(insertstream maxscale-common mysqlcommon)
 set_target_properties(insertstream PROPERTIES VERSION "1.0.0")
 install_module(insertstream core)

server/modules/filter/tee/CMakeLists.txt

@@ -1,4 +1,4 @@
 add_library(tee SHARED tee.cc teesession.cc)
-target_link_libraries(tee maxscale-common MySQLCommon)
+target_link_libraries(tee maxscale-common mysqlcommon)
 set_target_properties(tee PROPERTIES VERSION "1.0.0")
 install_module(tee core)

server/modules/protocol/CDC/CMakeLists.txt

@@ -1,4 +1,4 @@
-add_library(CDC SHARED cdc.c)
+add_library(cdc SHARED cdc.c)
-target_link_libraries(CDC maxscale-common)
+target_link_libraries(cdc maxscale-common)
-set_target_properties(CDC PROPERTIES VERSION "1.0.1")
+set_target_properties(cdc PROPERTIES VERSION "1.0.1")
-install_module(CDC core)
+install_module(cdc core)

server/modules/protocol/MySQL/CMakeLists.txt

@@ -1,7 +1,7 @@
-add_library(MySQLCommon SHARED mysql_common.cc mariadb_client.cc)
+add_library(mysqlcommon SHARED mysql_common.cc mariadb_client.cc)
-target_link_libraries(MySQLCommon maxscale-common)
+target_link_libraries(mysqlcommon maxscale-common)
-set_target_properties(MySQLCommon PROPERTIES VERSION "2.0.0")
+set_target_properties(mysqlcommon PROPERTIES VERSION "2.0.0")
-install_module(MySQLCommon core)
+install_module(mysqlcommon core)
 
 add_subdirectory(MySQLBackend)
 add_subdirectory(MySQLClient)

server/modules/protocol/MySQL/MySQLBackend/CMakeLists.txt

@@ -1,7 +1,7 @@
-add_library(MySQLBackend SHARED mysql_backend.c)
+add_library(mysqlbackend SHARED mysql_backend.c)
 # TODO: Refactor MySQLBackend so that COM_CHANGE_USER processing is
 # transparent to the protocol module. After this change, we don't need to
 # link against MySQLAuth.
-target_link_libraries(MySQLBackend maxscale-common MySQLCommon MySQLAuth)
+target_link_libraries(mysqlbackend maxscale-common mysqlcommon mysqlauth)
-set_target_properties(MySQLBackend PROPERTIES VERSION "2.0.0")
+set_target_properties(mysqlbackend PROPERTIES VERSION "2.0.0")
-install_module(MySQLBackend core)
+install_module(mysqlbackend core)

server/modules/protocol/MySQL/MySQLClient/CMakeLists.txt

@@ -1,7 +1,7 @@
-add_library(MySQLClient SHARED mysql_client.cc)
+add_library(mysqlclient SHARED mysql_client.cc)
-target_link_libraries(MySQLClient maxscale-common  MySQLCommon)
+target_link_libraries(mysqlclient maxscale-common mysqlcommon)
-set_target_properties(MySQLClient PROPERTIES VERSION "1.0.0")
+set_target_properties(mysqlclient PROPERTIES VERSION "1.0.0")
-install_module(MySQLClient core)
+install_module(mysqlclient core)
 
 if(BUILD_TESTS)
   add_subdirectory(test)

server/modules/protocol/MySQL/test/CMakeLists.txt

@@ -1,4 +1,4 @@
 add_executable(test_parse_kill test_parse_kill.cc)
-target_link_libraries(test_parse_kill maxscale-common MySQLCommon)
+target_link_libraries(test_parse_kill maxscale-common mysqlcommon)
 add_test(test_parse_kill test_parse_kill)
 

server/modules/routing/readwritesplit/CMakeLists.txt

@@ -7,6 +7,6 @@ rwsplit_select_backends.cc
 rwsplit_session_cmd.cc
 rwsplit_tmp_table_multi.cc
 rwsplit_ps.cc)
-target_link_libraries(readwritesplit maxscale-common MySQLCommon)
+target_link_libraries(readwritesplit maxscale-common mysqlcommon)
 set_target_properties(readwritesplit PROPERTIES VERSION "1.0.2")
 install_module(readwritesplit core)

server/modules/routing/schemarouter/CMakeLists.txt

@@ -1,5 +1,5 @@
 add_library(schemarouter SHARED schemarouter.cc schemarouterinstance.cc schemaroutersession.cc shard_map.cc)
-target_link_libraries(schemarouter maxscale-common MySQLCommon)
+target_link_libraries(schemarouter maxscale-common mysqlcommon)
 add_dependencies(schemarouter pcre2)
 set_target_properties(schemarouter PROPERTIES VERSION "1.0.0")
 install_module(schemarouter core)