Bug #33768149 Clean up usage of init_sql_alloc

Remove the pre_alloc_size argument to init_sql_alloc, it has been
ignored since the patch for
    Bug #26940369: REWRITE THE MEM_ROOT

Remove calls to init_sql_alloc() for MEM_ROOT objects on the heap
(part of other objects) or on the stack. Use CTOR to initialize
instead.

MEM_ROOT now has a DTOR which does Clear(), so most of the calls to
this function can be removed.

Set MEM_ROOT.m_error_handler if MYSQL_SERVER is defined.

Change-Id: Iaeaaff7f2e9743a353c802829cd62ee9c73c7710

Author: Tor Didriksen

include/my_alloc.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2000, 2021, Oracle and/or its affiliates.
+/* Copyright (c) 2000, 2022, Oracle and/or its affiliates.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License, version 2.0,
@@ -44,6 +44,10 @@
 #include "my_pointer_arithmetic.h"
 #include "mysql/psi/psi_memory.h"
 
+#if defined(MYSQL_SERVER)
+extern "C" void sql_alloc_error_handler();
+#endif
+
 /**
  * The MEM_ROOT is a simple arena, where allocations are carved out of
  * larger blocks. Using an arena over plain malloc gives you two main
@@ -88,7 +92,11 @@ struct MEM_ROOT {
   MEM_ROOT(PSI_memory_key key, size_t block_size)
       : m_block_size(block_size),
         m_orig_block_size(block_size),
-        m_psi_key(key) {}
+        m_psi_key(key) {
+#if defined(MYSQL_SERVER)
+    m_error_handler = sql_alloc_error_handler;
+#endif
+  }
 
   // MEM_ROOT is movable but not copyable.
   MEM_ROOT(const MEM_ROOT &) = delete;

sql/auth/acl_table_user.cc

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018, 2021, Oracle and/or its affiliates.
+/* Copyright (c) 2018, 2022, Oracle and/or its affiliates.
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License, version 2.0,
@@ -68,7 +68,6 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA */
 #include "sql/sql_update.h"       /* compare_records */
 #include "sql/system_variables.h" /* System_variables */
 #include "sql/table.h"            /* TABLE, TABLE_SHARE, ... */
-#include "sql/thr_malloc.h"       /* init_sql_alloc */
 #include "sql/tztime.h"           /* Time_zone */
 #include "sql_string.h"           /* String */
 #include "template_utils.h"       /* down_cast */
@@ -1342,17 +1341,14 @@ std::string Acl_table_user_writer::get_current_credentials() {
 */
 Acl_table_user_reader::Acl_table_user_reader(THD *thd, TABLE *table)
     : Acl_table(thd, table, acl_table::Acl_table_operation::OP_READ),
-      m_restrictions(new Restrictions) {
-  init_sql_alloc(PSI_NOT_INSTRUMENTED, &m_mem_root, ACL_ALLOC_BLOCK_SIZE, 0);
-}
+      m_restrictions(new Restrictions) {}
 
 /**
   Free resources before we destroy.
 */
 Acl_table_user_reader::~Acl_table_user_reader() {
   if (m_table_schema) delete m_table_schema;
   if (m_restrictions) delete m_restrictions;
-  m_mem_root.Clear();
 }
 
 /**

sql/auth/acl_table_user.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018, 2021, Oracle and/or its affiliates.
+/* Copyright (c) 2018, 2022, Oracle and/or its affiliates.
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License, version 2.0,
@@ -318,7 +318,7 @@ class Acl_table_user_reader : public Acl_table {
  private:
   User_table_schema *m_table_schema = nullptr;
   unique_ptr_destroy_only<RowIterator> m_iterator;
-  MEM_ROOT m_mem_root;
+  MEM_ROOT m_mem_root{PSI_NOT_INSTRUMENTED, ACL_ALLOC_BLOCK_SIZE};
   Restrictions *m_restrictions = nullptr;
   Json_object *m_user_application_user_metadata_json = nullptr;
 };

sql/auth/sql_auth_cache.cc

@@ -1,4 +1,4 @@
-/* Copyright (c) 2000, 2021, Oracle and/or its affiliates.
+/* Copyright (c) 2000, 2022, Oracle and/or its affiliates.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License, version 2.0,
@@ -183,8 +183,7 @@ static void set_hostname(ACL_HOST_AND_IP *host, const char *host_arg,
   Allocates the memory in the the global_acl_memory MEM_ROOT.
 */
 void init_acl_memory() {
-  init_sql_alloc(key_memory_acl_mem, &global_acl_memory, ACL_ALLOC_BLOCK_SIZE,
-                 0);
+  init_sql_alloc(key_memory_acl_mem, &global_acl_memory, ACL_ALLOC_BLOCK_SIZE);
 }
 
 /**
@@ -2691,7 +2690,7 @@ bool grant_reload(THD *thd, bool mdl_locked) {
       undo opertion possible in case of failure.
     */
     old_mem = move(memex);
-    init_sql_alloc(key_memory_acl_memex, &memex, ACL_ALLOC_BLOCK_SIZE, 0);
+    init_sql_alloc(key_memory_acl_memex, &memex, ACL_ALLOC_BLOCK_SIZE);
     /*
       tables[2].table i.e. procs_priv can be null if we are working with
       pre 4.1 privilage tables

sql/auth/sql_user.cc

@@ -1,4 +1,4 @@
-/* Copyright (c) 2000, 2021, Oracle and/or its affiliates.
+/* Copyright (c) 2000, 2022, Oracle and/or its affiliates.
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License, version 2.0,
    as published by the Free Software Foundation.
@@ -1808,8 +1808,7 @@ bool set_and_validate_user_attributes(
         */
         acl_user->m_mfa->alter_mfa(mfa);
       } else {
-        MEM_ROOT mr;
-        init_sql_alloc(PSI_NOT_INSTRUMENTED, &mr, 256, 0);
+        MEM_ROOT mr(PSI_NOT_INSTRUMENTED, 256);
         I_multi_factor_auth *tmp = new (&mr) Multi_factor_auth_list(&mr);
         if (tmp->is_alter_allowed(thd, Str)) {
           mr.Clear();

sql/event_data_objects.cc

@@ -1,4 +1,4 @@
-/* Copyright (c) 2005, 2021, Oracle and/or its affiliates.
+/* Copyright (c) 2005, 2022, Oracle and/or its affiliates.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License, version 2.0,
@@ -222,8 +222,6 @@ Event_queue_element_for_exec::~Event_queue_element_for_exec() {
 Event_basic::Event_basic()
     : m_schema_name(NULL_CSTR), m_event_name(NULL_CSTR), m_time_zone(nullptr) {
   DBUG_TRACE;
-  /* init memory root */
-  init_sql_alloc(key_memory_event_basic_root, &mem_root, 256, 512);
 }
 
 /*
@@ -233,10 +231,7 @@ Event_basic::Event_basic()
     Event_basic::Event_basic()
 */
 
-Event_basic::~Event_basic() {
-  DBUG_TRACE;
-  mem_root.Clear();
-}
+Event_basic::~Event_basic() { DBUG_TRACE; }
 
 /*
   Constructor

sql/event_data_objects.h

@@ -1,6 +1,6 @@
 #ifndef _EVENT_DATA_OBJECTS_H_
 #define _EVENT_DATA_OBJECTS_H_
-/* Copyright (c) 2004, 2021, Oracle and/or its affiliates.
+/* Copyright (c) 2004, 2022, Oracle and/or its affiliates.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License, version 2.0,
@@ -37,6 +37,7 @@
 #include "my_psi_config.h"
 #include "my_time.h"  // interval_type
 #include "mysql/components/services/bits/psi_statement_bits.h"
+#include "sql/psi_memory_key.h"
 
 class String;
 class THD;
@@ -76,7 +77,7 @@ class Event_queue_element_for_exec {
 
 class Event_basic {
  protected:
-  MEM_ROOT mem_root;
+  MEM_ROOT mem_root{key_memory_event_basic_root, 256};
 
  public:
   LEX_CSTRING m_schema_name;

sql/events.h

@@ -1,6 +1,6 @@
 #ifndef _EVENT_H_
 #define _EVENT_H_
-/* Copyright (c) 2004, 2021, Oracle and/or its affiliates.
+/* Copyright (c) 2004, 2022, Oracle and/or its affiliates.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License, version 2.0,
@@ -43,7 +43,7 @@
 #include "mysql/components/services/bits/psi_mutex_bits.h"
 #include "mysql/components/services/bits/psi_stage_bits.h"
 #include "mysql/components/services/bits/psi_thread_bits.h"
-#include "mysql/psi/psi_memory.h"  // PSI_memory_key
+#include "sql/psi_memory_key.h"
 
 class Event_db_repository;
 class Event_parse_data;
@@ -64,8 +64,6 @@ extern PSI_cond_key key_event_scheduler_COND_state;
 extern PSI_thread_key key_thread_event_scheduler, key_thread_event_worker;
 #endif /* HAVE_PSI_INTERFACE */
 
-extern PSI_memory_key key_memory_event_basic_root;
-
 /* Always defined, for SHOW PROCESSLIST. */
 extern PSI_stage_info stage_waiting_on_empty_queue;
 extern PSI_stage_info stage_waiting_for_next_activation;

sql/locked_tables_list.cc

@@ -1,4 +1,4 @@
-/* Copyright (c) 2000, 2021, Oracle and/or its affiliates.
+/* Copyright (c) 2000, 2022, Oracle and/or its affiliates.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License, version 2.0,
@@ -32,10 +32,7 @@ Locked_tables_list::Locked_tables_list()
     : m_locked_tables(nullptr),
       m_locked_tables_last(&m_locked_tables),
       m_reopen_array(nullptr),
-      m_locked_tables_count(0) {
-  init_sql_alloc(key_memory_locked_table_list, &m_locked_tables_root,
-                 MEM_ROOT_BLOCK_SIZE, 0);
-}
+      m_locked_tables_count(0) {}
 
 /**
   Enter LTM_LOCK_TABLES mode.

sql/locked_tables_list.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2008, 2021, Oracle and/or its affiliates.
+/* Copyright (c) 2008, 2022, Oracle and/or its affiliates.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License, version 2.0,
@@ -26,6 +26,8 @@
 #include <sys/types.h>
 #include <vector>
 #include "my_alloc.h"
+#include "sql/psi_memory_key.h"
+#include "sql/sql_const.h"
 
 struct MYSQL_LOCK;
 class MDL_context;
@@ -85,7 +87,8 @@ const char *get_locked_tables_mode_name(
 
 class Locked_tables_list {
  private:
-  MEM_ROOT m_locked_tables_root;
+  MEM_ROOT m_locked_tables_root{key_memory_locked_table_list,
+                                MEM_ROOT_BLOCK_SIZE};
   TABLE_LIST *m_locked_tables;
   TABLE_LIST **m_locked_tables_last;
   /** An auxiliary array used only in reopen_tables(). */

sql/mysql_tzinfo_to_sql.cc

@@ -1,5 +1,5 @@
 /*
-   Copyright (c) 2004, 2021, Oracle and/or its affiliates.
+   Copyright (c) 2004, 2022, Oracle and/or its affiliates.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License, version 2.0,
@@ -326,6 +326,8 @@ static bool scan_tz_dir(char *name_end) {
   return false;
 }
 
+extern "C" void sql_alloc_error_handler() {}
+
 int main(int argc, char **argv) {
   MY_INIT(argv[0]);
 

sql/psi_memory_key.h

@@ -64,6 +64,7 @@ extern PSI_memory_key key_memory_DD_default_values;
 extern PSI_memory_key key_memory_DD_import;
 extern PSI_memory_key key_memory_DD_objects;
 extern PSI_memory_key key_memory_DD_String_type;
+extern PSI_memory_key key_memory_event_basic_root;
 extern PSI_memory_key key_memory_Event_queue_element_for_exec_names;
 extern PSI_memory_key key_memory_Event_scheduler_scheduler_param;
 extern PSI_memory_key key_memory_File_query_log_name;

sql/rpl_handler.cc

@@ -97,14 +97,12 @@ Delegate::Delegate(
 #else
   if (mysql_rwlock_init(0, &lock)) return;
 #endif
-  init_sql_alloc(key_memory_delegate, &memroot, 1024, 0);
   inited = true;
 }
 
 Delegate::~Delegate() {
   inited = false;
   mysql_rwlock_destroy(&lock);
-  memroot.Clear();
 }
 
 int Delegate::add_observer(void *observer, st_plugin_int *plugin) {

sql/rpl_handler.h

@@ -36,9 +36,10 @@
 #include "mysql/components/services/bits/psi_rwlock_bits.h"
 #include "mysql/psi/mysql_rwlock.h"
 #include "sql/locks/shared_spin_lock.h"  // Shared_spin_lock
-#include "sql/sql_list.h"                // List
-#include "sql/sql_plugin.h"              // my_plugin_(un)lock
-#include "sql/sql_plugin_ref.h"          // plugin_ref
+#include "sql/psi_memory_key.h"
+#include "sql/sql_list.h"        // List
+#include "sql/sql_plugin.h"      // my_plugin_(un)lock
+#include "sql/sql_plugin_ref.h"  // plugin_ref
 
 class Master_info;
 class String;
@@ -219,7 +220,7 @@ class Delegate {
   */
   lock::Shared_spin_lock m_spin_lock;
   /** Memory pool to be used to allocate the observers list */
-  MEM_ROOT memroot;
+  MEM_ROOT memroot{key_memory_delegate, 1024};
   /** Flag statign whether or not this instance was initialized */
   bool inited;
   /**

sql/sp.cc

@@ -2237,10 +2237,7 @@ sp_head *sp_load_for_information_schema(THD *thd, LEX_CSTRING db_name,
 sp_head *sp_start_parsing(THD *thd, enum_sp_type sp_type, sp_name *sp_name) {
   // The order is important:
   // 1. new sp_head()
-  MEM_ROOT own_root;
-
-  init_sql_alloc(key_memory_sp_head_main_root, &own_root, MEM_ROOT_BLOCK_SIZE,
-                 0);
+  MEM_ROOT own_root(key_memory_sp_head_main_root, MEM_ROOT_BLOCK_SIZE);
 
   void *rawmem = own_root.Alloc(sizeof(sp_head));
   if (!rawmem) return nullptr;