merge

config/ac-macros/misc.m4

@@ -456,10 +456,8 @@ fi
 AC_DEFUN([MYSQL_STACK_DIRECTION],
  [AC_CACHE_CHECK(stack direction for C alloca, ac_cv_c_stack_direction,
  [AC_TRY_RUN([#include <stdlib.h>
- /* Prevent compiler optimization by HP's compiler, see bug#42213 */
-#if defined(__HP_cc) || defined (__HP_aCC) || defined (__hpux)
-#pragma noinline
-#endif
+ /* Prevent compiler inline optimization, see bug#42213 */
+ int (volatile *ptr_f)();
  int find_stack_direction ()
  {
    static char *addr = 0;
@@ -467,14 +465,15 @@ AC_DEFUN([MYSQL_STACK_DIRECTION],
    if (addr == 0)
      {
        addr = &dummy;
-       return find_stack_direction ();
+       return (*prt_f) ();
      }
    else
      return (&dummy > addr) ? 1 : -1;
  }
  int main ()
  {
-   exit (find_stack_direction() < 0);
+   ptr_f = find_stack_direction;
+   exit ((*ptr_f)() < 0);
  }], ac_cv_c_stack_direction=1, ac_cv_c_stack_direction=-1,
    ac_cv_c_stack_direction=)])
  AC_DEFINE_UNQUOTED(STACK_DIRECTION, $ac_cv_c_stack_direction)

extra/yassl/taocrypt/include/misc.hpp

@@ -136,9 +136,13 @@ void CleanUp();
 
 // Turn on ia32 ASM for Big Integer
 // CodeWarrior defines _MSC_VER
+//
+// Do not use assembler with GCC, as the implementation for it is broken;
+// it does not use proper GCC asm contraints and makes assumptions about
+// frame pointers and so on, which breaks depending on GCC version and
+// optimization level.
 #if !defined(TAOCRYPT_DISABLE_X86ASM) && ((defined(_MSC_VER) && \
-   !defined(__MWERKS__) && defined(_M_IX86)) || \
-   (defined(__GNUC__) && defined(__i386__)))
+   !defined(__MWERKS__) && defined(_M_IX86)))
     #define TAOCRYPT_X86ASM_AVAILABLE
 #endif
 

mysql-test/suite/plugins/r/pam.result

@@ -2,7 +2,7 @@ install plugin pam soname 'auth_pam.so';
 create user test_pam identified via pam using 'mariadb_mtr';
 #
 # athentication is successful, challenge/pin are ok
-# note that current_user() differts from user()
+# note that current_user() differs from user()
 #
 Challenge input first.
 Enter: not very secret challenge

mysql-test/suite/plugins/t/pam.test

@@ -29,7 +29,7 @@ EOF
 
 --echo #
 --echo # athentication is successful, challenge/pin are ok
---echo # note that current_user() differts from user()
+--echo # note that current_user() differs from user()
 --echo #
 --exec $MYSQL_TEST -u test_pam --plugin-dir=$plugindir < $MYSQLTEST_VARDIR/tmp/pam_good.txt
 

plugin/auth_pam/mapper/pam_user_map.c

+/*
+  Pam module to change user names arbitrarily in the pam stack.
+
+  Compile as
+  
+     gcc pam_user_map.c -shared -lpam -fPIC -o pam_user_map.so
+
+  Install as appropriate (for example, in /lib/security/).
+  Add to your /etc/pam.d/mysql (preferrably, at the end) this line:
+=========================================================
+auth            required        pam_user_map.so
+=========================================================
+
+  And create /etc/security/user_map.conf with the desired mapping
+  in the format:  orig_user_name: mapped_user_name
+=========================================================
+#comments and emty lines are ignored
+john: jack
+bob:  admin
+top:  accounting
+=========================================================
+
+*/
+
+#include <stdio.h>
+#include <syslog.h>
+#include <security/pam_modules.h>
+
+#define FILENAME "/etc/security/user_map.conf"
+#define skip(what) while (*s && (what)) s++
+
+int pam_sm_authenticate(pam_handle_t *pamh, int flags,
+    int argc, const char *argv[])
+{
+  int pam_err, line= 0;
+  const char *username;
+  char buf[256];
+  FILE *f;
+
+  f= fopen(FILENAME, "r");
+  if (f == NULL)
+  {
+    pam_syslog(pamh, LOG_ERR, "Cannot open '%s'\n", FILENAME);
+    return PAM_SYSTEM_ERR;
+  }
+
+  pam_err = pam_get_item(pamh, PAM_USER, (const void**)&username);
+  if (pam_err != PAM_SUCCESS)
+    goto ret;
+
+  while (fgets(buf, sizeof(buf), f) != NULL)
+  {
+    char *s= buf, *from, *to, *end_from, *end_to;
+    line++;
+
+    skip(isspace(*s));
+    if (*s == '#' || *s == 0) continue;
+    from= s;
+    skip(isalnum(*s) || (*s == '_'));
+    end_from= s;
+    skip(isspace(*s));
+    if (end_from == from || *s++ != ':') goto syntax_error;
+    skip(isspace(*s));
+    to= s;
+    skip(isalnum(*s) || (*s == '_'));
+    end_to= s;
+    if (end_to == to) goto syntax_error;
+
+    *end_from= *end_to= 0;
+    if (strcmp(username, from) == 0)
+    {
+      pam_err= pam_set_item(pamh, PAM_USER, to);
+      goto ret;
+    }
+  }
+  pam_err= PAM_SUCCESS;
+  goto ret;
+
+syntax_error:
+  pam_syslog(pamh, LOG_ERR, "Syntax error at %s:%d", FILENAME, line);
+  pam_err= PAM_SYSTEM_ERR;
+ret:
+  fclose(f);
+  return pam_err;
+}
+
+int pam_sm_setcred(pam_handle_t *pamh, int flags,
+                   int argc, const char *argv[])
+{
+
+    return PAM_SUCCESS;
+}
+

plugin/auth_pam/testing/pam_mariadb_mtr.c

@@ -10,7 +10,7 @@
   Create /etc/pam.d/mariadb_mtr with
 =========================================================
 auth            required        pam_mariadb_mtr.so pam_test
-account         required        pam_mariadb_mtr.so
+account         required        pam_permit.so
 =========================================================
 */
 
@@ -21,8 +21,7 @@ account         required        pam_mariadb_mtr.so
 
 #define N 3
 
-PAM_EXTERN int
-pam_sm_authenticate(pam_handle_t *pamh, int flags,
+int pam_sm_authenticate(pam_handle_t *pamh, int flags,
                         int argc, const char *argv[])
 {
   struct pam_conv *conv;
@@ -69,16 +68,7 @@ pam_sm_authenticate(pam_handle_t *pamh, int flags,
   return retval;
 }
 
-PAM_EXTERN int
-pam_sm_setcred(pam_handle_t *pamh, int flags,
-    int argc, const char *argv[])
-{
-
-    return PAM_SUCCESS;
-}
-
-PAM_EXTERN int
-pam_sm_acct_mgmt(pam_handle_t *pamh, int flags,
+int pam_sm_setcred(pam_handle_t *pamh, int flags,
                    int argc, const char *argv[])
 {
 

scripts/mysql_install_db.sh

@@ -329,8 +329,10 @@ then
     cannot_find_file "$langdir/errmsg.sys"
     exit 1
   fi
-  mysqld_opt="--language=$langdir"
+else
+  langdir=english
 fi
+mysqld_opt="--language=$langdir"
 
 # Try to determine the hostname
 hostname=`@HOSTNAME@`

sql/create_options.cc

@@ -138,8 +138,8 @@ static bool set_one_value(ha_create_table_option *opt,
 
       my_option optp=
         { opt->name, 1, 0, (uchar **)val, 0, 0, GET_ULL,
-          REQUIRED_ARG, opt->def_value, opt->min_value, opt->max_value,
-          0, (long) opt->block_size, 0};
+          REQUIRED_ARG, (longlong)opt->def_value, (longlong)opt->min_value,
+          opt->max_value, 0, (long) opt->block_size, 0};
 
       ulonglong orig_val= strtoull(value->str, NULL, 10);
       my_bool unused;

sql/mysqld.cc

@@ -6177,7 +6177,7 @@ struct my_option my_long_options[] =
   {"debug-crc-break", OPT_DEBUG_CRC,
    "Call my_debug_put_break_here() if crc matches this number (for debug).",
    &opt_my_crc_dbug_check, &opt_my_crc_dbug_check,
-   0, GET_ULONG, REQUIRED_ARG, 0, 0, ~(ulong) 0L, 0, 0, 0},
+   0, GET_ULONG, REQUIRED_ARG, 0, 0, ~(ulonglong) 0, 0, 0, 0},
   {"debug-flush", OPT_DEBUG_FLUSH, "Default debug log with flush after write",
    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
   {"debug-assert-if-crashed-table", OPT_DEBUG_ASSERT_IF_CRASHED_TABLE,
@@ -6440,7 +6440,7 @@ each time the SQL thread starts.",
 #ifdef HAVE_MMAP
   {"log-tc-size", OPT_LOG_TC_SIZE, "Size of transaction coordinator log.",
    &opt_tc_log_size, &opt_tc_log_size, 0, GET_ULONG,
-   REQUIRED_ARG, TC_LOG_MIN_SIZE, TC_LOG_MIN_SIZE, (longlong) ULONG_MAX, 0,
+   REQUIRED_ARG, TC_LOG_MIN_SIZE, TC_LOG_MIN_SIZE, (ulonglong) ULONG_MAX, 0,
    TC_LOG_PAGE_SIZE, 0},
 #endif
   {"log-update", OPT_UPDATE_LOG,
@@ -7018,12 +7018,12 @@ each time the SQL thread starts.",
    "during a transaction. If you often use big, multi-statement "
    "transactions you can increase this to get more performance.",
    &binlog_cache_size, &binlog_cache_size, 0, GET_ULONG,
-   REQUIRED_ARG, 32*1024L, IO_SIZE, (longlong) ULONG_MAX, 0, IO_SIZE, 0},
+   REQUIRED_ARG, 32*1024L, IO_SIZE, (ulonglong) ULONG_MAX, 0, IO_SIZE, 0},
   {"bulk_insert_buffer_size", OPT_BULK_INSERT_BUFFER_SIZE,
    "Size of tree cache used in bulk insert optimization. Note that this "
    "is a limit per thread.", &global_system_variables.bulk_insert_buff_size,
    &max_system_variables.bulk_insert_buff_size,
-   0, GET_ULONG, REQUIRED_ARG, 8192*1024, 0, (longlong) ULONG_MAX, 0, 1, 0},
+   0, GET_ULONG, REQUIRED_ARG, 8192*1024, 0, (ulonglong) ULONG_MAX, 0, 1, 0},
   {"connect_timeout", OPT_CONNECT_TIMEOUT,
    "The number of seconds the mysqld server is waiting for a connect packet "
    "before responding with 'Bad handshake'.", &connect_timeout, &connect_timeout,
@@ -7048,7 +7048,7 @@ each time the SQL thread starts.",
    "will check if there are any SELECT statements pending. If so, it allows "
    "these to execute before continuing.",
     &delayed_insert_limit, &delayed_insert_limit, 0, GET_ULONG,
-    REQUIRED_ARG, DELAYED_LIMIT, 1, (longlong) ULONG_MAX, 0, 1, 0},
+    REQUIRED_ARG, DELAYED_LIMIT, 1, (ulonglong) ULONG_MAX, 0, 1, 0},
   {"delayed_insert_timeout", OPT_DELAYED_INSERT_TIMEOUT,
    "How long a INSERT DELAYED thread should wait for INSERT statements before terminating.",
    &delayed_insert_timeout, &delayed_insert_timeout, 0,
@@ -7058,7 +7058,7 @@ each time the SQL thread starts.",
     "If the queue becomes full, any client that does INSERT DELAYED will wait "
     "until there is room in the queue again.",
     &delayed_queue_size, &delayed_queue_size, 0, GET_ULONG,
-    REQUIRED_ARG, DELAYED_QUEUE_SIZE, 1, (longlong) ULONG_MAX, 0, 1, 0},
+    REQUIRED_ARG, DELAYED_QUEUE_SIZE, 1, (ulonglong) ULONG_MAX, 0, 1, 0},
   {"div_precision_increment", OPT_DIV_PRECINCREMENT,
    "Precision of the result of '/' operator will be increased on that value.",
    &global_system_variables.div_precincrement,
@@ -7098,7 +7098,7 @@ each time the SQL thread starts.",
     "The maximum length of the result of function group_concat.",
     &global_system_variables.group_concat_max_len,
     &max_system_variables.group_concat_max_len, 0, GET_ULONG,
-    REQUIRED_ARG, 1024, 4, (longlong) ULONG_MAX, 0, 1, 0},
+    REQUIRED_ARG, 1024, 4, (ulonglong) ULONG_MAX, 0, 1, 0},
   {"interactive_timeout", OPT_INTERACTIVE_TIMEOUT,
    "The number of seconds the server waits for activity on an interactive "
    "connection before closing it.",
@@ -7109,13 +7109,13 @@ each time the SQL thread starts.",
    "The size of the buffer that is used for joins.",
     &global_system_variables.join_buff_size,
     &max_system_variables.join_buff_size, 0, GET_ULONG,
-   REQUIRED_ARG, 128*1024L, 128+MALLOC_OVERHEAD, (longlong) ULONG_MAX,
+   REQUIRED_ARG, 128*1024L, 128+MALLOC_OVERHEAD, (ulonglong) ULONG_MAX,
    MALLOC_OVERHEAD, 128, 0},
   {"join_buffer_space_limit", OPT_JOIN_BUFF_SPACE_LIMIT,
    "The limit of the space for all join buffers used by a query.",
    &global_system_variables.join_buff_space_limit,
    &max_system_variables.join_buff_space_limit, 0, GET_ULL,
-   REQUIRED_ARG, 16*128*1024L, 2048+MALLOC_OVERHEAD, (longlong) ULONGLONG_MAX,
+   REQUIRED_ARG, 16*128*1024L, 2048+MALLOC_OVERHEAD, (ulonglong) ULONGLONG_MAX,
    MALLOC_OVERHEAD, 2048, 0},
    {"join_cache_level", OPT_JOIN_CACHE_LEVEL,
    "Controls what join operations can be executed with join buffers. Odd numbers are used for plain join buffers while even numbers are used for linked buffers",
@@ -7141,7 +7141,7 @@ each time the SQL thread starts.",
    "This specifies the percentage ratio of that number of hits to the total "
    "number of blocks in key cache.",
    &dflt_key_cache_var.param_age_threshold,  0, 0,
-   (GET_ULONG | GET_ASK_ADDR), REQUIRED_ARG, 300, 100, (longlong) ULONG_MAX,
+   (GET_ULONG | GET_ASK_ADDR), REQUIRED_ARG, 300, 100, (ulonglong) ULONG_MAX,
    0, 100, 0},
   {"key_cache_block_size", OPT_KEY_CACHE_BLOCK_SIZE,
    "The default size of key cache blocks.",
@@ -7167,7 +7167,7 @@ each time the SQL thread starts.",
    "this to reduce output on slow query log)",
    &global_system_variables.log_slow_rate_limit,
    &max_system_variables.log_slow_rate_limit, 0, GET_ULONG,
-   REQUIRED_ARG, 1, 1, ~0L, 0, 1L, 0},
+   REQUIRED_ARG, 1, 1, ~0ULL, 0, 1L, 0},
   {"log-slow-verbosity", OPT_LOG_SLOW_VERBOSITY,
    "Choose how verbose the messages to your slow log will be. Multiple flags "
    "allowed in a comma-separated string. [query_plan, innodb]",
@@ -7218,7 +7218,7 @@ each time the SQL thread starts.",
    "If there is more than this number of interrupted connections from a host "
    "this host will be blocked from further connections.",
    &max_connect_errors, &max_connect_errors, 0, GET_ULONG,
-  REQUIRED_ARG, MAX_CONNECT_ERRORS, 1, (longlong) ULONG_MAX, 0, 1, 0},
+  REQUIRED_ARG, MAX_CONNECT_ERRORS, 1, (ulonglong) ULONG_MAX, 0, 1, 0},
   // Default max_connections of 151 is larger than Apache's default max
   // children, to avoid "too many connections" error in a common setup
   {"max_connections", OPT_MAX_CONNECTIONS,
@@ -7287,7 +7287,7 @@ each time the SQL thread starts.",
    "Maximum number of temporary tables a client can keep open at a time.",
    &global_system_variables.max_tmp_tables,
    &max_system_variables.max_tmp_tables, 0, GET_ULONG,
-   REQUIRED_ARG, 32, 1, (longlong) ULONG_MAX, 0, 1, 0},
+   REQUIRED_ARG, 32, 1, (ulonglong) ULONG_MAX, 0, 1, 0},
   {"max_user_connections", OPT_MAX_USER_CONNECTIONS,
    "The maximum number of active connections for a single user (0 = no limit. In addition global max_user_connections counting and checking is permanently disabled).",
    &max_user_connections, &max_user_connections, 0, GET_INT,
@@ -7300,7 +7300,7 @@ each time the SQL thread starts.",
    "Don't log queries which examine less than min_examined_row_limit rows to file.",
    &global_system_variables.min_examined_row_limit,
    &max_system_variables.min_examined_row_limit, 0, GET_ULONG,
-  REQUIRED_ARG, 0, 0, (longlong) ULONG_MAX, 0, 1L, 0},
+  REQUIRED_ARG, 0, 0, (ulonglong) ULONG_MAX, 0, 1L, 0},
   {"mrr_buffer_size", OPT_MRR_BUFFER_SIZE,
    "Size of buffer to use when using MRR with range access",
    (uchar**) &global_system_variables.mrr_buff_size,
@@ -7342,7 +7342,7 @@ each time the SQL thread starts.",
    "disables parallel repair.",
    &global_system_variables.myisam_repair_threads,
    &max_system_variables.myisam_repair_threads, 0,
-   GET_ULONG, REQUIRED_ARG, 1, 1, (longlong) ULONG_MAX, 0, 1, 0},
+   GET_ULONG, REQUIRED_ARG, 1, 1, (ulonglong) ULONG_MAX, 0, 1, 0},
   {"myisam_sort_buffer_size", OPT_MYISAM_SORT_BUFFER_SIZE,
    "The buffer that is allocated when sorting the index when doing a REPAIR "
    "or when creating indexes with CREATE INDEX or ALTER TABLE.",
@@ -7373,7 +7373,7 @@ each time the SQL thread starts.",
    "If a read on a communication port is interrupted, retry this many times before giving up.",
    &global_system_variables.net_retry_count,
    &max_system_variables.net_retry_count,0,
-   GET_ULONG, REQUIRED_ARG, MYSQLD_NET_RETRY_COUNT, 1, (longlong) ULONG_MAX,
+   GET_ULONG, REQUIRED_ARG, MYSQLD_NET_RETRY_COUNT, 1, (ulonglong) ULONG_MAX,
    0, 1, 0},
   {"net_write_timeout", OPT_NET_WRITE_TIMEOUT,
    "Number of seconds to wait for a block to be written to a connection before "
@@ -7454,19 +7454,19 @@ each time the SQL thread starts.",
    "Allocation block size for query parsing and execution.",
    &global_system_variables.query_alloc_block_size,
    &max_system_variables.query_alloc_block_size, 0, GET_ULONG,
-   REQUIRED_ARG, QUERY_ALLOC_BLOCK_SIZE, 1024, (longlong) ULONG_MAX, 0, 1024,
+   REQUIRED_ARG, QUERY_ALLOC_BLOCK_SIZE, 1024, (ulonglong) ULONG_MAX, 0, 1024,
    0},
 #ifdef HAVE_QUERY_CACHE
   {"query_cache_limit", OPT_QUERY_CACHE_LIMIT,
    "Don't cache results that are bigger than this.",
    &query_cache_limit, &query_cache_limit, 0, GET_ULONG,
-   REQUIRED_ARG, 1024*1024L, 0, (longlong) ULONG_MAX, 0, 1, 0},
+   REQUIRED_ARG, 1024*1024L, 0, (ulonglong) ULONG_MAX, 0, 1, 0},
   {"query_cache_min_res_unit", OPT_QUERY_CACHE_MIN_RES_UNIT,
    "Minimal size of unit in which space for results is allocated (last unit "
    "will be trimmed after writing all result data).",
    &query_cache_min_res_unit, &query_cache_min_res_unit,
    0, GET_ULONG, REQUIRED_ARG, QUERY_CACHE_MIN_RESULT_DATA_SIZE,
-   0, (longlong) ULONG_MAX, 0, 1, 0},
+   0, (ulonglong) ULONG_MAX, 0, 1, 0},
 #endif /*HAVE_QUERY_CACHE*/
   {"query_cache_size", OPT_QUERY_CACHE_SIZE,
    "The memory allocated to store results from old queries.",
@@ -7497,13 +7497,13 @@ each time the SQL thread starts.",
    &global_system_variables.query_prealloc_size,
    &max_system_variables.query_prealloc_size, 0, GET_ULONG,
    REQUIRED_ARG, QUERY_ALLOC_PREALLOC_SIZE, QUERY_ALLOC_PREALLOC_SIZE,
-   (longlong) ULONG_MAX, 0, 1024, 0},
+   (ulonglong) ULONG_MAX, 0, 1024, 0},
   {"range_alloc_block_size", OPT_RANGE_ALLOC_BLOCK_SIZE,
    "Allocation block size for storing ranges during optimization.",
    &global_system_variables.range_alloc_block_size,
    &max_system_variables.range_alloc_block_size, 0, GET_ULONG,
    REQUIRED_ARG, RANGE_ALLOC_BLOCK_SIZE, RANGE_ALLOC_BLOCK_SIZE,
-   (longlong) ULONG_MAX, 0, 1024, 0},
+   (ulonglong) ULONG_MAX, 0, 1024, 0},
   {"rowid_merge_buff_size", OPT_ROWID_MERGE_BUFF_SIZE,
    "The size of the buffers used [NOT] IN evaluation via partial matching.",
    (uchar**) &global_system_variables.rowid_merge_buff_size,
@@ -7577,7 +7577,7 @@ each time the SQL thread starts.",
    "Synchronously flush binary log to disk after every #th event. "
    "Use 0 (default) to disable synchronous flushing.",
    &sync_binlog_period, &sync_binlog_period, 0, GET_ULONG,
-   REQUIRED_ARG, 0, 0, (longlong) ULONG_MAX, 0, 1, 0},
+   REQUIRED_ARG, 0, 0, (ulonglong) ULONG_MAX, 0, 1, 0},
   {"sync-frm", OPT_SYNC_FRM, "Sync .frm to disk on create. Enabled by default.",
    &opt_sync_frm, &opt_sync_frm, 0, GET_BOOL, NO_ARG, 1, 0,
    0, 0, 0, 0},
@@ -7626,7 +7626,7 @@ each time the SQL thread starts.",
   {"thread_stack", OPT_THREAD_STACK,
    "The stack size for each thread.", &my_thread_stack_size,
    &my_thread_stack_size, 0, GET_ULONG, REQUIRED_ARG,DEFAULT_THREAD_STACK,
-   (sizeof(void*)<=4)?1024L*128L: ((256-16)*1024L), (longlong) ULONG_MAX, 0, 1024, 0},
+   (sizeof(void*)<=4)?1024L*128L: ((256-16)*1024L), (ulonglong) ULONG_MAX, 0, 1024, 0},
   { "time_format", OPT_TIME_FORMAT,
     "The TIME format (for future).",
     &opt_date_time_formats[MYSQL_TIMESTAMP_TIME],
@@ -7642,13 +7642,13 @@ each time the SQL thread starts.",
    "Allocation block size for transactions to be stored in binary log.",
    &global_system_variables.trans_alloc_block_size,
    &max_system_variables.trans_alloc_block_size, 0, GET_ULONG,
-   REQUIRED_ARG, QUERY_ALLOC_BLOCK_SIZE, 1024, (longlong) ULONG_MAX, 0, 1024,
+   REQUIRED_ARG, QUERY_ALLOC_BLOCK_SIZE, 1024, (ulonglong) ULONG_MAX, 0, 1024,
    0},
   {"transaction_prealloc_size", OPT_TRANS_PREALLOC_SIZE,
    "Persistent buffer for transactions to be stored in binary log.",
    &global_system_variables.trans_prealloc_size,
    &max_system_variables.trans_prealloc_size, 0, GET_ULONG,
-   REQUIRED_ARG, TRANS_ALLOC_PREALLOC_SIZE, 1024, (longlong) ULONG_MAX, 0,
+   REQUIRED_ARG, TRANS_ALLOC_PREALLOC_SIZE, 1024, (ulonglong) ULONG_MAX, 0,
    1024, 0},
   {"thread_handling", OPT_THREAD_HANDLING,
    "Define threads usage for handling queries: "

storage/maria/ha_maria.cc

@@ -229,7 +229,7 @@ static MYSQL_SYSVAR_ULONG(pagecache_age_threshold,
        "until it is considered aged enough to be downgraded to a warm block. "
        "This specifies the percentage ratio of that number of hits to the "
        "total number of blocks in the page cache.", 0, 0,
-        300, 100, ~0L, 100);
+        300, 100, ~(unsigned long)0, 100);
 
 static MYSQL_SYSVAR_ULONGLONG(pagecache_buffer_size, pagecache_buffer_size,
        PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,

storage/maria/ma_ft_nlq_search.c

@@ -82,6 +82,7 @@ static int walk_and_match(FT_WORD *word, uint32 count, ALL_IN_ONE *aio)
 #error
 #endif
   DBUG_ENTER("walk_and_match");
+  LINT_INIT(subkeys.i);
 
   word->weight=LWS_FOR_QUERY;
 

storage/myisam/ft_nlq_search.c

@@ -83,6 +83,7 @@ static int walk_and_match(FT_WORD *word, uint32 count, ALL_IN_ONE *aio)
 #error
 #endif
   DBUG_ENTER("walk_and_match");
+  LINT_INIT(subkeys.i);
 
   word->weight=LWS_FOR_QUERY;
 

storage/xtradb/handler/ha_innodb.cc

@@ -11884,7 +11884,7 @@ static MYSQL_SYSVAR_BOOL(doublewrite, innobase_use_doublewrite,
 static MYSQL_SYSVAR_ULONG(io_capacity, srv_io_capacity,
   PLUGIN_VAR_RQCMDARG,
   "Number of IOPs the server can do. Tunes the background IO rate",
-  NULL, NULL, 200, 100, ~0L, 0);
+  NULL, NULL, 200, 100, ~0UL, 0);
 
 static MYSQL_SYSVAR_ULONG(fast_shutdown, innobase_fast_shutdown,
   PLUGIN_VAR_OPCMDARG,
@@ -11972,7 +11972,7 @@ static MYSQL_SYSVAR_BOOL(adaptive_flushing, srv_adaptive_flushing,
 static MYSQL_SYSVAR_ULONG(max_purge_lag, srv_max_purge_lag,
   PLUGIN_VAR_RQCMDARG,
   "Desired maximum length of the purge queue (0 = no limit)",
-  NULL, NULL, 0, 0, ~0L, 0);
+  NULL, NULL, 0, 0, ~0UL, 0);
 
 static MYSQL_SYSVAR_BOOL(rollback_on_timeout, innobase_rollback_on_timeout,
   PLUGIN_VAR_OPCMDARG | PLUGIN_VAR_READONLY,
@@ -12059,7 +12059,7 @@ static MYSQL_SYSVAR_ULONG(commit_concurrency, innobase_commit_concurrency,
 static MYSQL_SYSVAR_ULONG(concurrency_tickets, srv_n_free_tickets_to_enter,
   PLUGIN_VAR_RQCMDARG,
   "Number of times a thread is allowed to enter InnoDB within the same SQL query after it has once got the ticket",
-  NULL, NULL, 500L, 1L, ~0L, 0);
+  NULL, NULL, 500L, 1L, ~0UL, 0);
 
 #ifdef EXTENDED_FOR_KILLIDLE
 #define kill_idle_help_text "If non-zero value, the idle session with transaction which is idle over the value in seconds is killed by InnoDB."
@@ -12129,12 +12129,12 @@ static MYSQL_SYSVAR_LONG(open_files, innobase_open_files,
 static MYSQL_SYSVAR_ULONG(sync_spin_loops, srv_n_spin_wait_rounds,
   PLUGIN_VAR_RQCMDARG,
   "Count of spin-loop rounds in InnoDB mutexes (30 by default)",
-  NULL, NULL, 30L, 0L, ~0L, 0);
+  NULL, NULL, 30L, 0L, ~0UL, 0);
 
 static MYSQL_SYSVAR_ULONG(spin_wait_delay, srv_spin_wait_delay,
   PLUGIN_VAR_OPCMDARG,
   "Maximum delay between polling for a spin lock (6 by default)",
-  NULL, NULL, 6L, 0L, ~0L, 0);
+  NULL, NULL, 6L, 0L, ~0UL, 0);
 
 static MYSQL_SYSVAR_BOOL(thread_concurrency_timer_based,
   innobase_thread_concurrency_timer_based,
@@ -12150,7 +12150,7 @@ static MYSQL_SYSVAR_ULONG(thread_concurrency, srv_thread_concurrency,
 static MYSQL_SYSVAR_ULONG(thread_sleep_delay, srv_thread_sleep_delay,
   PLUGIN_VAR_RQCMDARG,
   "Time of innodb thread sleeping before joining InnoDB queue (usec). Value 0 disable a sleep",
-  NULL, NULL, 10000L, 0L, ~0L, 0);
+  NULL, NULL, 10000L, 0L, ~0UL, 0);
 
 static MYSQL_SYSVAR_STR(data_file_path, innobase_data_file_path,
   PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,