← Back to branch summary

~thomir-deactivatedaccount/drizzle/drizzle-fix-bug653747

« back to all changes in this revision

Viewing changes to drizzled/module/loader.cc

  • Committer: Brian Aker
  • Date: 2010-10-10 02:07:52 UTC
  • mfrom: (1827.2.3 staging)
  • Revision ID: brian@tangent.org-20101010020752-ktv73isay5dxtvp3
Merge in switch on table_share_instance inheritance.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/module/loader.cc
163
163
static int test_plugin_options(memory::Root *, module::Module *,
164
164
                               po::options_description &long_options);
165
165
static void unlock_variables(Session *session, struct system_variables *vars);
166
 
static void cleanup_variables(system_variables *vars);
167
 
static void plugin_vars_free_values(module::Module::Variables &vars);
 
166
static void cleanup_variables(Session *session, struct system_variables *vars);
 
167
static void plugin_vars_free_values(sys_var *vars);
168
168
 
169
169
/* declared in set_var.cc */
170
170
extern sys_var *intern_find_sys_var(const char *str, uint32_t length, bool no_error);
289
289
static void delete_module(module::Module *module)
290
290
{
291
291
  /* Free allocated strings before deleting the plugin. */
292
 
  plugin_vars_free_values(module->getSysVars());
 
292
  plugin_vars_free_values(module->system_vars);
293
293
  module->isInited= false;
 
294
  mysql_del_sys_var_chain(module->system_vars);
294
295
  delete module;
295
296
}
296
297
 
317
318
    set the plugin attribute of plugin's sys vars so they are pointing
318
319
    to the active plugin
319
320
  */
320
 
  for (module::Module::Variables::iterator iter= module->getSysVars().begin();
321
 
       iter != module->getSysVars().end();
322
 
       ++iter)
 
321
  if (module->system_vars)
323
322
  {
324
 
    sys_var *current_var= *iter;
325
 
    current_var->cast_pluginvar()->plugin= module;
 
323
    sys_var_pluginvar *var= module->system_vars->cast_pluginvar();
 
324
    for (;;)
 
325
    {
 
326
      var->plugin= module;
 
327
      if (! var->getNext())
 
328
        break;
 
329
      var= var->getNext()->cast_pluginvar();
 
330
    }
326
331
  }
327
332
}
328
333
 
552
557
    unlock_variables(NULL, &global_system_variables);
553
558
    unlock_variables(NULL, &max_system_variables);
554
559
 
555
 
    cleanup_variables(&global_system_variables);
556
 
    cleanup_variables(&max_system_variables);
 
560
    cleanup_variables(NULL, &global_system_variables);
 
561
    cleanup_variables(NULL, &max_system_variables);
557
562
 
558
563
    initialized= 0;
559
564
  }
791
796
    then the intern_plugin_lock did not raise an error, so we do it here.
792
797
  */
793
798
  if (pi && !var)
794
 
  {
795
799
    my_error(ER_UNKNOWN_SYSTEM_VARIABLE, MYF(0), (char*) str);
796
 
    assert(false);
797
 
  }
798
800
  return(var);
799
801
}
800
802
 
1046
1048
void plugin_sessionvar_init(Session *session)
1047
1049
{
1048
1050
  session->variables.storage_engine= NULL;
1049
 
  cleanup_variables(&session->variables);
 
1051
  cleanup_variables(session, &session->variables);
1050
1052
 
1051
1053
  session->variables= global_system_variables;
1052
1054
  session->variables.storage_engine= NULL;
1075
1077
  Unlike plugin_vars_free_values() it frees all variables of all plugins,
1076
1078
  it's used on shutdown.
1077
1079
*/
1078
 
static void cleanup_variables(system_variables *vars)
 
1080
static void cleanup_variables(Session *session, struct system_variables *vars)
1079
1081
{
 
1082
  sys_var_pluginvar *pivar;
 
1083
  sys_var *var;
 
1084
  int flags;
 
1085
 
 
1086
  bookmark_unordered_map::iterator iter= bookmark_hash.begin();
 
1087
  for (; iter != bookmark_hash.end() ; ++iter)
 
1088
  {
 
1089
    const Bookmark &v= (*iter).second;
 
1090
    const string key_name((*iter).first);
 
1091
    if (v.version > vars->dynamic_variables_version ||
 
1092
        !(var= intern_find_sys_var(key_name.c_str(), key_name.size(), true)) ||
 
1093
        !(pivar= var->cast_pluginvar()) ||
 
1094
        v.type_code != (pivar->plugin_var->flags & PLUGIN_VAR_TYPEMASK))
 
1095
      continue;
 
1096
 
 
1097
    flags= pivar->plugin_var->flags;
 
1098
 
 
1099
    if ((flags & PLUGIN_VAR_TYPEMASK) == PLUGIN_VAR_STR &&
 
1100
        flags & PLUGIN_VAR_SessionLOCAL && flags & PLUGIN_VAR_MEMALLOC)
 
1101
    {
 
1102
      char **ptr= (char**) pivar->real_value_ptr(session, OPT_SESSION);
 
1103
      free(*ptr);
 
1104
      *ptr= NULL;
 
1105
    }
 
1106
  }
 
1107
 
1080
1108
  assert(vars->storage_engine == NULL);
1081
1109
 
1082
1110
  free(vars->dynamic_variables_ptr);
1089
1117
void plugin_sessionvar_cleanup(Session *session)
1090
1118
{
1091
1119
  unlock_variables(session, &session->variables);
1092
 
  cleanup_variables(&session->variables);
 
1120
  cleanup_variables(session, &session->variables);
1093
1121
}
1094
1122
 
1095
1123
 
1104
1132
  @param[in]        vars        Chain of system variables of a plugin
1105
1133
*/
1106
1134
 
1107
 
static void plugin_vars_free_values(module::Module::Variables &vars)
 
1135
static void plugin_vars_free_values(sys_var *vars)
1108
1136
{
1109
1137
 
1110
 
  for (module::Module::Variables::iterator iter= vars.begin();
1111
 
       iter != vars.end();
1112
 
       ++iter)
 
1138
  for (sys_var *var= vars; var; var= var->getNext())
1113
1139
  {
1114
 
    sys_var_pluginvar *piv= (*iter)->cast_pluginvar();
 
1140
    sys_var_pluginvar *piv= var->cast_pluginvar();
1115
1141
    if (piv &&
1116
1142
        ((piv->plugin_var->flags & PLUGIN_VAR_TYPEMASK) == PLUGIN_VAR_STR) &&
1117
1143
        (piv->plugin_var->flags & PLUGIN_VAR_MEMALLOC))
1605
1631
                               module::Module *test_module,
1606
1632
                               po::options_description &long_options)
1607
1633
{
 
1634
  struct sys_var_chain chain= { NULL, NULL };
1608
1635
  drizzle_sys_var **opt;
1609
1636
  option *opts= NULL;
1610
1637
  int error;
1683
1710
      assert(v); /* check that an object was actually constructed */
1684
1711
 
1685
1712
      drizzle_add_plugin_sysvar(static_cast<sys_var_pluginvar *>(v));
1686
 
      try
1687
 
      {
1688
 
        add_sys_var_to_list(v);
1689
 
        test_module->addSysVar(v);
1690
 
      }
1691
 
      catch (...)
 
1713
      /*
 
1714
        Add to the chain of variables.
 
1715
        Done like this for easier debugging so that the
 
1716
        pointer to v is not lost on optimized builds.
 
1717
      */
 
1718
      v->chain_sys_var(&chain);
 
1719
    }
 
1720
    if (chain.first)
 
1721
    {
 
1722
      chain.last->setNext(NULL);
 
1723
      if (mysql_add_sys_var_chain(chain.first, NULL))
1692
1724
      {
1693
1725
        errmsg_printf(ERRMSG_LVL_ERROR,
1694
1726
                      _("Plugin '%s' has conflicting system variables"),
1695
1727
                      test_module->getName().c_str());
1696
1728
        goto err;
1697
1729
      }
1698
 
 
 
1730
      test_module->system_vars= chain.first;
1699
1731
    }
1700
 
 
1701
1732
    return(0);
1702
1733
  }
1703
1734