← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/plugin/loader.cc

  • Committer: Brian Aker
  • Date: 2010-04-19 17:51:52 UTC
  • Revision ID: brian@gaz-20100419175152-lar9fncw9vhhav0d
Updates to confine memroot

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/plugin/loader.cc
84
84
  write-lock on LOCK_system_variables_hash is required before modifying
85
85
  the following variables/structures
86
86
*/
87
 
static memory::Root plugin_mem_root;
 
87
static memory::Root plugin_mem_root(4096);
88
88
static uint32_t global_variables_dynamic_size= 0;
89
89
static HASH bookmark_hash;
90
90
 
375
375
  plugin::Manifest **builtins;
376
376
  plugin::Manifest *manifest;
377
377
  plugin::Module *module;
378
 
  memory::Root tmp_root;
 
378
  memory::Root tmp_root(4096);
379
379
 
380
380
  if (initialized)
381
381
    return false;
382
382
 
383
 
  init_alloc_root(&plugin_mem_root, 4096);
384
 
  init_alloc_root(&tmp_root, 4096);
385
 
 
386
383
  if (hash_init(&bookmark_hash, &my_charset_bin, 16, 0, 0,
387
384
                  get_bookmark_hash_key, NULL, HASH_UNIQUE))
388
385
  {
899
896
  {
900
897
    const string varname(make_bookmark_name(plugin, name, flags));
901
898
 
902
 
    result= static_cast<st_bookmark*>(alloc_root(&plugin_mem_root,
903
 
                                      sizeof(struct st_bookmark) + varname.size() + 1));
 
899
    result= static_cast<st_bookmark*>(plugin_mem_root.alloc_root(sizeof(struct st_bookmark) + varname.size() + 1));
904
900
    memset(result->key, 0, varname.size()+1);
905
901
    memcpy(result->key, varname.c_str(), varname.size());
906
902
    result->name_len= varname.size() - 2;
1572
1568
    if (!(opt->flags & PLUGIN_VAR_SessionLOCAL))
1573
1569
    {
1574
1570
      optnamelen= strlen(opt->name);
1575
 
      optname= (char*) alloc_root(mem_root, namelen + optnamelen + 2);
 
1571
      optname= (char*) mem_root->alloc_root(namelen + optnamelen + 2);
1576
1572
      sprintf(optname, "%s-%s", name.c_str(), opt->name);
1577
1573
      optnamelen= namelen + optnamelen + 1;
1578
1574
    }
1628
1624
 
1629
1625
  for (opt= p->getManifest().system_vars; opt && *opt; opt++, count++) {};
1630
1626
 
1631
 
  opts= (option*)alloc_root(mem_root, (sizeof(option) * count));
 
1627
  opts= (option*)mem_root->alloc_root((sizeof(option) * count));
1632
1628
  if (opts == NULL)
1633
1629
    return NULL;
1634
1630
 
1686
1682
 
1687
1683
  if (count > EXTRA_OPTIONS || (*argc > 1))
1688
1684
  {
1689
 
    if (!(opts= (option*) alloc_root(tmp_root, sizeof(option) * count)))
 
1685
    if (!(opts= (option*) tmp_root->alloc_root(sizeof(option) * count)))
1690
1686
    {
1691
1687
      errmsg_printf(ERRMSG_LVL_ERROR, _("Out of memory for plugin '%s'."), tmp->getName().c_str());
1692
1688
      return(-1);
1788
1784
  plugin::Registry &registry= plugin::Registry::singleton();
1789
1785
  vector<option> all_options;
1790
1786
  plugin::Module *p;
1791
 
  memory::Root mem_root;
 
1787
  memory::Root mem_root(4096);
1792
1788
  option *opt= NULL;
1793
1789
 
1794
 
  init_alloc_root(&mem_root, 4096);
1795
 
 
1796
1790
  if (initialized)
1797
1791
  {
1798
1792
    std::map<std::string, plugin::Module *>::const_iterator modules=