← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/plugin/loader.cc

  • Committer: Monty Taylor
  • Date: 2009-10-27 01:05:10 UTC
  • mto: This revision was merged to the branch mainline in revision 1201.
  • Revision ID: mordred@inaugust.com-20091027010510-rel1e59xy7ti27a9
Renamed plugin::Handle to plugin::Module for clarity.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/plugin/loader.cc
72
72
static bool initialized= false;
73
73
 
74
74
static DYNAMIC_ARRAY plugin_dl_array;
75
 
static DYNAMIC_ARRAY plugin_array;
 
75
static DYNAMIC_ARRAY module_array;
76
76
 
77
77
static bool reap_needed= false;
78
78
 
130
130
class sys_var_pluginvar: public sys_var
131
131
{
132
132
public:
133
 
  plugin::Handle *plugin;
 
133
  plugin::Module *plugin;
134
134
  struct st_mysql_sys_var *plugin_var;
135
135
 
136
136
  sys_var_pluginvar(const std::string name_arg,
158
158
static bool plugin_load_list(plugin::Registry &registry,
159
159
                             MEM_ROOT *tmp_root, int *argc, char **argv,
160
160
                             const char *list);
161
 
static int test_plugin_options(MEM_ROOT *, plugin::Handle *,
 
161
static int test_plugin_options(MEM_ROOT *, plugin::Module *,
162
162
                               int *, char **);
163
163
static bool register_builtin(plugin::Registry &registry,
164
 
                             plugin::Handle *,
165
 
                             plugin::Handle **);
 
164
                             plugin::Module *,
 
165
                             plugin::Module **);
166
166
static void unlock_variables(Session *session, struct system_variables *vars);
167
167
static void cleanup_variables(Session *session, struct system_variables *vars);
168
168
static void plugin_vars_free_values(sys_var *vars);
405
405
 
406
406
 
407
407
 
408
 
static plugin::Handle *plugin_insert_or_reuse(plugin::Handle *plugin)
 
408
static plugin::Module *plugin_insert_or_reuse(plugin::Module *module)
409
409
{
410
 
  if (insert_dynamic(&plugin_array, (unsigned char*)&plugin))
 
410
  if (insert_dynamic(&module_array, (unsigned char*)&module))
411
411
    return(0);
412
 
  plugin= *dynamic_element(&plugin_array, plugin_array.elements - 1,
413
 
                        plugin::Handle **);
414
 
  return(plugin);
 
412
  module= *dynamic_element(&module_array, module_array.elements - 1,
 
413
                           plugin::Module **);
 
414
  return module;
415
415
}
416
416
 
417
417
 
439
439
  if (library == NULL)
440
440
    return true;
441
441
 
442
 
  plugin::Handle *tmp= NULL;
 
442
  plugin::Module *tmp= NULL;
443
443
  /* Find plugin by name */
444
444
  for (manifest= library->plugins; manifest->name; manifest++)
445
445
  {
448
448
                       (const unsigned char *)manifest->name,
449
449
                       strlen(manifest->name)))
450
450
    {
451
 
      tmp= new (std::nothrow) plugin::Handle(manifest, library);
 
451
      tmp= new (std::nothrow) plugin::Module(manifest, library);
452
452
      if (tmp == NULL)
453
453
        return true;
454
454
 
478
478
}
479
479
 
480
480
 
481
 
static void plugin_del(plugin::Registry &registry, plugin::Handle *plugin)
 
481
static void delete_module(plugin::Registry &registry, plugin::Module *module)
482
482
{
483
 
  if (plugin->isInited)
 
483
  plugin::Manifest manifest= module->getManifest();
 
484
 
 
485
  if (module->isInited)
484
486
  {
485
 
    if (plugin->getManifest().status_vars)
 
487
    if (manifest.status_vars)
486
488
    {
487
 
      remove_status_vars(plugin->getManifest().status_vars);
 
489
      remove_status_vars(manifest.status_vars);
488
490
    }
489
491
 
490
 
    if (plugin->getManifest().deinit)
491
 
      plugin->getManifest().deinit(registry);
 
492
    if (manifest.deinit)
 
493
      manifest.deinit(registry);
492
494
  }
493
495
 
494
496
  /* Free allocated strings before deleting the plugin. */
495
 
  plugin_vars_free_values(plugin->system_vars);
496
 
  if (plugin->plugin_dl)
497
 
    plugin_dl_del(&plugin->plugin_dl->dl);
498
 
  plugin->isInited= false;
 
497
  plugin_vars_free_values(module->system_vars);
 
498
  if (module->plugin_dl)
 
499
    plugin_dl_del(&module->plugin_dl->dl);
 
500
  module->isInited= false;
499
501
  pthread_rwlock_wrlock(&LOCK_system_variables_hash);
500
 
  mysql_del_sys_var_chain(plugin->system_vars);
 
502
  mysql_del_sys_var_chain(module->system_vars);
501
503
  pthread_rwlock_unlock(&LOCK_system_variables_hash);
502
 
  delete plugin;
 
504
  delete module;
503
505
}
504
506
 
505
507
static void reap_plugins(plugin::Registry &plugins)
506
508
{
507
509
  size_t count;
508
510
  uint32_t idx;
509
 
  plugin::Handle *plugin;
 
511
  plugin::Module *module;
510
512
 
511
 
  count= plugin_array.elements;
 
513
  count= module_array.elements;
512
514
 
513
515
  for (idx= 0; idx < count; idx++)
514
516
  {
515
 
    plugin= *dynamic_element(&plugin_array, idx, plugin::Handle **);
516
 
    plugin_del(plugins, plugin);
 
517
    module= *dynamic_element(&module_array, idx, plugin::Module **);
 
518
    delete_module(plugins, module);
517
519
  }
518
520
  drizzle_del_plugin_sysvar();
519
521
}
520
522
 
521
523
 
522
 
static void plugin_initialize_vars(plugin::Handle *plugin)
 
524
static void plugin_initialize_vars(plugin::Module *module)
523
525
{
524
 
  if (plugin->getManifest().status_vars)
 
526
  if (module->getManifest().status_vars)
525
527
  {
526
 
    add_status_vars(plugin->getManifest().status_vars); // add_status_vars makes a copy
 
528
    add_status_vars(module->getManifest().status_vars); // add_status_vars makes a copy
527
529
  }
528
530
 
529
531
  /*
530
532
    set the plugin attribute of plugin's sys vars so they are pointing
531
533
    to the active plugin
532
534
  */
533
 
  if (plugin->system_vars)
 
535
  if (module->system_vars)
534
536
  {
535
 
    sys_var_pluginvar *var= plugin->system_vars->cast_pluginvar();
 
537
    sys_var_pluginvar *var= module->system_vars->cast_pluginvar();
536
538
    for (;;)
537
539
    {
538
 
      var->plugin= plugin;
 
540
      var->plugin= module;
539
541
      if (! var->getNext())
540
542
        break;
541
543
      var= var->getNext()->cast_pluginvar();
545
547
 
546
548
 
547
549
static bool plugin_initialize(plugin::Registry &registry,
548
 
                              plugin::Handle *plugin)
 
550
                              plugin::Module *module)
549
551
{
550
 
  assert(plugin->isInited == false);
 
552
  assert(module->isInited == false);
551
553
 
552
 
  registry.setCurrentHandle(plugin);
553
 
  if (plugin->getManifest().init)
 
554
  registry.setCurrentModule(module);
 
555
  if (module->getManifest().init)
554
556
  {
555
 
    if (plugin->getManifest().init(registry))
 
557
    if (module->getManifest().init(registry))
556
558
    {
557
559
      errmsg_printf(ERRMSG_LVL_ERROR,
558
560
                    _("Plugin '%s' init function returned error.\n"),
559
 
                    plugin->getName().c_str());
 
561
                    module->getName().c_str());
560
562
      return true;
561
563
    }
562
564
  }
563
 
  registry.clearCurrentHandle();
564
 
  plugin->isInited= true;
 
565
  registry.clearCurrentModule();
 
566
  module->isInited= true;
565
567
 
566
568
 
567
569
  return false;
591
593
  uint32_t idx;
592
594
  plugin::Manifest **builtins;
593
595
  plugin::Manifest *manifest;
594
 
  plugin::Handle *handle;
 
596
  plugin::Module *module;
595
597
  MEM_ROOT tmp_root;
596
598
 
597
599
  if (initialized)
607
609
 
608
610
  if (my_init_dynamic_array(&plugin_dl_array,
609
611
                            sizeof(plugin::Library *),16,16) ||
610
 
      my_init_dynamic_array(&plugin_array,
611
 
                            sizeof(plugin::Handle *),16,16))
 
612
      my_init_dynamic_array(&module_array,
 
613
                            sizeof(plugin::Module *),16,16))
612
614
    goto err;
613
615
 
614
616
  initialized= 1;
620
622
  {
621
623
    for (manifest= *builtins; manifest->name; manifest++)
622
624
    {
623
 
      handle= new (std::nothrow) plugin::Handle(manifest);
624
 
      if (handle == NULL)
 
625
      module= new (std::nothrow) plugin::Module(manifest);
 
626
      if (module == NULL)
625
627
        return true;
626
628
 
627
629
      free_root(&tmp_root, MYF(MY_MARK_BLOCKS_FREE));
628
 
      if (test_plugin_options(&tmp_root, handle, argc, argv))
 
630
      if (test_plugin_options(&tmp_root, module, argc, argv))
629
631
        continue;
630
632
 
631
 
      if (register_builtin(registry, handle, &handle))
 
633
      if (register_builtin(registry, module, &module))
632
634
        goto err_unlock;
633
635
 
634
 
      plugin_initialize_vars(handle);
 
636
      plugin_initialize_vars(module);
635
637
 
636
638
      if (! (flags & PLUGIN_INIT_SKIP_INITIALIZATION))
637
639
      {
638
 
        if (plugin_initialize(registry, handle))
 
640
        if (plugin_initialize(registry, module))
639
641
          goto err_unlock;
640
642
      }
641
643
    }
655
657
  /*
656
658
    Now we initialize all remaining plugins
657
659
  */
658
 
  for (idx= 0; idx < plugin_array.elements; idx++)
 
660
  for (idx= 0; idx < module_array.elements; idx++)
659
661
  {
660
 
    handle= *dynamic_element(&plugin_array, idx, plugin::Handle **);
661
 
    if (handle->isInited == false)
 
662
    module= *dynamic_element(&module_array, idx, plugin::Module **);
 
663
    if (module->isInited == false)
662
664
    {
663
 
      plugin_initialize_vars(handle);
 
665
      plugin_initialize_vars(module);
664
666
 
665
 
      if (plugin_initialize(registry, handle))
666
 
        plugin_del(registry, handle);
 
667
      if (plugin_initialize(registry, module))
 
668
        delete_module(registry, module);
667
669
    }
668
670
  }
669
671
 
681
683
 
682
684
 
683
685
static bool register_builtin(plugin::Registry &registry,
684
 
                             plugin::Handle *tmp,
685
 
                             plugin::Handle **ptr)
 
686
                             plugin::Module *tmp,
 
687
                             plugin::Module **ptr)
686
688
{
687
689
 
688
690
  tmp->isInited= false;
689
691
  tmp->plugin_dl= 0;
690
692
 
691
 
  if (insert_dynamic(&plugin_array, (unsigned char*)&tmp))
 
693
  if (insert_dynamic(&module_array, (unsigned char*)&tmp))
692
694
    return(1);
693
695
 
694
 
  *ptr= *dynamic_element(&plugin_array, plugin_array.elements - 1,
695
 
                         plugin::Handle **);
 
696
  *ptr= *dynamic_element(&module_array, module_array.elements - 1,
 
697
                         plugin::Module **);
696
698
 
697
699
  registry.add(*ptr);
698
700
 
787
789
void plugin_shutdown(plugin::Registry &registry)
788
790
{
789
791
  uint32_t idx;
790
 
  size_t count= plugin_array.elements;
791
 
  vector<plugin::Handle *> plugins;
 
792
  size_t count= module_array.elements;
 
793
//  vector<plugin::Module *> modules;
792
794
  vector<plugin::Library *> dl;
793
795
 
794
796
  if (initialized)
807
809
 
808
810
  /* Dispose of the memory */
809
811
 
810
 
  delete_dynamic(&plugin_array);
 
812
  delete_dynamic(&module_array);
811
813
 
812
814
  count= plugin_dl_array.elements;
813
815
  dl.reserve(count);
1133
1135
{
1134
1136
  sys_var *var;
1135
1137
  sys_var_pluginvar *pi= NULL;
1136
 
  plugin::Handle *plugin;
 
1138
  plugin::Module *module;
1137
1139
 
1138
1140
  pthread_rwlock_rdlock(&LOCK_system_variables_hash);
1139
1141
  if ((var= intern_find_sys_var(str, length, false)) &&
1140
1142
      (pi= var->cast_pluginvar()))
1141
1143
  {
1142
1144
    pthread_rwlock_unlock(&LOCK_system_variables_hash);
1143
 
    if (!(plugin= pi->plugin))
 
1145
    if (!(module= pi->plugin))
1144
1146
      var= NULL; /* failed to lock it, it must be uninstalling */
1145
 
    else if (plugin->isInited == false)
 
1147
    else if (module->isInited == false)
1146
1148
    {
1147
1149
      var= NULL;
1148
1150
    }
1877
1879
}
1878
1880
 
1879
1881
 
1880
 
static int construct_options(MEM_ROOT *mem_root, plugin::Handle *tmp,
 
1882
static int construct_options(MEM_ROOT *mem_root, plugin::Module *tmp,
1881
1883
                             my_option *options, bool can_disable)
1882
1884
{
1883
1885
  const char *plugin_name= tmp->getManifest().name;
2105
2107
}
2106
2108
 
2107
2109
 
2108
 
static my_option *construct_help_options(MEM_ROOT *mem_root, plugin::Handle *p)
 
2110
static my_option *construct_help_options(MEM_ROOT *mem_root, plugin::Module *p)
2109
2111
{
2110
2112
  st_mysql_sys_var **opt;
2111
2113
  my_option *opts;
2163
2165
  NOTE:
2164
2166
    Requires that a write-lock is held on LOCK_system_variables_hash
2165
2167
*/
2166
 
static int test_plugin_options(MEM_ROOT *tmp_root, plugin::Handle *tmp,
 
2168
static int test_plugin_options(MEM_ROOT *tmp_root, plugin::Module *tmp,
2167
2169
                               int *argc, char **argv)
2168
2170
{
2169
2171
  struct sys_var_chain chain= { NULL, NULL };
2287
2289
void my_print_help_inc_plugins(my_option *main_options)
2288
2290
{
2289
2291
  vector<my_option> all_options;
2290
 
  plugin::Handle *p;
 
2292
  plugin::Module *p;
2291
2293
  MEM_ROOT mem_root;
2292
2294
  my_option *opt= NULL;
2293
2295
 
2294
2296
  init_alloc_root(&mem_root, 4096, 4096);
2295
2297
 
2296
2298
  if (initialized)
2297
 
    for (uint32_t idx= 0; idx < plugin_array.elements; idx++)
 
2299
    for (uint32_t idx= 0; idx < module_array.elements; idx++)
2298
2300
    {
2299
 
      p= *dynamic_element(&plugin_array, idx, plugin::Handle **);
 
2301
      p= *dynamic_element(&module_array, idx, plugin::Module **);
2300
2302
 
2301
2303
      if (p->getManifest().system_vars == NULL)
2302
2304
        continue;