← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_plugin.cc

  • Committer: Monty Taylor
  • Date: 2009-01-06 18:48:07 UTC
  • mto: This revision was merged to the branch mainline in revision 762.
  • Revision ID: mordred@inaugust.com-20090106184807-cen092lvb8mc3z4k
Enabled deadlock_innodb.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_plugin.cc
11
11
 
12
12
   You should have received a copy of the GNU General Public License
13
13
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
15
 
 
16
 
#include "config.h"
17
 
 
18
 
#include <dlfcn.h>
19
 
 
20
 
#include <cstdio>
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
15
 
 
16
#include <drizzled/server_includes.h>
 
17
#include <mysys/my_getopt.h>
 
18
#include <mysys/hash.h>
 
19
 
 
20
#include <drizzled/authentication.h>
 
21
#include <drizzled/logging.h>
 
22
#include <drizzled/errmsg.h>
 
23
#include <drizzled/configvar.h>
 
24
#include <drizzled/qcache.h>
 
25
#include <drizzled/parser.h>
 
26
#include <drizzled/sql_parse.h>
 
27
#include <drizzled/scheduling.h>
 
28
#include <drizzled/replicator.h>
 
29
#include <drizzled/show.h>
 
30
#include <drizzled/handler.h>
 
31
#include <drizzled/set_var.h>
 
32
#include <drizzled/session.h>
 
33
#include <drizzled/item/null.h>
 
34
 
21
35
#include <string>
22
36
#include <vector>
23
 
#include <map>
24
 
#include <algorithm>
25
 
#include <iostream>
26
 
 
27
 
#include <boost/program_options.hpp>
28
 
 
29
 
#include "drizzled/option.h"
30
 
#include "drizzled/internal/m_string.h"
31
 
 
32
 
#include "drizzled/plugin.h"
33
 
#include "drizzled/module/load_list.h"
34
 
#include "drizzled/module/library.h"
35
 
#include "drizzled/module/registry.h"
36
 
#include "drizzled/module/option_context.h"
37
 
#include "drizzled/sql_parse.h"
38
 
#include "drizzled/show.h"
39
 
#include "drizzled/cursor.h"
40
 
#include "drizzled/set_var.h"
41
 
#include "drizzled/session.h"
42
 
#include "drizzled/item/null.h"
43
 
#include "drizzled/error.h"
44
 
#include "drizzled/gettext.h"
45
 
#include "drizzled/errmsg_print.h"
46
 
#include "drizzled/strfunc.h"
47
 
#include "drizzled/pthread_globals.h"
48
 
#include "drizzled/util/tokenize.h"
49
 
 
50
 
#include <boost/foreach.hpp>
51
 
 
52
 
/* FreeBSD 2.2.2 does not define RTLD_NOW) */
53
 
#ifndef RTLD_NOW
54
 
#define RTLD_NOW 1
55
 
#endif
56
 
 
57
 
namespace po=boost::program_options;
 
37
 
 
38
#include <drizzled/error.h>
 
39
#include <drizzled/gettext.h>
 
40
 
 
41
#define REPORT_TO_LOG  1
 
42
#define REPORT_TO_USER 2
 
43
 
 
44
#define plugin_ref_to_int(A) (A ? A[0] : NULL)
 
45
#define plugin_int_to_ref(A) &(A)
58
46
 
59
47
using namespace std;
60
48
 
61
 
/** These exist just to prevent symbols from being optimized out */
62
 
typedef drizzled::module::Manifest drizzled_builtin_list[];
63
 
extern drizzled_builtin_list PANDORA_BUILTIN_SYMBOLS_LIST;
64
 
extern drizzled_builtin_list PANDORA_BUILTIN_LOAD_SYMBOLS_LIST;
65
 
drizzled::module::Manifest *drizzled_builtins[]=
66
 
{
67
 
  PANDORA_BUILTIN_SYMBOLS_LIST, NULL
68
 
};
69
 
drizzled::module::Manifest *drizzled_load_builtins[]=
70
 
{
71
 
  PANDORA_BUILTIN_LOAD_SYMBOLS_LIST, NULL
72
 
};
73
 
 
74
 
namespace drizzled
75
 
{
76
 
 
77
 
 
78
 
typedef vector<string> PluginOptions;
79
 
static PluginOptions opt_plugin_load;
80
 
static PluginOptions opt_plugin_add;
81
 
static PluginOptions opt_plugin_remove;
82
 
const char *builtin_plugins= PANDORA_BUILTIN_LIST;
83
 
const char *builtin_load_plugins= PANDORA_BUILTIN_LOAD_LIST;
 
49
extern struct st_mysql_plugin *mysqld_builtins[];
 
50
 
 
51
char *opt_plugin_load= NULL;
 
52
char *opt_plugin_dir_ptr;
 
53
char opt_plugin_dir[FN_REFLEN];
 
54
/*
 
55
  When you ad a new plugin type, add both a string and make sure that the
 
56
  init and deinit array are correctly updated.
 
57
*/
 
58
const LEX_STRING plugin_type_names[DRIZZLE_MAX_PLUGIN_TYPE_NUM]=
 
59
{
 
60
  { C_STRING_WITH_LEN("DAEMON") },
 
61
  { C_STRING_WITH_LEN("STORAGE ENGINE") },
 
62
  { C_STRING_WITH_LEN("INFORMATION SCHEMA") },
 
63
  { C_STRING_WITH_LEN("UDF") },
 
64
  { C_STRING_WITH_LEN("UDA") },
 
65
  { C_STRING_WITH_LEN("AUDIT") },
 
66
  { C_STRING_WITH_LEN("LOGGER") },
 
67
  { C_STRING_WITH_LEN("ERRMSG") },
 
68
  { C_STRING_WITH_LEN("AUTH") },
 
69
  { C_STRING_WITH_LEN("CONFIGVAR") },
 
70
  { C_STRING_WITH_LEN("QCACHE") },
 
71
  { C_STRING_WITH_LEN("PARSER") },
 
72
  { C_STRING_WITH_LEN("SCHEDULING") },
 
73
  { C_STRING_WITH_LEN("REPLICATOR") }
 
74
};
 
75
 
 
76
extern int initialize_schema_table(st_plugin_int *plugin);
 
77
extern int finalize_schema_table(st_plugin_int *plugin);
 
78
 
 
79
extern int initialize_udf(st_plugin_int *plugin);
 
80
extern int finalize_udf(st_plugin_int *plugin);
 
81
 
 
82
/*
 
83
  The number of elements in both plugin_type_initialize and
 
84
  plugin_type_deinitialize should equal to the number of plugins
 
85
  defined.
 
86
*/
 
87
plugin_type_init plugin_type_initialize[DRIZZLE_MAX_PLUGIN_TYPE_NUM]=
 
88
{
 
89
  0,  /* Daemon */
 
90
  ha_initialize_handlerton,  /* Storage Engine */
 
91
  initialize_schema_table,  /* Information Schema */
 
92
  initialize_udf,  /* UDF */
 
93
  0,  /* UDA */
 
94
  0,  /* Audit */
 
95
  logging_initializer,  /* Logger */
 
96
  errmsg_initializer,  /* Error Messages */
 
97
  authentication_initializer,  /* Auth */
 
98
  configvar_initializer,
 
99
  qcache_initializer,
 
100
  parser_initializer,
 
101
  scheduling_initializer,
 
102
  replicator_initializer
 
103
};
 
104
 
 
105
plugin_type_init plugin_type_deinitialize[DRIZZLE_MAX_PLUGIN_TYPE_NUM]=
 
106
{
 
107
  0,  /* Daemon */
 
108
  ha_finalize_handlerton,  /* Storage Engine */
 
109
  finalize_schema_table,  /* Information Schema */
 
110
  finalize_udf,  /* UDF */
 
111
  0,  /* UDA */
 
112
  0,  /* Audit */
 
113
  logging_finalizer,  /* Logger */
 
114
  errmsg_finalizer,  /* Logger */
 
115
  authentication_finalizer,  /* Auth */
 
116
  configvar_finalizer,
 
117
  qcache_finalizer,
 
118
  parser_finalizer,
 
119
  scheduling_finalizer,
 
120
  replicator_finalizer
 
121
};
 
122
 
 
123
static const char *plugin_declarations_sym= "_mysql_plugin_declarations_";
84
124
 
85
125
/* Note that 'int version' must be the first field of every plugin
86
126
   sub-structure (plugin->info).
87
127
*/
88
128
 
89
 
static bool initialized= false;
90
 
 
91
 
 
 
129
static bool initialized= 0;
 
130
 
 
131
static DYNAMIC_ARRAY plugin_dl_array;
 
132
static DYNAMIC_ARRAY plugin_array;
 
133
static HASH plugin_hash[DRIZZLE_MAX_PLUGIN_TYPE_NUM];
92
134
static bool reap_needed= false;
 
135
static int plugin_array_version=0;
93
136
 
94
137
/*
95
138
  write-lock on LOCK_system_variables_hash is required before modifying
96
139
  the following variables/structures
97
140
*/
98
 
static memory::Root plugin_mem_root(4096);
 
141
static MEM_ROOT plugin_mem_root;
99
142
static uint32_t global_variables_dynamic_size= 0;
 
143
static HASH bookmark_hash;
100
144
 
101
145
 
102
146
/*
103
147
  hidden part of opaque value passed to variable check functions.
104
148
  Used to provide a object-like structure to non C++ consumers.
105
149
*/
106
 
struct st_item_value_holder : public drizzle_value
 
150
struct st_item_value_holder : public st_mysql_value
107
151
{
108
152
  Item *item;
109
153
};
110
154
 
111
 
class Bookmark
 
155
 
 
156
/*
 
157
  stored in bookmark_hash, this structure is never removed from the
 
158
  hash and is used to mark a single offset for a session local variable
 
159
  even if plugins have been uninstalled and reinstalled, repeatedly.
 
160
  This structure is allocated from plugin_mem_root.
 
161
 
 
162
  The key format is as follows:
 
163
    1 byte         - variable type code
 
164
    name_len bytes - variable name
 
165
    '\0'           - end of key
 
166
*/
 
167
struct st_bookmark
112
168
{
113
 
public:
114
 
  Bookmark() :
115
 
    type_code(0),
116
 
    offset(0),
117
 
    version(0),
118
 
    key("")
119
 
  {}
120
 
  uint8_t type_code;
 
169
  uint32_t name_len;
121
170
  int offset;
122
171
  uint32_t version;
123
 
  string key;
124
 
};
125
 
 
126
 
typedef boost::unordered_map<string, Bookmark> bookmark_unordered_map;
127
 
static bookmark_unordered_map bookmark_hash;
128
 
 
 
172
  char key[1];
 
173
};
 
174
 
 
175
 
 
176
/*
 
177
  skeleton of a plugin variable - portion of structure common to all.
 
178
*/
 
179
struct st_mysql_sys_var
 
180
{
 
181
  DRIZZLE_PLUGIN_VAR_HEADER;
 
182
};
 
183
 
 
184
 
 
185
/*
 
186
  sys_var class for access to all plugin variables visible to the user
 
187
*/
 
188
class sys_var_pluginvar: public sys_var
 
189
{
 
190
public:
 
191
  struct st_plugin_int *plugin;
 
192
  struct st_mysql_sys_var *plugin_var;
 
193
 
 
194
  static void *operator new(size_t size, MEM_ROOT *mem_root)
 
195
  { return (void*) alloc_root(mem_root, (uint) size); }
 
196
  static void operator delete(void *, size_t)
 
197
  { TRASH(ptr_arg, size); }
 
198
 
 
199
  sys_var_pluginvar(const char *name_arg,
 
200
                    struct st_mysql_sys_var *plugin_var_arg)
 
201
    :sys_var(name_arg), plugin_var(plugin_var_arg) {}
 
202
  sys_var_pluginvar *cast_pluginvar() { return this; }
 
203
  bool is_readonly() const { return plugin_var->flags & PLUGIN_VAR_READONLY; }
 
204
  bool check_type(enum_var_type type)
 
205
  { return !(plugin_var->flags & PLUGIN_VAR_SessionLOCAL) && type != OPT_GLOBAL; }
 
206
  bool check_update_type(Item_result type);
 
207
  SHOW_TYPE show_type();
 
208
  unsigned char* real_value_ptr(Session *session, enum_var_type type);
 
209
  TYPELIB* plugin_var_typelib(void);
 
210
  unsigned char* value_ptr(Session *session, enum_var_type type, LEX_STRING *base);
 
211
  bool check(Session *session, set_var *var);
 
212
  bool check_default(enum_var_type)
 
213
    { return is_readonly(); }
 
214
  void set_default(Session *session, enum_var_type);
 
215
  bool update(Session *session, set_var *var);
 
216
};
129
217
 
130
218
 
131
219
/* prototypes */
132
 
static void plugin_prune_list(vector<string> &plugin_list,
133
 
                              const vector<string> &plugins_to_remove);
134
 
static bool plugin_load_list(module::Registry &registry,
135
 
                             memory::Root *tmp_root,
136
 
                             const set<string> &plugin_list,
137
 
                             po::options_description &long_options,
138
 
                             bool builtin= false);
139
 
static int test_plugin_options(memory::Root *, module::Module *,
140
 
                               po::options_description &long_options);
141
 
static void unlock_variables(Session *session, drizzle_system_variables *vars);
142
 
static void cleanup_variables(drizzle_system_variables *vars);
 
220
static bool plugin_load_list(MEM_ROOT *tmp_root, int *argc, char **argv,
 
221
                             const char *list);
 
222
static int test_plugin_options(MEM_ROOT *, struct st_plugin_int *,
 
223
                               int *, char **);
 
224
static bool register_builtin(struct st_mysql_plugin *, struct st_plugin_int *,
 
225
                             struct st_plugin_int **);
 
226
static void unlock_variables(Session *session, struct system_variables *vars);
 
227
static void cleanup_variables(Session *session, struct system_variables *vars);
 
228
static void plugin_vars_free_values(sys_var *vars);
 
229
static void plugin_opt_set_limits(struct my_option *options,
 
230
                                  const struct st_mysql_sys_var *opt);
 
231
#define my_intern_plugin_lock(A,B) intern_plugin_lock(A,B)
 
232
#define my_intern_plugin_lock_ci(A,B) intern_plugin_lock(A,B)
 
233
static plugin_ref intern_plugin_lock(LEX *lex, plugin_ref plugin);
 
234
static void intern_plugin_unlock(LEX *lex, plugin_ref plugin);
 
235
static void reap_plugins(void);
 
236
 
 
237
 
 
238
/* declared in set_var.cc */
 
239
extern sys_var *intern_find_sys_var(const char *str, uint32_t length, bool no_error);
 
240
extern bool throw_bounds_warning(Session *session, bool fixed, bool unsignd,
 
241
                                 const char *name, int64_t val);
 
242
 
 
243
/****************************************************************************
 
244
  Value type thunks, allows the C world to play in the C++ world
 
245
****************************************************************************/
 
246
 
 
247
static int item_value_type(struct st_mysql_value *value)
 
248
{
 
249
  switch (((st_item_value_holder*)value)->item->result_type()) {
 
250
  case INT_RESULT:
 
251
    return DRIZZLE_VALUE_TYPE_INT;
 
252
  case REAL_RESULT:
 
253
    return DRIZZLE_VALUE_TYPE_REAL;
 
254
  default:
 
255
    return DRIZZLE_VALUE_TYPE_STRING;
 
256
  }
 
257
}
 
258
 
 
259
static const char *item_val_str(struct st_mysql_value *value,
 
260
                                char *buffer, int *length)
 
261
{
 
262
  String str(buffer, *length, system_charset_info), *res;
 
263
  if (!(res= ((st_item_value_holder*)value)->item->val_str(&str)))
 
264
    return NULL;
 
265
  *length= res->length();
 
266
  if (res->c_ptr_quick() == buffer)
 
267
    return buffer;
 
268
 
 
269
  /*
 
270
    Lets be nice and create a temporary string since the
 
271
    buffer was too small
 
272
  */
 
273
  return current_session->strmake(res->c_ptr_quick(), res->length());
 
274
}
 
275
 
 
276
 
 
277
static int item_val_int(struct st_mysql_value *value, int64_t *buf)
 
278
{
 
279
  Item *item= ((st_item_value_holder*)value)->item;
 
280
  *buf= item->val_int();
 
281
  if (item->is_null())
 
282
    return 1;
 
283
  return 0;
 
284
}
 
285
 
 
286
 
 
287
static int item_val_real(struct st_mysql_value *value, double *buf)
 
288
{
 
289
  Item *item= ((st_item_value_holder*)value)->item;
 
290
  *buf= item->val_real();
 
291
  if (item->is_null())
 
292
    return 1;
 
293
  return 0;
 
294
}
143
295
 
144
296
 
145
297
/****************************************************************************
146
298
  Plugin support code
147
299
****************************************************************************/
148
300
 
149
 
 
 
301
static struct st_plugin_dl *plugin_dl_find(const LEX_STRING *dl)
 
302
{
 
303
  uint32_t i;
 
304
  struct st_plugin_dl *tmp;
 
305
 
 
306
  for (i= 0; i < plugin_dl_array.elements; i++)
 
307
  {
 
308
    tmp= *dynamic_element(&plugin_dl_array, i, struct st_plugin_dl **);
 
309
    if (tmp->ref_count &&
 
310
        ! my_strnncoll(files_charset_info,
 
311
                       (const unsigned char *)dl->str, dl->length,
 
312
                       (const unsigned char *)tmp->dl.str, tmp->dl.length))
 
313
      return(tmp);
 
314
  }
 
315
  return(0);
 
316
}
 
317
 
 
318
static st_plugin_dl *plugin_dl_insert_or_reuse(struct st_plugin_dl *plugin_dl)
 
319
{
 
320
  uint32_t i;
 
321
  struct st_plugin_dl *tmp;
 
322
 
 
323
  for (i= 0; i < plugin_dl_array.elements; i++)
 
324
  {
 
325
    tmp= *dynamic_element(&plugin_dl_array, i, struct st_plugin_dl **);
 
326
    if (! tmp->ref_count)
 
327
    {
 
328
      memcpy(tmp, plugin_dl, sizeof(struct st_plugin_dl));
 
329
      return(tmp);
 
330
    }
 
331
  }
 
332
  if (insert_dynamic(&plugin_dl_array, (unsigned char*)&plugin_dl))
 
333
    return(0);
 
334
  tmp= *dynamic_element(&plugin_dl_array, plugin_dl_array.elements - 1,
 
335
                        struct st_plugin_dl **)=
 
336
      (struct st_plugin_dl *) memdup_root(&plugin_mem_root, (unsigned char*)plugin_dl,
 
337
                                           sizeof(struct st_plugin_dl));
 
338
  return(tmp);
 
339
}
 
340
 
 
341
static inline void free_plugin_mem(struct st_plugin_dl *p)
 
342
{
 
343
  if (p->handle)
 
344
    dlclose(p->handle);
 
345
  free(p->dl.str);
 
346
}
 
347
 
 
348
 
 
349
static st_plugin_dl *plugin_dl_add(const LEX_STRING *dl, int report)
 
350
{
 
351
  string dlpath;
 
352
  uint32_t plugin_dir_len, dummy_errors;
 
353
  struct st_plugin_dl *tmp, plugin_dl;
 
354
  void *sym;
 
355
  plugin_dir_len= strlen(opt_plugin_dir);
 
356
  dlpath.reserve(FN_REFLEN);
 
357
  /*
 
358
    Ensure that the dll doesn't have a path.
 
359
    This is done to ensure that only approved libraries from the
 
360
    plugin directory are used (to make this even remotely secure).
 
361
  */
 
362
  if (strchr(dl->str, FN_LIBCHAR) ||
 
363
      check_string_char_length((LEX_STRING *) dl, "", NAME_CHAR_LEN,
 
364
                               system_charset_info, 1) ||
 
365
      plugin_dir_len + dl->length + 1 >= FN_REFLEN)
 
366
  {
 
367
    if (report & REPORT_TO_USER)
 
368
      my_error(ER_UDF_NO_PATHS, MYF(0));
 
369
    if (report & REPORT_TO_LOG)
 
370
      errmsg_printf(ERRMSG_LVL_ERROR, "%s",ER(ER_UDF_NO_PATHS));
 
371
    return(0);
 
372
  }
 
373
  /* If this dll is already loaded just increase ref_count. */
 
374
  if ((tmp= plugin_dl_find(dl)))
 
375
  {
 
376
    tmp->ref_count++;
 
377
    return(tmp);
 
378
  }
 
379
  memset(&plugin_dl, 0, sizeof(plugin_dl));
 
380
  /* Compile dll path */
 
381
  dlpath.append(opt_plugin_dir);
 
382
  dlpath.append("/");
 
383
  dlpath.append(dl->str);
 
384
  plugin_dl.ref_count= 1;
 
385
  /* Open new dll handle */
 
386
  if (!(plugin_dl.handle= dlopen(dlpath.c_str(), RTLD_LAZY|RTLD_GLOBAL)))
 
387
  {
 
388
    const char *errmsg=dlerror();
 
389
    uint32_t dlpathlen= dlpath.length();
 
390
    if (!dlpath.compare(0, dlpathlen, errmsg))
 
391
    { // if errmsg starts from dlpath, trim this prefix.
 
392
      errmsg+=dlpathlen;
 
393
      if (*errmsg == ':') errmsg++;
 
394
      if (*errmsg == ' ') errmsg++;
 
395
    }
 
396
    if (report & REPORT_TO_USER)
 
397
      my_error(ER_CANT_OPEN_LIBRARY, MYF(0), dlpath.c_str(), errno, errmsg);
 
398
    if (report & REPORT_TO_LOG)
 
399
      errmsg_printf(ERRMSG_LVL_ERROR, ER(ER_CANT_OPEN_LIBRARY), dlpath.c_str(), errno, errmsg);
 
400
    return(0);
 
401
  }
 
402
 
 
403
  /* Find plugin declarations */
 
404
  if (!(sym= dlsym(plugin_dl.handle, plugin_declarations_sym)))
 
405
  {
 
406
    free_plugin_mem(&plugin_dl);
 
407
    if (report & REPORT_TO_USER)
 
408
      my_error(ER_CANT_FIND_DL_ENTRY, MYF(0), plugin_declarations_sym);
 
409
    if (report & REPORT_TO_LOG)
 
410
      errmsg_printf(ERRMSG_LVL_ERROR, ER(ER_CANT_FIND_DL_ENTRY), plugin_declarations_sym);
 
411
    return(0);
 
412
  }
 
413
 
 
414
  plugin_dl.plugins= (struct st_mysql_plugin *)sym;
 
415
 
 
416
  /* Duplicate and convert dll name */
 
417
  plugin_dl.dl.length= dl->length * files_charset_info->mbmaxlen + 1;
 
418
  if (! (plugin_dl.dl.str= (char*) malloc(plugin_dl.dl.length)))
 
419
  {
 
420
    free_plugin_mem(&plugin_dl);
 
421
    if (report & REPORT_TO_USER)
 
422
      my_error(ER_OUTOFMEMORY, MYF(0), plugin_dl.dl.length);
 
423
    if (report & REPORT_TO_LOG)
 
424
      errmsg_printf(ERRMSG_LVL_ERROR, ER(ER_OUTOFMEMORY), plugin_dl.dl.length);
 
425
    return(0);
 
426
  }
 
427
  plugin_dl.dl.length= copy_and_convert(plugin_dl.dl.str, plugin_dl.dl.length,
 
428
    files_charset_info, dl->str, dl->length, system_charset_info,
 
429
    &dummy_errors);
 
430
  plugin_dl.dl.str[plugin_dl.dl.length]= 0;
 
431
  /* Add this dll to array */
 
432
  if (! (tmp= plugin_dl_insert_or_reuse(&plugin_dl)))
 
433
  {
 
434
    free_plugin_mem(&plugin_dl);
 
435
    if (report & REPORT_TO_USER)
 
436
      my_error(ER_OUTOFMEMORY, MYF(0), sizeof(struct st_plugin_dl));
 
437
    if (report & REPORT_TO_LOG)
 
438
      errmsg_printf(ERRMSG_LVL_ERROR, ER(ER_OUTOFMEMORY), sizeof(struct st_plugin_dl));
 
439
    return(0);
 
440
  }
 
441
  return(tmp);
 
442
}
 
443
 
 
444
 
 
445
static void plugin_dl_del(const LEX_STRING *dl)
 
446
{
 
447
  uint32_t i;
 
448
 
 
449
  for (i= 0; i < plugin_dl_array.elements; i++)
 
450
  {
 
451
    struct st_plugin_dl *tmp= *dynamic_element(&plugin_dl_array, i,
 
452
                                               struct st_plugin_dl **);
 
453
    if (tmp->ref_count &&
 
454
        ! my_strnncoll(files_charset_info,
 
455
                       (const unsigned char *)dl->str, dl->length,
 
456
                       (const unsigned char *)tmp->dl.str, tmp->dl.length))
 
457
    {
 
458
      /* Do not remove this element, unless no other plugin uses this dll. */
 
459
      if (! --tmp->ref_count)
 
460
      {
 
461
        free_plugin_mem(tmp);
 
462
        memset(tmp, 0, sizeof(struct st_plugin_dl));
 
463
      }
 
464
      break;
 
465
    }
 
466
  }
 
467
  return;
 
468
}
 
469
 
 
470
 
 
471
static struct st_plugin_int *plugin_find_internal(const LEX_STRING *name, int type)
 
472
{
 
473
  uint32_t i;
 
474
  if (! initialized)
 
475
    return(0);
 
476
 
 
477
  if (type == DRIZZLE_ANY_PLUGIN)
 
478
  {
 
479
    for (i= 0; i < DRIZZLE_MAX_PLUGIN_TYPE_NUM; i++)
 
480
    {
 
481
      struct st_plugin_int *plugin= (st_plugin_int *)
 
482
        hash_search(&plugin_hash[i], (const unsigned char *)name->str, name->length);
 
483
      if (plugin)
 
484
        return(plugin);
 
485
    }
 
486
  }
 
487
  else
 
488
    return((st_plugin_int *)
 
489
        hash_search(&plugin_hash[type], (const unsigned char *)name->str, name->length));
 
490
  return(0);
 
491
}
 
492
 
 
493
 
 
494
static SHOW_COMP_OPTION plugin_status(const LEX_STRING *name, int type)
 
495
{
 
496
  SHOW_COMP_OPTION rc= SHOW_OPTION_NO;
 
497
  struct st_plugin_int *plugin;
 
498
  if ((plugin= plugin_find_internal(name, type)))
 
499
  {
 
500
    rc= SHOW_OPTION_DISABLED;
 
501
    if (plugin->state == PLUGIN_IS_READY)
 
502
      rc= SHOW_OPTION_YES;
 
503
  }
 
504
  return(rc);
 
505
}
 
506
 
 
507
 
 
508
bool plugin_is_ready(const LEX_STRING *name, int type)
 
509
{
 
510
  bool rc= false;
 
511
  if (plugin_status(name, type) == SHOW_OPTION_YES)
 
512
    rc= true;
 
513
  return rc;
 
514
}
 
515
 
 
516
 
 
517
SHOW_COMP_OPTION sys_var_have_plugin::get_option()
 
518
{
 
519
  LEX_STRING plugin_name= { (char *) plugin_name_str, plugin_name_len };
 
520
  return plugin_status(&plugin_name, plugin_type);
 
521
}
 
522
 
 
523
 
 
524
static plugin_ref intern_plugin_lock(LEX *, plugin_ref rc)
 
525
{
 
526
  st_plugin_int *pi= plugin_ref_to_int(rc);
 
527
 
 
528
  if (pi->state & (PLUGIN_IS_READY | PLUGIN_IS_UNINITIALIZED))
 
529
  {
 
530
    plugin_ref plugin;
 
531
    /*
 
532
      For debugging, we do an additional malloc which allows the
 
533
      memory manager and/or valgrind to track locked references and
 
534
      double unlocks to aid resolving reference counting.problems.
 
535
    */
 
536
    if (!(plugin= (plugin_ref) malloc(sizeof(pi))))
 
537
      return(NULL);
 
538
 
 
539
    *plugin= pi;
 
540
    pi->ref_count++;
 
541
 
 
542
    return(plugin);
 
543
  }
 
544
  return(NULL);
 
545
}
 
546
 
 
547
 
 
548
plugin_ref plugin_lock(Session *session, plugin_ref *ptr)
 
549
{
 
550
  LEX *lex= session ? session->lex : 0;
 
551
  plugin_ref rc;
 
552
  rc= my_intern_plugin_lock_ci(lex, *ptr);
 
553
  return(rc);
 
554
}
 
555
 
 
556
 
 
557
plugin_ref plugin_lock_by_name(Session *session, const LEX_STRING *name, int type)
 
558
{
 
559
  LEX *lex= session ? session->lex : 0;
 
560
  plugin_ref rc= NULL;
 
561
  st_plugin_int *plugin;
 
562
  if ((plugin= plugin_find_internal(name, type)))
 
563
    rc= my_intern_plugin_lock_ci(lex, plugin_int_to_ref(plugin));
 
564
  return(rc);
 
565
}
 
566
 
 
567
 
 
568
static st_plugin_int *plugin_insert_or_reuse(struct st_plugin_int *plugin)
 
569
{
 
570
  uint32_t i;
 
571
  struct st_plugin_int *tmp;
 
572
  for (i= 0; i < plugin_array.elements; i++)
 
573
  {
 
574
    tmp= *dynamic_element(&plugin_array, i, struct st_plugin_int **);
 
575
    if (tmp->state == PLUGIN_IS_FREED)
 
576
    {
 
577
      memcpy(tmp, plugin, sizeof(struct st_plugin_int));
 
578
      return(tmp);
 
579
    }
 
580
  }
 
581
  if (insert_dynamic(&plugin_array, (unsigned char*)&plugin))
 
582
    return(0);
 
583
  tmp= *dynamic_element(&plugin_array, plugin_array.elements - 1,
 
584
                        struct st_plugin_int **)=
 
585
       (struct st_plugin_int *) memdup_root(&plugin_mem_root, (unsigned char*)plugin,
 
586
                                            sizeof(struct st_plugin_int));
 
587
  return(tmp);
 
588
}
150
589
 
151
590
 
152
591
/*
153
592
  NOTE
154
593
    Requires that a write-lock is held on LOCK_system_variables_hash
155
594
*/
156
 
static bool plugin_add(module::Registry &registry, memory::Root *tmp_root,
157
 
                       module::Library *library,
158
 
                       po::options_description &long_options)
 
595
static bool plugin_add(MEM_ROOT *tmp_root,
 
596
                       const LEX_STRING *name, const LEX_STRING *dl,
 
597
                       int *argc, char **argv, int report)
159
598
{
160
 
  if (! initialized)
161
 
    return true;
162
 
 
163
 
  if (registry.find(library->getName()))
 
599
  struct st_plugin_int tmp;
 
600
  struct st_mysql_plugin *plugin;
 
601
  if (plugin_find_internal(name, DRIZZLE_ANY_PLUGIN))
164
602
  {
165
 
    errmsg_printf(error::WARN, ER(ER_PLUGIN_EXISTS),
166
 
                  library->getName().c_str());
167
 
    return false;
 
603
    if (report & REPORT_TO_USER)
 
604
      my_error(ER_UDF_EXISTS, MYF(0), name->str);
 
605
    if (report & REPORT_TO_LOG)
 
606
      errmsg_printf(ERRMSG_LVL_ERROR, ER(ER_UDF_EXISTS), name->str);
 
607
    return(true);
168
608
  }
169
 
 
170
 
  module::Module *tmp= NULL;
 
609
  /* Clear the whole struct to catch future extensions. */
 
610
  memset(&tmp, 0, sizeof(tmp));
 
611
  if (! (tmp.plugin_dl= plugin_dl_add(dl, report)))
 
612
    return(true);
171
613
  /* Find plugin by name */
172
 
  const module::Manifest *manifest= library->getManifest();
173
 
 
174
 
  if (registry.find(manifest->name))
175
 
  {
176
 
    errmsg_printf(error::ERROR, 
177
 
                  _("Plugin '%s' contains the name '%s' in its manifest, which "
178
 
                    "has already been registered.\n"),
179
 
                  library->getName().c_str(),
180
 
                  manifest->name);
181
 
    return true;
182
 
  }
183
 
 
184
 
  tmp= new (std::nothrow) module::Module(manifest, library);
185
 
  if (tmp == NULL)
186
 
    return true;
187
 
 
188
 
  if (!test_plugin_options(tmp_root, tmp, long_options))
189
 
  {
190
 
    registry.add(tmp);
191
 
    return false;
192
 
  }
193
 
  errmsg_printf(error::ERROR, ER(ER_CANT_FIND_DL_ENTRY),
194
 
                library->getName().c_str());
195
 
  return true;
196
 
}
197
 
 
198
 
 
199
 
static void reap_plugins(module::Registry &registry)
200
 
{
201
 
  std::map<std::string, module::Module *>::const_iterator modules=
202
 
    registry.getModulesMap().begin();
203
 
 
204
 
  while (modules != registry.getModulesMap().end())
205
 
  {
206
 
    module::Module *module= (*modules).second;
207
 
    delete module;
208
 
    ++modules;
209
 
  }
210
 
}
211
 
 
212
 
 
213
 
static bool plugin_initialize(module::Registry &registry,
214
 
                              module::Module *module)
215
 
{
216
 
  assert(module->isInited == false);
217
 
 
218
 
  module::Context loading_context(registry, module);
219
 
  if (module->getManifest().init)
220
 
  {
221
 
    if (module->getManifest().init(loading_context))
222
 
    {
223
 
      errmsg_printf(error::ERROR,
224
 
                    _("Plugin '%s' init function returned error.\n"),
225
 
                    module->getName().c_str());
226
 
      return true;
227
 
    }
228
 
  }
229
 
  module->isInited= true;
230
 
 
231
 
 
232
 
  return false;
233
 
}
234
 
 
235
 
 
236
 
inline static void dashes_to_underscores(std::string &name_in,
237
 
                                         char from= '-', char to= '_')
238
 
{
239
 
  for (string::iterator p= name_in.begin();
240
 
       p != name_in.end();
241
 
       ++p)
242
 
  {
243
 
    if (*p == from)
244
 
    {
245
 
      *p= to;
246
 
    }
247
 
  }
248
 
}
249
 
 
250
 
inline static void underscores_to_dashes(std::string &name_in)
251
 
{
252
 
  return dashes_to_underscores(name_in, '_', '-');
253
 
}
254
 
 
255
 
static void compose_plugin_options(vector<string> &target,
256
 
                                   vector<string> options)
257
 
{
258
 
  for (vector<string>::iterator it= options.begin();
259
 
       it != options.end();
260
 
       ++it)
261
 
  {
262
 
    tokenize(*it, target, ",", true);
263
 
  }
264
 
  for (vector<string>::iterator it= target.begin();
265
 
       it != target.end();
266
 
       ++it)
267
 
  {
268
 
    dashes_to_underscores(*it);
269
 
  }
270
 
}
271
 
 
272
 
void compose_plugin_add(vector<string> options)
273
 
{
274
 
  compose_plugin_options(opt_plugin_add, options);
275
 
}
276
 
 
277
 
void compose_plugin_remove(vector<string> options)
278
 
{
279
 
  compose_plugin_options(opt_plugin_remove, options);
280
 
}
281
 
 
282
 
void notify_plugin_load(string in_plugin_load)
283
 
{
284
 
  tokenize(in_plugin_load, opt_plugin_load, ",", true);
285
 
}
 
614
  for (plugin= tmp.plugin_dl->plugins; plugin->name; plugin++)
 
615
  {
 
616
    uint32_t name_len= strlen(plugin->name);
 
617
    if (plugin->type < DRIZZLE_MAX_PLUGIN_TYPE_NUM &&
 
618
        ! my_strnncoll(system_charset_info,
 
619
                       (const unsigned char *)name->str, name->length,
 
620
                       (const unsigned char *)plugin->name,
 
621
                       name_len))
 
622
    {
 
623
      struct st_plugin_int *tmp_plugin_ptr;
 
624
 
 
625
      tmp.plugin= plugin;
 
626
      tmp.name.str= (char *)plugin->name;
 
627
      tmp.name.length= name_len;
 
628
      tmp.ref_count= 0;
 
629
      tmp.state= PLUGIN_IS_UNINITIALIZED;
 
630
      if (!test_plugin_options(tmp_root, &tmp, argc, argv))
 
631
      {
 
632
        if ((tmp_plugin_ptr= plugin_insert_or_reuse(&tmp)))
 
633
        {
 
634
          plugin_array_version++;
 
635
          if (!my_hash_insert(&plugin_hash[plugin->type], (unsigned char*)tmp_plugin_ptr))
 
636
          {
 
637
            init_alloc_root(&tmp_plugin_ptr->mem_root, 4096, 4096);
 
638
            return(false);
 
639
          }
 
640
          tmp_plugin_ptr->state= PLUGIN_IS_FREED;
 
641
        }
 
642
        mysql_del_sys_var_chain(tmp.system_vars);
 
643
        goto err;
 
644
      }
 
645
      /* plugin was disabled */
 
646
      plugin_dl_del(dl);
 
647
      return(false);
 
648
    }
 
649
  }
 
650
  if (report & REPORT_TO_USER)
 
651
    my_error(ER_CANT_FIND_DL_ENTRY, MYF(0), name->str);
 
652
  if (report & REPORT_TO_LOG)
 
653
    errmsg_printf(ERRMSG_LVL_ERROR, ER(ER_CANT_FIND_DL_ENTRY), name->str);
 
654
err:
 
655
  plugin_dl_del(dl);
 
656
  return(true);
 
657
}
 
658
 
 
659
 
 
660
static void plugin_deinitialize(struct st_plugin_int *plugin, bool ref_check)
 
661
{
 
662
  if (plugin->plugin->status_vars)
 
663
  {
 
664
#ifdef FIX_LATER
 
665
    /*
 
666
      We have a problem right now where we can not prepend without
 
667
      breaking backwards compatibility. We will fix this shortly so
 
668
      that engines have "use names" and we wil use those for
 
669
      CREATE TABLE, and use the plugin name then for adding automatic
 
670
      variable names.
 
671
    */
 
672
    SHOW_VAR array[2]= {
 
673
      {plugin->plugin->name, (char*)plugin->plugin->status_vars, SHOW_ARRAY},
 
674
      {0, 0, SHOW_UNDEF}
 
675
    };
 
676
    remove_status_vars(array);
 
677
#else
 
678
    remove_status_vars(plugin->plugin->status_vars);
 
679
#endif /* FIX_LATER */
 
680
  }
 
681
 
 
682
  if (plugin_type_deinitialize[plugin->plugin->type])
 
683
  {
 
684
    if ((*plugin_type_deinitialize[plugin->plugin->type])(plugin))
 
685
    {
 
686
      errmsg_printf(ERRMSG_LVL_ERROR, _("Plugin '%s' of type %s failed deinitialization"),
 
687
                      plugin->name.str, plugin_type_names[plugin->plugin->type].str);
 
688
    }
 
689
  }
 
690
  else if (plugin->plugin->deinit)
 
691
    plugin->plugin->deinit(plugin);
 
692
 
 
693
  plugin->state= PLUGIN_IS_UNINITIALIZED;
 
694
 
 
695
  /*
 
696
    We do the check here because NDB has a worker Session which doesn't
 
697
    exit until NDB is shut down.
 
698
  */
 
699
  if (ref_check && plugin->ref_count)
 
700
    errmsg_printf(ERRMSG_LVL_ERROR, _("Plugin '%s' has ref_count=%d after deinitialization."),
 
701
                    plugin->name.str, plugin->ref_count);
 
702
}
 
703
 
 
704
 
 
705
static void plugin_del(struct st_plugin_int *plugin)
 
706
{
 
707
  /* Free allocated strings before deleting the plugin. */
 
708
  plugin_vars_free_values(plugin->system_vars);
 
709
  hash_delete(&plugin_hash[plugin->plugin->type], (unsigned char*)plugin);
 
710
  if (plugin->plugin_dl)
 
711
    plugin_dl_del(&plugin->plugin_dl->dl);
 
712
  plugin->state= PLUGIN_IS_FREED;
 
713
  plugin_array_version++;
 
714
  pthread_rwlock_wrlock(&LOCK_system_variables_hash);
 
715
  mysql_del_sys_var_chain(plugin->system_vars);
 
716
  pthread_rwlock_unlock(&LOCK_system_variables_hash);
 
717
  free_root(&plugin->mem_root, MYF(0));
 
718
  return;
 
719
}
 
720
 
 
721
static void reap_plugins(void)
 
722
{
 
723
  size_t count;
 
724
  uint32_t idx;
 
725
  struct st_plugin_int *plugin;
 
726
 
 
727
  reap_needed= false;
 
728
  count= plugin_array.elements;
 
729
 
 
730
  for (idx= 0; idx < count; idx++)
 
731
  {
 
732
    plugin= *dynamic_element(&plugin_array, idx, struct st_plugin_int **);
 
733
    plugin->state= PLUGIN_IS_DYING;
 
734
    plugin_deinitialize(plugin, true);
 
735
    plugin_del(plugin);
 
736
  }
 
737
}
 
738
 
 
739
static void intern_plugin_unlock(LEX *, plugin_ref plugin)
 
740
{
 
741
  st_plugin_int *pi;
 
742
 
 
743
  if (!plugin)
 
744
    return;
 
745
 
 
746
  pi= plugin_ref_to_int(plugin);
 
747
 
 
748
  free((void *) plugin);
 
749
 
 
750
  assert(pi->ref_count);
 
751
  pi->ref_count--;
 
752
 
 
753
  if (pi->state == PLUGIN_IS_DELETED && !pi->ref_count)
 
754
    reap_needed= true;
 
755
 
 
756
  return;
 
757
}
 
758
 
 
759
 
 
760
void plugin_unlock(Session *session, plugin_ref plugin)
 
761
{
 
762
  LEX *lex= session ? session->lex : 0;
 
763
  if (!plugin)
 
764
    return;
 
765
  intern_plugin_unlock(lex, plugin);
 
766
  return;
 
767
}
 
768
 
 
769
 
 
770
void plugin_unlock_list(Session *session, plugin_ref *list, uint32_t count)
 
771
{
 
772
  LEX *lex= session ? session->lex : 0;
 
773
  assert(list);
 
774
  while (count--)
 
775
    intern_plugin_unlock(lex, *list++);
 
776
  return;
 
777
}
 
778
 
 
779
 
 
780
static int plugin_initialize(struct st_plugin_int *plugin)
 
781
{
 
782
 
 
783
  if (plugin_type_initialize[plugin->plugin->type])
 
784
  {
 
785
    if ((*plugin_type_initialize[plugin->plugin->type])(plugin))
 
786
    {
 
787
      errmsg_printf(ERRMSG_LVL_ERROR, _("Plugin '%s' registration as a %s failed."),
 
788
                      plugin->name.str, plugin_type_names[plugin->plugin->type].str);
 
789
      goto err;
 
790
    }
 
791
  }
 
792
  else if (plugin->plugin->init)
 
793
  {
 
794
    if (plugin->plugin->init(plugin))
 
795
    {
 
796
      errmsg_printf(ERRMSG_LVL_ERROR, _("Plugin '%s' init function returned error."),
 
797
                      plugin->name.str);
 
798
      goto err;
 
799
    }
 
800
  }
 
801
 
 
802
  plugin->state= PLUGIN_IS_READY;
 
803
 
 
804
  if (plugin->plugin->status_vars)
 
805
  {
 
806
#ifdef FIX_LATER
 
807
    /*
 
808
      We have a problem right now where we can not prepend without
 
809
      breaking backwards compatibility. We will fix this shortly so
 
810
      that engines have "use names" and we wil use those for
 
811
      CREATE TABLE, and use the plugin name then for adding automatic
 
812
      variable names.
 
813
    */
 
814
    SHOW_VAR array[2]= {
 
815
      {plugin->plugin->name, (char*)plugin->plugin->status_vars, SHOW_ARRAY},
 
816
      {0, 0, SHOW_UNDEF}
 
817
    };
 
818
    if (add_status_vars(array)) // add_status_vars makes a copy
 
819
      goto err;
 
820
#else
 
821
    add_status_vars(plugin->plugin->status_vars); // add_status_vars makes a copy
 
822
#endif /* FIX_LATER */
 
823
  }
 
824
 
 
825
  /*
 
826
    set the plugin attribute of plugin's sys vars so they are pointing
 
827
    to the active plugin
 
828
  */
 
829
  if (plugin->system_vars)
 
830
  {
 
831
    sys_var_pluginvar *var= plugin->system_vars->cast_pluginvar();
 
832
    for (;;)
 
833
    {
 
834
      var->plugin= plugin;
 
835
      if (!var->next)
 
836
        break;
 
837
      var= var->next->cast_pluginvar();
 
838
    }
 
839
  }
 
840
 
 
841
  return(0);
 
842
err:
 
843
  return(1);
 
844
}
 
845
 
 
846
 
 
847
extern "C" unsigned char *get_plugin_hash_key(const unsigned char *, size_t *, bool);
 
848
extern "C" unsigned char *get_bookmark_hash_key(const unsigned char *, size_t *, bool);
 
849
 
 
850
 
 
851
unsigned char *get_plugin_hash_key(const unsigned char *buff, size_t *length, bool)
 
852
{
 
853
  struct st_plugin_int *plugin= (st_plugin_int *)buff;
 
854
  *length= (uint)plugin->name.length;
 
855
  return((unsigned char *)plugin->name.str);
 
856
}
 
857
 
 
858
 
 
859
unsigned char *get_bookmark_hash_key(const unsigned char *buff, size_t *length, bool)
 
860
{
 
861
  struct st_bookmark *var= (st_bookmark *)buff;
 
862
  *length= var->name_len + 1;
 
863
  return (unsigned char*) var->key;
 
864
}
 
865
 
286
866
 
287
867
/*
288
868
  The logic is that we first load and initialize all compiled in plugins.
291
871
 
292
872
  Finally we initialize everything, aka the dynamic that have yet to initialize.
293
873
*/
294
 
bool plugin_init(module::Registry &registry,
295
 
                 po::options_description &long_options)
 
874
int plugin_init(int *argc, char **argv, int flags)
296
875
{
297
 
  memory::Root tmp_root(4096);
 
876
  uint32_t idx;
 
877
  struct st_mysql_plugin **builtins;
 
878
  struct st_mysql_plugin *plugin;
 
879
  struct st_plugin_int tmp, *plugin_ptr;
 
880
  MEM_ROOT tmp_root;
298
881
 
299
882
  if (initialized)
300
 
    return false;
 
883
    return(0);
 
884
 
 
885
  init_alloc_root(&plugin_mem_root, 4096, 4096);
 
886
  init_alloc_root(&tmp_root, 4096, 4096);
 
887
 
 
888
  if (hash_init(&bookmark_hash, &my_charset_bin, 16, 0, 0,
 
889
                  get_bookmark_hash_key, NULL, HASH_UNIQUE))
 
890
      goto err;
 
891
 
 
892
 
 
893
  if (my_init_dynamic_array(&plugin_dl_array,
 
894
                            sizeof(struct st_plugin_dl *),16,16) ||
 
895
      my_init_dynamic_array(&plugin_array,
 
896
                            sizeof(struct st_plugin_int *),16,16))
 
897
    goto err;
 
898
 
 
899
  for (idx= 0; idx < DRIZZLE_MAX_PLUGIN_TYPE_NUM; idx++)
 
900
  {
 
901
    if (hash_init(&plugin_hash[idx], system_charset_info, 16, 0, 0,
 
902
                  get_plugin_hash_key, NULL, HASH_UNIQUE))
 
903
      goto err;
 
904
  }
301
905
 
302
906
  initialized= 1;
303
907
 
304
 
  PluginOptions builtin_load_list;
305
 
  tokenize(builtin_load_plugins, builtin_load_list, ",", true);
306
 
 
307
 
  PluginOptions builtin_list;
308
 
  tokenize(builtin_plugins, builtin_list, ",", true);
309
 
 
310
 
  bool load_failed= false;
311
 
 
312
 
  if (opt_plugin_add.size() > 0)
313
 
  {
314
 
    for (PluginOptions::iterator iter= opt_plugin_add.begin();
315
 
         iter != opt_plugin_add.end();
316
 
         ++iter)
317
 
    {
318
 
      if (find(builtin_list.begin(),
319
 
               builtin_list.end(), *iter) != builtin_list.end())
320
 
      {
321
 
        builtin_load_list.push_back(*iter);
322
 
      }
323
 
      else
324
 
      {
325
 
        opt_plugin_load.push_back(*iter);
326
 
      }
327
 
    }
328
 
  }
329
 
 
330
 
  if (opt_plugin_remove.size() > 0)
331
 
  {
332
 
    plugin_prune_list(opt_plugin_load, opt_plugin_remove);
333
 
    plugin_prune_list(builtin_load_list, opt_plugin_remove);
334
 
  }
335
 
 
336
 
 
337
908
  /*
338
909
    First we register builtin plugins
339
910
  */
340
 
  const set<string> builtin_list_set(builtin_load_list.begin(),
341
 
                                     builtin_load_list.end());
342
 
  load_failed= plugin_load_list(registry, &tmp_root,
343
 
                                builtin_list_set, long_options, true);
344
 
  if (load_failed)
 
911
  for (builtins= mysqld_builtins; *builtins; builtins++)
345
912
  {
346
 
    tmp_root.free_root(MYF(0));
347
 
    return true;
 
913
    for (plugin= *builtins; plugin->name; plugin++)
 
914
    {
 
915
      memset(&tmp, 0, sizeof(tmp));
 
916
      tmp.plugin= plugin;
 
917
      tmp.name.str= (char *)plugin->name;
 
918
      tmp.name.length= strlen(plugin->name);
 
919
 
 
920
      free_root(&tmp_root, MYF(MY_MARK_BLOCKS_FREE));
 
921
      if (test_plugin_options(&tmp_root, &tmp, argc, argv))
 
922
        continue;
 
923
 
 
924
      if (register_builtin(plugin, &tmp, &plugin_ptr))
 
925
        goto err_unlock;
 
926
 
 
927
      if (plugin_initialize(plugin_ptr))
 
928
        goto err_unlock;
 
929
 
 
930
      /*
 
931
        initialize the global default storage engine so that it may
 
932
        not be null in any child thread.
 
933
      */
 
934
      if (my_strcasecmp(&my_charset_utf8_general_ci, plugin->name, "MyISAM") == 0)
 
935
      {
 
936
        assert(!global_system_variables.table_plugin);
 
937
        global_system_variables.table_plugin=
 
938
          my_intern_plugin_lock(NULL, plugin_int_to_ref(plugin_ptr));
 
939
        assert(plugin_ptr->ref_count == 1);
 
940
      }
 
941
    }
348
942
  }
349
943
 
350
 
  /* Uniquify the list */
351
 
  const set<string> plugin_list_set(opt_plugin_load.begin(),
352
 
                                    opt_plugin_load.end());
353
 
  
 
944
  /* should now be set to MyISAM storage engine */
 
945
  assert(global_system_variables.table_plugin);
 
946
 
354
947
  /* Register all dynamic plugins */
355
 
  load_failed= plugin_load_list(registry, &tmp_root,
356
 
                                plugin_list_set, long_options);
357
 
  if (load_failed)
 
948
  if (!(flags & PLUGIN_INIT_SKIP_DYNAMIC_LOADING))
358
949
  {
359
 
    tmp_root.free_root(MYF(0));
360
 
    return true;
 
950
    if (opt_plugin_load)
 
951
      plugin_load_list(&tmp_root, argc, argv, opt_plugin_load);
361
952
  }
362
953
 
363
 
  tmp_root.free_root(MYF(0));
364
 
 
365
 
  return false;
366
 
}
367
 
 
368
 
bool plugin_finalize(module::Registry &registry)
369
 
{
 
954
  if (flags & PLUGIN_INIT_SKIP_INITIALIZATION)
 
955
    goto end;
 
956
 
370
957
  /*
371
958
    Now we initialize all remaining plugins
372
959
  */
373
 
  module::Registry::ModuleList module_list= registry.getList();
374
 
  module::Registry::ModuleList::iterator modules= module_list.begin();
375
 
    
376
 
  while (modules != module_list.end())
 
960
  for (idx= 0; idx < plugin_array.elements; idx++)
377
961
  {
378
 
    module::Module *module= *modules;
379
 
    ++modules;
380
 
    if (module->isInited == false)
 
962
    plugin_ptr= *dynamic_element(&plugin_array, idx, struct st_plugin_int **);
 
963
    if (plugin_ptr->state == PLUGIN_IS_UNINITIALIZED)
381
964
    {
382
 
      if (plugin_initialize(registry, module))
 
965
      if (plugin_initialize(plugin_ptr))
383
966
      {
384
 
        registry.remove(module);
385
 
        delete module;
386
 
        return true;
 
967
        plugin_ptr->state= PLUGIN_IS_DYING;
 
968
        plugin_deinitialize(plugin_ptr, true);
 
969
        plugin_del(plugin_ptr);
387
970
      }
388
971
    }
389
972
  }
390
973
 
391
974
 
392
 
  BOOST_FOREACH(plugin::Plugin::map::value_type value, registry.getPluginsMap())
393
 
  {
394
 
    value.second->prime();
395
 
  }
396
 
 
397
 
  return false;
398
 
}
399
 
 
400
 
/*
401
 
  Window of opportunity for plugins to issue any queries with the database up and running but with no user's connected.
402
 
*/
403
 
void plugin_startup_window(module::Registry &registry, drizzled::Session &session)
404
 
{
405
 
  BOOST_FOREACH(plugin::Plugin::map::value_type value, registry.getPluginsMap())
406
 
  {
407
 
    value.second->startup(session);
408
 
  }
409
 
}
410
 
 
411
 
class PrunePlugin :
412
 
  public unary_function<string, bool>
413
 
{
414
 
  const string to_match;
415
 
  PrunePlugin();
416
 
  PrunePlugin& operator=(const PrunePlugin&);
417
 
public:
418
 
  explicit PrunePlugin(const string &match_in) :
419
 
    to_match(match_in)
420
 
  { }
421
 
 
422
 
  result_type operator()(const string &match_against)
423
 
  {
424
 
    return match_against == to_match;
425
 
  }
426
 
};
427
 
 
428
 
static void plugin_prune_list(vector<string> &plugin_list,
429
 
                              const vector<string> &plugins_to_remove)
430
 
{
431
 
  for (vector<string>::const_iterator iter= plugins_to_remove.begin();
432
 
       iter != plugins_to_remove.end();
433
 
       ++iter)
434
 
  {
435
 
    plugin_list.erase(remove_if(plugin_list.begin(),
436
 
                                plugin_list.end(),
437
 
                                PrunePlugin(*iter)),
438
 
                      plugin_list.end());
439
 
  }
440
 
}
 
975
end:
 
976
  free_root(&tmp_root, MYF(0));
 
977
 
 
978
  return(0);
 
979
 
 
980
err_unlock:
 
981
err:
 
982
  free_root(&tmp_root, MYF(0));
 
983
  return(1);
 
984
}
 
985
 
 
986
 
 
987
static bool register_builtin(struct st_mysql_plugin *plugin,
 
988
                             struct st_plugin_int *tmp,
 
989
                             struct st_plugin_int **ptr)
 
990
{
 
991
 
 
992
  tmp->state= PLUGIN_IS_UNINITIALIZED;
 
993
  tmp->ref_count= 0;
 
994
  tmp->plugin_dl= 0;
 
995
 
 
996
  if (insert_dynamic(&plugin_array, (unsigned char*)&tmp))
 
997
    return(1);
 
998
 
 
999
  *ptr= *dynamic_element(&plugin_array, plugin_array.elements - 1,
 
1000
                         struct st_plugin_int **)=
 
1001
        (struct st_plugin_int *) memdup_root(&plugin_mem_root, (unsigned char*)tmp,
 
1002
                                             sizeof(struct st_plugin_int));
 
1003
 
 
1004
  if (my_hash_insert(&plugin_hash[plugin->type],(unsigned char*) *ptr))
 
1005
    return(1);
 
1006
 
 
1007
  return(0);
 
1008
}
 
1009
 
441
1010
 
442
1011
/*
443
1012
  called only by plugin_init()
444
1013
*/
445
 
static bool plugin_load_list(module::Registry &registry,
446
 
                             memory::Root *tmp_root,
447
 
                             const set<string> &plugin_list,
448
 
                             po::options_description &long_options,
449
 
                             bool builtin)
 
1014
static bool plugin_load_list(MEM_ROOT *tmp_root, int *argc, char **argv,
 
1015
                             const char *list)
450
1016
{
451
 
  module::Library *library= NULL;
452
 
 
453
 
  for (set<string>::const_iterator iter= plugin_list.begin();
454
 
       iter != plugin_list.end();
455
 
       ++iter)
 
1017
  char buffer[FN_REFLEN];
 
1018
  LEX_STRING name= {buffer, 0}, dl= {NULL, 0}, *str= &name;
 
1019
  struct st_plugin_dl *plugin_dl;
 
1020
  struct st_mysql_plugin *plugin;
 
1021
  char *p= buffer;
 
1022
  while (list)
456
1023
  {
457
 
    const string plugin_name(*iter);
458
 
 
459
 
    library= registry.addLibrary(plugin_name, builtin);
460
 
    if (library == NULL)
 
1024
    if (p == buffer + sizeof(buffer) - 1)
461
1025
    {
462
 
      errmsg_printf(error::ERROR,
463
 
                    _("Couldn't load plugin library named '%s'.\n"),
464
 
                    plugin_name.c_str());
465
 
      return true;
 
1026
      errmsg_printf(ERRMSG_LVL_ERROR, _("plugin-load parameter too long"));
 
1027
      return(true);
466
1028
    }
467
1029
 
468
 
    tmp_root->free_root(MYF(memory::MARK_BLOCKS_FREE));
469
 
    if (plugin_add(registry, tmp_root, library, long_options))
470
 
    {
471
 
      registry.removeLibrary(plugin_name);
472
 
      errmsg_printf(error::ERROR,
473
 
                    _("Couldn't load plugin named '%s'.\n"),
474
 
                    plugin_name.c_str());
475
 
      return true;
476
 
 
 
1030
    switch ((*(p++)= *(list++))) {
 
1031
    case '\0':
 
1032
      list= NULL; /* terminate the loop */
 
1033
      /* fall through */
 
1034
    case ':':     /* can't use this as delimiter as it may be drive letter */
 
1035
    case ';':
 
1036
      str->str[str->length]= '\0';
 
1037
      if (str == &name)  // load all plugins in named module
 
1038
      {
 
1039
        if (!name.length)
 
1040
        {
 
1041
          p--;    /* reset pointer */
 
1042
          continue;
 
1043
        }
 
1044
 
 
1045
        dl= name;
 
1046
        if ((plugin_dl= plugin_dl_add(&dl, REPORT_TO_LOG)))
 
1047
        {
 
1048
          for (plugin= plugin_dl->plugins; plugin->name; plugin++)
 
1049
          {
 
1050
            name.str= (char *) plugin->name;
 
1051
            name.length= strlen(name.str);
 
1052
 
 
1053
            free_root(tmp_root, MYF(MY_MARK_BLOCKS_FREE));
 
1054
            if (plugin_add(tmp_root, &name, &dl, argc, argv, REPORT_TO_LOG))
 
1055
              goto error;
 
1056
          }
 
1057
          plugin_dl_del(&dl); // reduce ref count
 
1058
        }
 
1059
      }
 
1060
      else
 
1061
      {
 
1062
        free_root(tmp_root, MYF(MY_MARK_BLOCKS_FREE));
 
1063
        if (plugin_add(tmp_root, &name, &dl, argc, argv, REPORT_TO_LOG))
 
1064
          goto error;
 
1065
      }
 
1066
      name.length= dl.length= 0;
 
1067
      dl.str= NULL; name.str= p= buffer;
 
1068
      str= &name;
 
1069
      continue;
 
1070
    case '=':
 
1071
    case '#':
 
1072
      if (str == &name)
 
1073
      {
 
1074
        name.str[name.length]= '\0';
 
1075
        str= &dl;
 
1076
        str->str= p;
 
1077
        continue;
 
1078
      }
 
1079
    default:
 
1080
      str->length++;
 
1081
      continue;
477
1082
    }
478
1083
  }
479
 
  return false;
 
1084
  return(false);
 
1085
error:
 
1086
  errmsg_printf(ERRMSG_LVL_ERROR, _("Couldn't load plugin named '%s' with soname '%s'."),
 
1087
                  name.str, dl.str);
 
1088
  return(true);
480
1089
}
481
1090
 
482
1091
 
483
 
void module_shutdown(module::Registry &registry)
 
1092
void plugin_shutdown(void)
484
1093
{
 
1094
  uint32_t idx, free_slots= 0;
 
1095
  size_t count= plugin_array.elements;
 
1096
  struct st_plugin_int *plugin;
 
1097
  vector<st_plugin_int *> plugins;
 
1098
  vector<st_plugin_dl *> dl;
485
1099
 
486
1100
  if (initialized)
487
1101
  {
488
1102
    reap_needed= true;
489
1103
 
490
 
    reap_plugins(registry);
491
 
    unlock_variables(NULL, &global_system_variables);
492
 
    unlock_variables(NULL, &max_system_variables);
493
 
 
494
 
    cleanup_variables(&global_system_variables);
495
 
    cleanup_variables(&max_system_variables);
 
1104
    /*
 
1105
      We want to shut down plugins in a reasonable order, this will
 
1106
      become important when we have plugins which depend upon each other.
 
1107
      Circular references cannot be reaped so they are forced afterwards.
 
1108
      TODO: Have an additional step here to notify all active plugins that
 
1109
      shutdown is requested to allow plugins to deinitialize in parallel.
 
1110
    */
 
1111
    while (reap_needed && (count= plugin_array.elements))
 
1112
    {
 
1113
      reap_plugins();
 
1114
      for (idx= free_slots= 0; idx < count; idx++)
 
1115
      {
 
1116
        plugin= *dynamic_element(&plugin_array, idx, struct st_plugin_int **);
 
1117
        switch (plugin->state) {
 
1118
        case PLUGIN_IS_READY:
 
1119
          plugin->state= PLUGIN_IS_DELETED;
 
1120
          reap_needed= true;
 
1121
          break;
 
1122
        case PLUGIN_IS_FREED:
 
1123
        case PLUGIN_IS_UNINITIALIZED:
 
1124
          free_slots++;
 
1125
          break;
 
1126
        }
 
1127
      }
 
1128
      if (!reap_needed)
 
1129
      {
 
1130
        /*
 
1131
          release any plugin references held.
 
1132
        */
 
1133
        unlock_variables(NULL, &global_system_variables);
 
1134
        unlock_variables(NULL, &max_system_variables);
 
1135
      }
 
1136
    }
 
1137
 
 
1138
    if (count > free_slots)
 
1139
      errmsg_printf(ERRMSG_LVL_WARN, _("Forcing shutdown of %"PRIu64" plugins"),
 
1140
                        (uint64_t)count - free_slots);
 
1141
 
 
1142
    plugins.reserve(count);
 
1143
 
 
1144
    /*
 
1145
      If we have any plugins which did not die cleanly, we force shutdown
 
1146
    */
 
1147
    for (idx= 0; idx < count; idx++)
 
1148
    {
 
1149
      plugins.push_back(*dynamic_element(&plugin_array, idx,
 
1150
                                         struct st_plugin_int **));
 
1151
      /* change the state to ensure no reaping races */
 
1152
      if (plugins[idx]->state == PLUGIN_IS_DELETED)
 
1153
        plugins[idx]->state= PLUGIN_IS_DYING;
 
1154
    }
 
1155
 
 
1156
    /*
 
1157
      We loop through all plugins and call deinit() if they have one.
 
1158
    */
 
1159
    for (idx= 0; idx < count; idx++)
 
1160
      if (!(plugins[idx]->state & (PLUGIN_IS_UNINITIALIZED | PLUGIN_IS_FREED)))
 
1161
      {
 
1162
        errmsg_printf(ERRMSG_LVL_INFO, _("Plugin '%s' will be forced to shutdown"),
 
1163
                              plugins[idx]->name.str);
 
1164
        /*
 
1165
          We are forcing deinit on plugins so we don't want to do a ref_count
 
1166
          check until we have processed all the plugins.
 
1167
        */
 
1168
        plugin_deinitialize(plugins[idx], false);
 
1169
      }
 
1170
 
 
1171
    /*
 
1172
      We defer checking ref_counts until after all plugins are deinitialized
 
1173
      as some may have worker threads holding on to plugin references.
 
1174
    */
 
1175
    for (idx= 0; idx < count; idx++)
 
1176
    {
 
1177
      if (plugins[idx]->ref_count)
 
1178
        errmsg_printf(ERRMSG_LVL_ERROR, _("Plugin '%s' has ref_count=%d after shutdown."),
 
1179
                        plugins[idx]->name.str, plugins[idx]->ref_count);
 
1180
      if (plugins[idx]->state & PLUGIN_IS_UNINITIALIZED)
 
1181
        plugin_del(plugins[idx]);
 
1182
    }
 
1183
 
 
1184
    /*
 
1185
      Now we can deallocate all memory.
 
1186
    */
 
1187
 
 
1188
    cleanup_variables(NULL, &global_system_variables);
 
1189
    cleanup_variables(NULL, &max_system_variables);
496
1190
 
497
1191
    initialized= 0;
 
1192
 
498
1193
  }
499
1194
 
500
1195
  /* Dispose of the memory */
501
 
  plugin_mem_root.free_root(MYF(0));
 
1196
 
 
1197
  for (idx= 0; idx < DRIZZLE_MAX_PLUGIN_TYPE_NUM; idx++)
 
1198
    hash_free(&plugin_hash[idx]);
 
1199
  delete_dynamic(&plugin_array);
 
1200
 
 
1201
  count= plugin_dl_array.elements;
 
1202
  dl.reserve(count);
 
1203
  for (idx= 0; idx < count; idx++)
 
1204
    dl.push_back(*dynamic_element(&plugin_dl_array, idx,
 
1205
                 struct st_plugin_dl **));
 
1206
  for (idx= 0; idx < count; idx++)
 
1207
    free_plugin_mem(dl[idx]);
 
1208
  delete_dynamic(&plugin_dl_array);
 
1209
 
 
1210
  hash_free(&bookmark_hash);
 
1211
  free_root(&plugin_mem_root, MYF(0));
502
1212
 
503
1213
  global_variables_dynamic_size= 0;
 
1214
 
 
1215
  return;
 
1216
}
 
1217
 
 
1218
 
 
1219
bool plugin_foreach_with_mask(Session *session, plugin_foreach_func *func,
 
1220
                       int type, uint32_t state_mask, void *arg)
 
1221
{
 
1222
  uint32_t idx;
 
1223
  size_t total;
 
1224
  struct st_plugin_int *plugin;
 
1225
  vector<st_plugin_int *> plugins;
 
1226
  int version=plugin_array_version;
 
1227
 
 
1228
  if (!initialized)
 
1229
    return(false);
 
1230
 
 
1231
  state_mask= ~state_mask; // do it only once
 
1232
 
 
1233
  total= type == DRIZZLE_ANY_PLUGIN ? plugin_array.elements
 
1234
                                  : plugin_hash[type].records;
 
1235
  plugins.reserve(total);
 
1236
 
 
1237
  if (type == DRIZZLE_ANY_PLUGIN)
 
1238
  {
 
1239
    for (idx= 0; idx < total; idx++)
 
1240
    {
 
1241
      plugin= *dynamic_element(&plugin_array, idx, struct st_plugin_int **);
 
1242
      plugins.push_back(!(plugin->state & state_mask) ? plugin : NULL);
 
1243
    }
 
1244
  }
 
1245
  else
 
1246
  {
 
1247
    HASH *hash= plugin_hash + type;
 
1248
    for (idx= 0; idx < total; idx++)
 
1249
    {
 
1250
      plugin= (struct st_plugin_int *) hash_element(hash, idx);
 
1251
      plugins.push_back(!(plugin->state & state_mask) ? plugin : NULL);
 
1252
    }
 
1253
  }
 
1254
  for (idx= 0; idx < total; idx++)
 
1255
  {
 
1256
    if (unlikely(version != plugin_array_version))
 
1257
    {
 
1258
      for (uint32_t i=idx; i < total; i++)
 
1259
        if (plugins[i] && plugins[i]->state & state_mask)
 
1260
          plugins[i]=0;
 
1261
    }
 
1262
    plugin= plugins[idx];
 
1263
    /* It will stop iterating on first engine error when "func" returns true */
 
1264
    if (plugin && func(session, plugin_int_to_ref(plugin), arg))
 
1265
        goto err;
 
1266
  }
 
1267
 
 
1268
  return false;
 
1269
err:
 
1270
  return true;
 
1271
}
 
1272
 
 
1273
 
 
1274
/****************************************************************************
 
1275
  Internal type declarations for variables support
 
1276
****************************************************************************/
 
1277
 
 
1278
#undef DRIZZLE_SYSVAR_NAME
 
1279
#define DRIZZLE_SYSVAR_NAME(name) name
 
1280
#define PLUGIN_VAR_TYPEMASK 0x007f
 
1281
 
 
1282
#define EXTRA_OPTIONS 3 /* options for: 'foo', 'plugin-foo' and NULL */
 
1283
 
 
1284
typedef DECLARE_DRIZZLE_SYSVAR_BASIC(sysvar_bool_t, bool);
 
1285
typedef DECLARE_DRIZZLE_SessionVAR_BASIC(sessionvar_bool_t, bool);
 
1286
typedef DECLARE_DRIZZLE_SYSVAR_BASIC(sysvar_str_t, char *);
 
1287
typedef DECLARE_DRIZZLE_SessionVAR_BASIC(sessionvar_str_t, char *);
 
1288
 
 
1289
typedef DECLARE_DRIZZLE_SYSVAR_TYPELIB(sysvar_enum_t, unsigned long);
 
1290
typedef DECLARE_DRIZZLE_SessionVAR_TYPELIB(sessionvar_enum_t, unsigned long);
 
1291
typedef DECLARE_DRIZZLE_SYSVAR_TYPELIB(sysvar_set_t, uint64_t);
 
1292
typedef DECLARE_DRIZZLE_SessionVAR_TYPELIB(sessionvar_set_t, uint64_t);
 
1293
 
 
1294
typedef DECLARE_DRIZZLE_SYSVAR_SIMPLE(sysvar_int_t, int);
 
1295
typedef DECLARE_DRIZZLE_SYSVAR_SIMPLE(sysvar_long_t, long);
 
1296
typedef DECLARE_DRIZZLE_SYSVAR_SIMPLE(sysvar_int64_t_t, int64_t);
 
1297
typedef DECLARE_DRIZZLE_SYSVAR_SIMPLE(sysvar_uint_t, uint);
 
1298
typedef DECLARE_DRIZZLE_SYSVAR_SIMPLE(sysvar_ulong_t, ulong);
 
1299
typedef DECLARE_DRIZZLE_SYSVAR_SIMPLE(sysvar_uint64_t_t, uint64_t);
 
1300
 
 
1301
typedef DECLARE_DRIZZLE_SessionVAR_SIMPLE(sessionvar_int_t, int);
 
1302
typedef DECLARE_DRIZZLE_SessionVAR_SIMPLE(sessionvar_long_t, long);
 
1303
typedef DECLARE_DRIZZLE_SessionVAR_SIMPLE(sessionvar_int64_t_t, int64_t);
 
1304
typedef DECLARE_DRIZZLE_SessionVAR_SIMPLE(sessionvar_uint_t, uint);
 
1305
typedef DECLARE_DRIZZLE_SessionVAR_SIMPLE(sessionvar_ulong_t, ulong);
 
1306
typedef DECLARE_DRIZZLE_SessionVAR_SIMPLE(sessionvar_uint64_t_t, uint64_t);
 
1307
 
 
1308
typedef bool *(*mysql_sys_var_ptr_p)(Session* a_session, int offset);
 
1309
 
 
1310
 
 
1311
/****************************************************************************
 
1312
  default variable data check and update functions
 
1313
****************************************************************************/
 
1314
 
 
1315
static int check_func_bool(Session *, struct st_mysql_sys_var *var,
 
1316
                           void *save, st_mysql_value *value)
 
1317
{
 
1318
  char buff[STRING_BUFFER_USUAL_SIZE];
 
1319
  const char *strvalue= "NULL", *str;
 
1320
  int result, length;
 
1321
  int64_t tmp;
 
1322
 
 
1323
  if (value->value_type(value) == DRIZZLE_VALUE_TYPE_STRING)
 
1324
  {
 
1325
    length= sizeof(buff);
 
1326
    if (!(str= value->val_str(value, buff, &length)) ||
 
1327
        (result= find_type(&bool_typelib, str, length, 1)-1) < 0)
 
1328
    {
 
1329
      if (str)
 
1330
        strvalue= str;
 
1331
      goto err;
 
1332
    }
 
1333
  }
 
1334
  else
 
1335
  {
 
1336
    if (value->val_int(value, &tmp) < 0)
 
1337
      goto err;
 
1338
    if (tmp > 1)
 
1339
    {
 
1340
      llstr(tmp, buff);
 
1341
      strvalue= buff;
 
1342
      goto err;
 
1343
    }
 
1344
    result= (int) tmp;
 
1345
  }
 
1346
  *(int*)save= -result;
 
1347
  return 0;
 
1348
err:
 
1349
  my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), var->name, strvalue);
 
1350
  return 1;
 
1351
}
 
1352
 
 
1353
 
 
1354
static int check_func_int(Session *session, struct st_mysql_sys_var *var,
 
1355
                          void *save, st_mysql_value *value)
 
1356
{
 
1357
  bool fixed;
 
1358
  int64_t tmp;
 
1359
  struct my_option options;
 
1360
  value->val_int(value, &tmp);
 
1361
  plugin_opt_set_limits(&options, var);
 
1362
 
 
1363
  if (var->flags & PLUGIN_VAR_UNSIGNED)
 
1364
    *(uint32_t *)save= (uint) getopt_ull_limit_value((uint64_t) tmp, &options,
 
1365
                                                   &fixed);
 
1366
  else
 
1367
    *(int *)save= (int) getopt_ll_limit_value(tmp, &options, &fixed);
 
1368
 
 
1369
  return throw_bounds_warning(session, fixed, var->flags & PLUGIN_VAR_UNSIGNED,
 
1370
                              var->name, (int64_t) tmp);
 
1371
}
 
1372
 
 
1373
 
 
1374
static int check_func_long(Session *session, struct st_mysql_sys_var *var,
 
1375
                          void *save, st_mysql_value *value)
 
1376
{
 
1377
  bool fixed;
 
1378
  int64_t tmp;
 
1379
  struct my_option options;
 
1380
  value->val_int(value, &tmp);
 
1381
  plugin_opt_set_limits(&options, var);
 
1382
 
 
1383
  if (var->flags & PLUGIN_VAR_UNSIGNED)
 
1384
    *(ulong *)save= (ulong) getopt_ull_limit_value((uint64_t) tmp, &options,
 
1385
                                                   &fixed);
 
1386
  else
 
1387
    *(long *)save= (long) getopt_ll_limit_value(tmp, &options, &fixed);
 
1388
 
 
1389
  return throw_bounds_warning(session, fixed, var->flags & PLUGIN_VAR_UNSIGNED,
 
1390
                              var->name, (int64_t) tmp);
 
1391
}
 
1392
 
 
1393
 
 
1394
static int check_func_int64_t(Session *session, struct st_mysql_sys_var *var,
 
1395
                               void *save, st_mysql_value *value)
 
1396
{
 
1397
  bool fixed;
 
1398
  int64_t tmp;
 
1399
  struct my_option options;
 
1400
  value->val_int(value, &tmp);
 
1401
  plugin_opt_set_limits(&options, var);
 
1402
 
 
1403
  if (var->flags & PLUGIN_VAR_UNSIGNED)
 
1404
    *(uint64_t *)save= getopt_ull_limit_value((uint64_t) tmp, &options,
 
1405
                                               &fixed);
 
1406
  else
 
1407
    *(int64_t *)save= getopt_ll_limit_value(tmp, &options, &fixed);
 
1408
 
 
1409
  return throw_bounds_warning(session, fixed, var->flags & PLUGIN_VAR_UNSIGNED,
 
1410
                              var->name, (int64_t) tmp);
 
1411
}
 
1412
 
 
1413
static int check_func_str(Session *session, struct st_mysql_sys_var *,
 
1414
                          void *save, st_mysql_value *value)
 
1415
{
 
1416
  char buff[STRING_BUFFER_USUAL_SIZE];
 
1417
  const char *str;
 
1418
  int length;
 
1419
 
 
1420
  length= sizeof(buff);
 
1421
  if ((str= value->val_str(value, buff, &length)))
 
1422
    str= session->strmake(str, length);
 
1423
  *(const char**)save= str;
 
1424
  return 0;
 
1425
}
 
1426
 
 
1427
 
 
1428
static int check_func_enum(Session *, struct st_mysql_sys_var *var,
 
1429
                           void *save, st_mysql_value *value)
 
1430
{
 
1431
  char buff[STRING_BUFFER_USUAL_SIZE];
 
1432
  const char *strvalue= "NULL", *str;
 
1433
  TYPELIB *typelib;
 
1434
  int64_t tmp;
 
1435
  long result;
 
1436
  int length;
 
1437
 
 
1438
  if (var->flags & PLUGIN_VAR_SessionLOCAL)
 
1439
    typelib= ((sessionvar_enum_t*) var)->typelib;
 
1440
  else
 
1441
    typelib= ((sysvar_enum_t*) var)->typelib;
 
1442
 
 
1443
  if (value->value_type(value) == DRIZZLE_VALUE_TYPE_STRING)
 
1444
  {
 
1445
    length= sizeof(buff);
 
1446
    if (!(str= value->val_str(value, buff, &length)))
 
1447
      goto err;
 
1448
    if ((result= (long)find_type(typelib, str, length, 1)-1) < 0)
 
1449
    {
 
1450
      strvalue= str;
 
1451
      goto err;
 
1452
    }
 
1453
  }
 
1454
  else
 
1455
  {
 
1456
    if (value->val_int(value, &tmp))
 
1457
      goto err;
 
1458
    if (tmp >= typelib->count)
 
1459
    {
 
1460
      llstr(tmp, buff);
 
1461
      strvalue= buff;
 
1462
      goto err;
 
1463
    }
 
1464
    result= (long) tmp;
 
1465
  }
 
1466
  *(long*)save= result;
 
1467
  return 0;
 
1468
err:
 
1469
  my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), var->name, strvalue);
 
1470
  return 1;
 
1471
}
 
1472
 
 
1473
 
 
1474
static int check_func_set(Session *, struct st_mysql_sys_var *var,
 
1475
                          void *save, st_mysql_value *value)
 
1476
{
 
1477
  char buff[STRING_BUFFER_USUAL_SIZE], *error= 0;
 
1478
  const char *strvalue= "NULL", *str;
 
1479
  TYPELIB *typelib;
 
1480
  uint64_t result;
 
1481
  uint32_t error_len;
 
1482
  bool not_used;
 
1483
  int length;
 
1484
 
 
1485
  if (var->flags & PLUGIN_VAR_SessionLOCAL)
 
1486
    typelib= ((sessionvar_set_t*) var)->typelib;
 
1487
  else
 
1488
    typelib= ((sysvar_set_t*)var)->typelib;
 
1489
 
 
1490
  if (value->value_type(value) == DRIZZLE_VALUE_TYPE_STRING)
 
1491
  {
 
1492
    length= sizeof(buff);
 
1493
    if (!(str= value->val_str(value, buff, &length)))
 
1494
      goto err;
 
1495
    result= find_set(typelib, str, length, NULL,
 
1496
                     &error, &error_len, &not_used);
 
1497
    if (error_len)
 
1498
    {
 
1499
      length= cmin(sizeof(buff), (unsigned long)error_len);
 
1500
      strncpy(buff, error, length);
 
1501
      buff[length]= '\0';
 
1502
      strvalue= buff;
 
1503
      goto err;
 
1504
    }
 
1505
  }
 
1506
  else
 
1507
  {
 
1508
    if (value->val_int(value, (int64_t *)&result))
 
1509
      goto err;
 
1510
    if (unlikely((result >= (1UL << typelib->count)) &&
 
1511
                 (typelib->count < sizeof(long)*8)))
 
1512
    {
 
1513
      llstr(result, buff);
 
1514
      strvalue= buff;
 
1515
      goto err;
 
1516
    }
 
1517
  }
 
1518
  *(uint64_t*)save= result;
 
1519
  return 0;
 
1520
err:
 
1521
  my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), var->name, strvalue);
 
1522
  return 1;
 
1523
}
 
1524
 
 
1525
 
 
1526
static void update_func_bool(Session *, struct st_mysql_sys_var *,
 
1527
                             void *tgt, const void *save)
 
1528
{
 
1529
  *(bool *) tgt= *(int *) save ? 1 : 0;
 
1530
}
 
1531
 
 
1532
 
 
1533
static void update_func_int(Session *, struct st_mysql_sys_var *,
 
1534
                             void *tgt, const void *save)
 
1535
{
 
1536
  *(int *)tgt= *(int *) save;
 
1537
}
 
1538
 
 
1539
 
 
1540
static void update_func_long(Session *, struct st_mysql_sys_var *,
 
1541
                             void *tgt, const void *save)
 
1542
{
 
1543
  *(long *)tgt= *(long *) save;
 
1544
}
 
1545
 
 
1546
 
 
1547
static void update_func_int64_t(Session *, struct st_mysql_sys_var *,
 
1548
                                 void *tgt, const void *save)
 
1549
{
 
1550
  *(int64_t *)tgt= *(uint64_t *) save;
 
1551
}
 
1552
 
 
1553
 
 
1554
static void update_func_str(Session *, struct st_mysql_sys_var *var,
 
1555
                             void *tgt, const void *save)
 
1556
{
 
1557
  char *old= *(char **) tgt;
 
1558
  *(char **)tgt= *(char **) save;
 
1559
  if (var->flags & PLUGIN_VAR_MEMALLOC)
 
1560
  {
 
1561
    *(char **)tgt= strdup(*(char **) save);
 
1562
    free(old);
 
1563
    /*
 
1564
     * There isn't a _really_ good thing to do here until this whole set_var
 
1565
     * mess gets redesigned
 
1566
     */
 
1567
    if (tgt == NULL)
 
1568
      errmsg_printf(ERRMSG_LVL_ERROR, _("Out of memory."));
 
1569
 
 
1570
  }
504
1571
}
505
1572
 
506
1573
 
509
1576
****************************************************************************/
510
1577
 
511
1578
 
 
1579
sys_var *find_sys_var(Session *session, const char *str, uint32_t length)
 
1580
{
 
1581
  sys_var *var;
 
1582
  sys_var_pluginvar *pi= NULL;
 
1583
  plugin_ref plugin;
 
1584
 
 
1585
  pthread_rwlock_rdlock(&LOCK_system_variables_hash);
 
1586
  if ((var= intern_find_sys_var(str, length, false)) &&
 
1587
      (pi= var->cast_pluginvar()))
 
1588
  {
 
1589
    pthread_rwlock_unlock(&LOCK_system_variables_hash);
 
1590
    LEX *lex= session ? session->lex : 0;
 
1591
    if (!(plugin= my_intern_plugin_lock(lex, plugin_int_to_ref(pi->plugin))))
 
1592
      var= NULL; /* failed to lock it, it must be uninstalling */
 
1593
    else
 
1594
    if (!(plugin_state(plugin) & PLUGIN_IS_READY))
 
1595
    {
 
1596
      /* initialization not completed */
 
1597
      var= NULL;
 
1598
      intern_plugin_unlock(lex, plugin);
 
1599
    }
 
1600
  }
 
1601
  else
 
1602
    pthread_rwlock_unlock(&LOCK_system_variables_hash);
 
1603
 
 
1604
  /*
 
1605
    If the variable exists but the plugin it is associated with is not ready
 
1606
    then the intern_plugin_lock did not raise an error, so we do it here.
 
1607
  */
 
1608
  if (pi && !var)
 
1609
    my_error(ER_UNKNOWN_SYSTEM_VARIABLE, MYF(0), (char*) str);
 
1610
  return(var);
 
1611
}
 
1612
 
 
1613
 
 
1614
/*
 
1615
  called by register_var, construct_options and test_plugin_options.
 
1616
  Returns the 'bookmark' for the named variable.
 
1617
  LOCK_system_variables_hash should be at least read locked
 
1618
*/
 
1619
static st_bookmark *find_bookmark(const char *plugin, const char *name, int flags)
 
1620
{
 
1621
  st_bookmark *result= NULL;
 
1622
  uint32_t namelen, length, pluginlen= 0;
 
1623
  char *varname, *p;
 
1624
 
 
1625
  if (!(flags & PLUGIN_VAR_SessionLOCAL))
 
1626
    return NULL;
 
1627
 
 
1628
  namelen= strlen(name);
 
1629
  if (plugin)
 
1630
    pluginlen= strlen(plugin) + 1;
 
1631
  length= namelen + pluginlen + 2;
 
1632
  varname= (char*) malloc(length);
 
1633
 
 
1634
  if (plugin)
 
1635
  {
 
1636
    sprintf(varname+1,"%s_%s",plugin,name);
 
1637
    for (p= varname + 1; *p; p++)
 
1638
      if (*p == '-')
 
1639
        *p= '_';
 
1640
  }
 
1641
  else
 
1642
    memcpy(varname + 1, name, namelen + 1);
 
1643
 
 
1644
  varname[0]= flags & PLUGIN_VAR_TYPEMASK;
 
1645
 
 
1646
  result= (st_bookmark*) hash_search(&bookmark_hash,
 
1647
                                     (const unsigned char*) varname, length - 1);
 
1648
 
 
1649
  free(varname);
 
1650
  return result;
 
1651
}
 
1652
 
 
1653
 
 
1654
/*
 
1655
  returns a bookmark for session-local variables, creating if neccessary.
 
1656
  returns null for non session-local variables.
 
1657
  Requires that a write lock is obtained on LOCK_system_variables_hash
 
1658
*/
 
1659
static st_bookmark *register_var(const char *plugin, const char *name,
 
1660
                                 int flags)
 
1661
{
 
1662
  uint32_t length= strlen(plugin) + strlen(name) + 3, size= 0, offset, new_size;
 
1663
  st_bookmark *result;
 
1664
  char *varname, *p;
 
1665
 
 
1666
  if (!(flags & PLUGIN_VAR_SessionLOCAL))
 
1667
    return NULL;
 
1668
 
 
1669
  switch (flags & PLUGIN_VAR_TYPEMASK) {
 
1670
  case PLUGIN_VAR_BOOL:
 
1671
    size= sizeof(bool);
 
1672
    break;
 
1673
  case PLUGIN_VAR_INT:
 
1674
    size= sizeof(int);
 
1675
    break;
 
1676
  case PLUGIN_VAR_LONG:
 
1677
  case PLUGIN_VAR_ENUM:
 
1678
    size= sizeof(long);
 
1679
    break;
 
1680
  case PLUGIN_VAR_LONGLONG:
 
1681
  case PLUGIN_VAR_SET:
 
1682
    size= sizeof(uint64_t);
 
1683
    break;
 
1684
  case PLUGIN_VAR_STR:
 
1685
    size= sizeof(char*);
 
1686
    break;
 
1687
  default:
 
1688
    assert(0);
 
1689
    return NULL;
 
1690
  };
 
1691
 
 
1692
  varname= ((char*) malloc(length));
 
1693
  sprintf(varname+1, "%s_%s", plugin, name);
 
1694
  for (p= varname + 1; *p; p++)
 
1695
    if (*p == '-')
 
1696
      *p= '_';
 
1697
 
 
1698
  if (!(result= find_bookmark(NULL, varname + 1, flags)))
 
1699
  {
 
1700
    result= (st_bookmark*) alloc_root(&plugin_mem_root,
 
1701
                                      sizeof(struct st_bookmark) + length-1);
 
1702
    varname[0]= flags & PLUGIN_VAR_TYPEMASK;
 
1703
    memcpy(result->key, varname, length);
 
1704
    result->name_len= length - 2;
 
1705
    result->offset= -1;
 
1706
 
 
1707
    assert(size && !(size & (size-1))); /* must be power of 2 */
 
1708
 
 
1709
    offset= global_system_variables.dynamic_variables_size;
 
1710
    offset= (offset + size - 1) & ~(size - 1);
 
1711
    result->offset= (int) offset;
 
1712
 
 
1713
    new_size= (offset + size + 63) & ~63;
 
1714
 
 
1715
    if (new_size > global_variables_dynamic_size)
 
1716
    {
 
1717
      char* tmpptr= NULL;
 
1718
      if (!(tmpptr=
 
1719
              (char *)realloc(global_system_variables.dynamic_variables_ptr,
 
1720
                              new_size)))
 
1721
        return NULL;
 
1722
      global_system_variables.dynamic_variables_ptr= tmpptr;
 
1723
      tmpptr= NULL;
 
1724
      if (!(tmpptr=
 
1725
              (char *)realloc(max_system_variables.dynamic_variables_ptr,
 
1726
                              new_size)))
 
1727
        return NULL;
 
1728
      max_system_variables.dynamic_variables_ptr= tmpptr;
 
1729
           
 
1730
      /*
 
1731
        Clear the new variable value space. This is required for string
 
1732
        variables. If their value is non-NULL, it must point to a valid
 
1733
        string.
 
1734
      */
 
1735
      memset(global_system_variables.dynamic_variables_ptr +
 
1736
             global_variables_dynamic_size, 0,
 
1737
             new_size - global_variables_dynamic_size);
 
1738
      memset(max_system_variables.dynamic_variables_ptr +
 
1739
             global_variables_dynamic_size, 0,
 
1740
             new_size - global_variables_dynamic_size);
 
1741
      global_variables_dynamic_size= new_size;
 
1742
    }
 
1743
 
 
1744
    global_system_variables.dynamic_variables_head= offset;
 
1745
    max_system_variables.dynamic_variables_head= offset;
 
1746
    global_system_variables.dynamic_variables_size= offset + size;
 
1747
    max_system_variables.dynamic_variables_size= offset + size;
 
1748
    global_system_variables.dynamic_variables_version++;
 
1749
    max_system_variables.dynamic_variables_version++;
 
1750
 
 
1751
    result->version= global_system_variables.dynamic_variables_version;
 
1752
 
 
1753
    /* this should succeed because we have already checked if a dup exists */
 
1754
    if (my_hash_insert(&bookmark_hash, (unsigned char*) result))
 
1755
    {
 
1756
      fprintf(stderr, "failed to add placeholder to hash");
 
1757
      assert(0);
 
1758
    }
 
1759
  }
 
1760
  free(varname);
 
1761
  return result;
 
1762
}
 
1763
 
 
1764
 
 
1765
/*
 
1766
  returns a pointer to the memory which holds the session-local variable or
 
1767
  a pointer to the global variable if session==null.
 
1768
  If required, will sync with global variables if the requested variable
 
1769
  has not yet been allocated in the current thread.
 
1770
*/
 
1771
static unsigned char *intern_sys_var_ptr(Session* session, int offset, bool global_lock)
 
1772
{
 
1773
  assert(offset >= 0);
 
1774
  assert((uint)offset <= global_system_variables.dynamic_variables_head);
 
1775
 
 
1776
  if (!session)
 
1777
    return (unsigned char*) global_system_variables.dynamic_variables_ptr + offset;
 
1778
 
 
1779
  /*
 
1780
    dynamic_variables_head points to the largest valid offset
 
1781
  */
 
1782
  if (!session->variables.dynamic_variables_ptr ||
 
1783
      (uint)offset > session->variables.dynamic_variables_head)
 
1784
  {
 
1785
    uint32_t idx;
 
1786
 
 
1787
    pthread_rwlock_rdlock(&LOCK_system_variables_hash);
 
1788
 
 
1789
    char *tmpptr= NULL;
 
1790
    if (!(tmpptr= (char *)realloc(session->variables.dynamic_variables_ptr,
 
1791
                                  global_variables_dynamic_size)))
 
1792
      return NULL;
 
1793
    session->variables.dynamic_variables_ptr= tmpptr;
 
1794
 
 
1795
    if (global_lock)
 
1796
      pthread_mutex_lock(&LOCK_global_system_variables);
 
1797
 
 
1798
    safe_mutex_assert_owner(&LOCK_global_system_variables);
 
1799
 
 
1800
    memcpy(session->variables.dynamic_variables_ptr +
 
1801
             session->variables.dynamic_variables_size,
 
1802
           global_system_variables.dynamic_variables_ptr +
 
1803
             session->variables.dynamic_variables_size,
 
1804
           global_system_variables.dynamic_variables_size -
 
1805
             session->variables.dynamic_variables_size);
 
1806
 
 
1807
    /*
 
1808
      now we need to iterate through any newly copied 'defaults'
 
1809
      and if it is a string type with MEMALLOC flag, we need to strdup
 
1810
    */
 
1811
    for (idx= 0; idx < bookmark_hash.records; idx++)
 
1812
    {
 
1813
      sys_var_pluginvar *pi;
 
1814
      sys_var *var;
 
1815
      st_bookmark *v= (st_bookmark*) hash_element(&bookmark_hash,idx);
 
1816
 
 
1817
      if (v->version <= session->variables.dynamic_variables_version ||
 
1818
          !(var= intern_find_sys_var(v->key + 1, v->name_len, true)) ||
 
1819
          !(pi= var->cast_pluginvar()) ||
 
1820
          v->key[0] != (pi->plugin_var->flags & PLUGIN_VAR_TYPEMASK))
 
1821
        continue;
 
1822
 
 
1823
      /* Here we do anything special that may be required of the data types */
 
1824
 
 
1825
      if ((pi->plugin_var->flags & PLUGIN_VAR_TYPEMASK) == PLUGIN_VAR_STR &&
 
1826
          pi->plugin_var->flags & PLUGIN_VAR_MEMALLOC)
 
1827
      {
 
1828
         char **pp= (char**) (session->variables.dynamic_variables_ptr +
 
1829
                             *(int*)(pi->plugin_var + 1));
 
1830
         if ((*pp= *(char**) (global_system_variables.dynamic_variables_ptr +
 
1831
                             *(int*)(pi->plugin_var + 1))))
 
1832
           *pp= strdup(*pp);
 
1833
         if (*pp == NULL)
 
1834
           return NULL;
 
1835
      }
 
1836
    }
 
1837
 
 
1838
    if (global_lock)
 
1839
      pthread_mutex_unlock(&LOCK_global_system_variables);
 
1840
 
 
1841
    session->variables.dynamic_variables_version=
 
1842
           global_system_variables.dynamic_variables_version;
 
1843
    session->variables.dynamic_variables_head=
 
1844
           global_system_variables.dynamic_variables_head;
 
1845
    session->variables.dynamic_variables_size=
 
1846
           global_system_variables.dynamic_variables_size;
 
1847
 
 
1848
    pthread_rwlock_unlock(&LOCK_system_variables_hash);
 
1849
  }
 
1850
  return (unsigned char*)session->variables.dynamic_variables_ptr + offset;
 
1851
}
 
1852
 
 
1853
static bool *mysql_sys_var_ptr_bool(Session* a_session, int offset)
 
1854
{
 
1855
  return (bool *)intern_sys_var_ptr(a_session, offset, true);
 
1856
}
 
1857
 
 
1858
static int *mysql_sys_var_ptr_int(Session* a_session, int offset)
 
1859
{
 
1860
  return (int *)intern_sys_var_ptr(a_session, offset, true);
 
1861
}
 
1862
 
 
1863
static long *mysql_sys_var_ptr_long(Session* a_session, int offset)
 
1864
{
 
1865
  return (long *)intern_sys_var_ptr(a_session, offset, true);
 
1866
}
 
1867
 
 
1868
static int64_t *mysql_sys_var_ptr_int64_t(Session* a_session, int offset)
 
1869
{
 
1870
  return (int64_t *)intern_sys_var_ptr(a_session, offset, true);
 
1871
}
 
1872
 
 
1873
static char **mysql_sys_var_ptr_str(Session* a_session, int offset)
 
1874
{
 
1875
  return (char **)intern_sys_var_ptr(a_session, offset, true);
 
1876
}
 
1877
 
 
1878
static uint64_t *mysql_sys_var_ptr_set(Session* a_session, int offset)
 
1879
{
 
1880
  return (uint64_t *)intern_sys_var_ptr(a_session, offset, true);
 
1881
}
 
1882
 
 
1883
static unsigned long *mysql_sys_var_ptr_enum(Session* a_session, int offset)
 
1884
{
 
1885
  return (unsigned long *)intern_sys_var_ptr(a_session, offset, true);
 
1886
}
 
1887
 
512
1888
 
513
1889
void plugin_sessionvar_init(Session *session)
514
1890
{
515
 
  session->variables.storage_engine= NULL;
516
 
  cleanup_variables(&session->variables);
 
1891
  plugin_ref old_table_plugin= session->variables.table_plugin;
 
1892
 
 
1893
  session->variables.table_plugin= NULL;
 
1894
  cleanup_variables(session, &session->variables);
517
1895
 
518
1896
  session->variables= global_system_variables;
519
 
  session->variables.storage_engine= NULL;
 
1897
  session->variables.table_plugin= NULL;
520
1898
 
521
1899
  /* we are going to allocate these lazily */
522
1900
  session->variables.dynamic_variables_version= 0;
523
1901
  session->variables.dynamic_variables_size= 0;
524
1902
  session->variables.dynamic_variables_ptr= 0;
525
1903
 
526
 
  session->variables.storage_engine= global_system_variables.storage_engine;
 
1904
  session->variables.table_plugin=
 
1905
        my_intern_plugin_lock(NULL, global_system_variables.table_plugin);
 
1906
  intern_plugin_unlock(NULL, old_table_plugin);
 
1907
  return;
527
1908
}
528
1909
 
529
1910
 
530
1911
/*
531
1912
  Unlocks all system variables which hold a reference
532
1913
*/
533
 
static void unlock_variables(Session *, struct drizzle_system_variables *vars)
 
1914
static void unlock_variables(Session *, struct system_variables *vars)
534
1915
{
535
 
  vars->storage_engine= NULL;
 
1916
  intern_plugin_unlock(NULL, vars->table_plugin);
 
1917
  vars->table_plugin= NULL;
536
1918
}
537
1919
 
538
1920
 
542
1924
  Unlike plugin_vars_free_values() it frees all variables of all plugins,
543
1925
  it's used on shutdown.
544
1926
*/
545
 
static void cleanup_variables(drizzle_system_variables *vars)
 
1927
static void cleanup_variables(Session *session, struct system_variables *vars)
546
1928
{
547
 
  assert(vars->storage_engine == NULL);
 
1929
  st_bookmark *v;
 
1930
  sys_var_pluginvar *pivar;
 
1931
  sys_var *var;
 
1932
  int flags;
 
1933
  uint32_t idx;
 
1934
 
 
1935
  pthread_rwlock_rdlock(&LOCK_system_variables_hash);
 
1936
  for (idx= 0; idx < bookmark_hash.records; idx++)
 
1937
  {
 
1938
    v= (st_bookmark*) hash_element(&bookmark_hash, idx);
 
1939
    if (v->version > vars->dynamic_variables_version ||
 
1940
        !(var= intern_find_sys_var(v->key + 1, v->name_len, true)) ||
 
1941
        !(pivar= var->cast_pluginvar()) ||
 
1942
        v->key[0] != (pivar->plugin_var->flags & PLUGIN_VAR_TYPEMASK))
 
1943
      continue;
 
1944
 
 
1945
    flags= pivar->plugin_var->flags;
 
1946
 
 
1947
    if ((flags & PLUGIN_VAR_TYPEMASK) == PLUGIN_VAR_STR &&
 
1948
        flags & PLUGIN_VAR_SessionLOCAL && flags & PLUGIN_VAR_MEMALLOC)
 
1949
    {
 
1950
      char **ptr= (char**) pivar->real_value_ptr(session, OPT_SESSION);
 
1951
      free(*ptr);
 
1952
      *ptr= NULL;
 
1953
    }
 
1954
  }
 
1955
  pthread_rwlock_unlock(&LOCK_system_variables_hash);
 
1956
 
 
1957
  assert(vars->table_plugin == NULL);
548
1958
 
549
1959
  free(vars->dynamic_variables_ptr);
550
1960
  vars->dynamic_variables_ptr= NULL;
556
1966
void plugin_sessionvar_cleanup(Session *session)
557
1967
{
558
1968
  unlock_variables(session, &session->variables);
559
 
  cleanup_variables(&session->variables);
560
 
}
561
 
 
 
1969
  cleanup_variables(session, &session->variables);
 
1970
}
 
1971
 
 
1972
 
 
1973
/**
 
1974
  @brief Free values of thread variables of a plugin.
 
1975
 
 
1976
  This must be called before a plugin is deleted. Otherwise its
 
1977
  variables are no longer accessible and the value space is lost. Note
 
1978
  that only string values with PLUGIN_VAR_MEMALLOC are allocated and
 
1979
  must be freed.
 
1980
 
 
1981
  @param[in]        vars        Chain of system variables of a plugin
 
1982
*/
 
1983
 
 
1984
static void plugin_vars_free_values(sys_var *vars)
 
1985
{
 
1986
 
 
1987
  for (sys_var *var= vars; var; var= var->next)
 
1988
  {
 
1989
    sys_var_pluginvar *piv= var->cast_pluginvar();
 
1990
    if (piv &&
 
1991
        ((piv->plugin_var->flags & PLUGIN_VAR_TYPEMASK) == PLUGIN_VAR_STR) &&
 
1992
        (piv->plugin_var->flags & PLUGIN_VAR_MEMALLOC))
 
1993
    {
 
1994
      /* Free the string from global_system_variables. */
 
1995
      char **valptr= (char**) piv->real_value_ptr(NULL, OPT_GLOBAL);
 
1996
      free(*valptr);
 
1997
      *valptr= NULL;
 
1998
    }
 
1999
  }
 
2000
  return;
 
2001
}
 
2002
 
 
2003
 
 
2004
bool sys_var_pluginvar::check_update_type(Item_result type)
 
2005
{
 
2006
  if (is_readonly())
 
2007
    return 1;
 
2008
  switch (plugin_var->flags & PLUGIN_VAR_TYPEMASK) {
 
2009
  case PLUGIN_VAR_INT:
 
2010
  case PLUGIN_VAR_LONG:
 
2011
  case PLUGIN_VAR_LONGLONG:
 
2012
    return type != INT_RESULT;
 
2013
  case PLUGIN_VAR_STR:
 
2014
    return type != STRING_RESULT;
 
2015
  default:
 
2016
    return 0;
 
2017
  }
 
2018
}
 
2019
 
 
2020
 
 
2021
SHOW_TYPE sys_var_pluginvar::show_type()
 
2022
{
 
2023
  switch (plugin_var->flags & PLUGIN_VAR_TYPEMASK) {
 
2024
  case PLUGIN_VAR_BOOL:
 
2025
    return SHOW_MY_BOOL;
 
2026
  case PLUGIN_VAR_INT:
 
2027
    return SHOW_INT;
 
2028
  case PLUGIN_VAR_LONG:
 
2029
    return SHOW_LONG;
 
2030
  case PLUGIN_VAR_LONGLONG:
 
2031
    return SHOW_LONGLONG;
 
2032
  case PLUGIN_VAR_STR:
 
2033
    return SHOW_CHAR_PTR;
 
2034
  case PLUGIN_VAR_ENUM:
 
2035
  case PLUGIN_VAR_SET:
 
2036
    return SHOW_CHAR;
 
2037
  default:
 
2038
    assert(0);
 
2039
    return SHOW_UNDEF;
 
2040
  }
 
2041
}
 
2042
 
 
2043
 
 
2044
unsigned char* sys_var_pluginvar::real_value_ptr(Session *session, enum_var_type type)
 
2045
{
 
2046
  assert(session || (type == OPT_GLOBAL));
 
2047
  if (plugin_var->flags & PLUGIN_VAR_SessionLOCAL)
 
2048
  {
 
2049
    if (type == OPT_GLOBAL)
 
2050
      session= NULL;
 
2051
 
 
2052
    return intern_sys_var_ptr(session, *(int*) (plugin_var+1), false);
 
2053
  }
 
2054
  return *(unsigned char**) (plugin_var+1);
 
2055
}
 
2056
 
 
2057
 
 
2058
TYPELIB* sys_var_pluginvar::plugin_var_typelib(void)
 
2059
{
 
2060
  switch (plugin_var->flags & (PLUGIN_VAR_TYPEMASK | PLUGIN_VAR_SessionLOCAL)) {
 
2061
  case PLUGIN_VAR_ENUM:
 
2062
    return ((sysvar_enum_t *)plugin_var)->typelib;
 
2063
  case PLUGIN_VAR_SET:
 
2064
    return ((sysvar_set_t *)plugin_var)->typelib;
 
2065
  case PLUGIN_VAR_ENUM | PLUGIN_VAR_SessionLOCAL:
 
2066
    return ((sessionvar_enum_t *)plugin_var)->typelib;
 
2067
  case PLUGIN_VAR_SET | PLUGIN_VAR_SessionLOCAL:
 
2068
    return ((sessionvar_set_t *)plugin_var)->typelib;
 
2069
  default:
 
2070
    return NULL;
 
2071
  }
 
2072
  return NULL;
 
2073
}
 
2074
 
 
2075
 
 
2076
unsigned char* sys_var_pluginvar::value_ptr(Session *session, enum_var_type type, LEX_STRING *)
 
2077
{
 
2078
  unsigned char* result;
 
2079
 
 
2080
  result= real_value_ptr(session, type);
 
2081
 
 
2082
  if ((plugin_var->flags & PLUGIN_VAR_TYPEMASK) == PLUGIN_VAR_ENUM)
 
2083
    result= (unsigned char*) get_type(plugin_var_typelib(), *(ulong*)result);
 
2084
  else if ((plugin_var->flags & PLUGIN_VAR_TYPEMASK) == PLUGIN_VAR_SET)
 
2085
  {
 
2086
    char buffer[STRING_BUFFER_USUAL_SIZE];
 
2087
    String str(buffer, sizeof(buffer), system_charset_info);
 
2088
    TYPELIB *typelib= plugin_var_typelib();
 
2089
    uint64_t mask= 1, value= *(uint64_t*) result;
 
2090
    uint32_t i;
 
2091
 
 
2092
    str.length(0);
 
2093
    for (i= 0; i < typelib->count; i++, mask<<=1)
 
2094
    {
 
2095
      if (!(value & mask))
 
2096
        continue;
 
2097
      str.append(typelib->type_names[i], typelib->type_lengths[i]);
 
2098
      str.append(',');
 
2099
    }
 
2100
 
 
2101
    result= (unsigned char*) "";
 
2102
    if (str.length())
 
2103
      result= (unsigned char*) session->strmake(str.ptr(), str.length()-1);
 
2104
  }
 
2105
  return result;
 
2106
}
 
2107
 
 
2108
 
 
2109
bool sys_var_pluginvar::check(Session *session, set_var *var)
 
2110
{
 
2111
  st_item_value_holder value;
 
2112
  assert(is_readonly() || plugin_var->check);
 
2113
 
 
2114
  value.value_type= item_value_type;
 
2115
  value.val_str= item_val_str;
 
2116
  value.val_int= item_val_int;
 
2117
  value.val_real= item_val_real;
 
2118
  value.item= var->value;
 
2119
 
 
2120
  return is_readonly() ||
 
2121
         plugin_var->check(session, plugin_var, &var->save_result, &value);
 
2122
}
 
2123
 
 
2124
 
 
2125
void sys_var_pluginvar::set_default(Session *session, enum_var_type type)
 
2126
{
 
2127
  const void *src;
 
2128
  void *tgt;
 
2129
 
 
2130
  assert(is_readonly() || plugin_var->update);
 
2131
 
 
2132
  if (is_readonly())
 
2133
    return;
 
2134
 
 
2135
  pthread_mutex_lock(&LOCK_global_system_variables);
 
2136
  tgt= real_value_ptr(session, type);
 
2137
  src= ((void **) (plugin_var + 1) + 1);
 
2138
 
 
2139
  if (plugin_var->flags & PLUGIN_VAR_SessionLOCAL)
 
2140
  {
 
2141
    if (type != OPT_GLOBAL)
 
2142
      src= real_value_ptr(session, OPT_GLOBAL);
 
2143
    else
 
2144
    switch (plugin_var->flags & PLUGIN_VAR_TYPEMASK) {
 
2145
        case PLUGIN_VAR_INT:
 
2146
          src= &((sessionvar_uint_t*) plugin_var)->def_val;
 
2147
          break;
 
2148
        case PLUGIN_VAR_LONG:
 
2149
          src= &((sessionvar_ulong_t*) plugin_var)->def_val;
 
2150
          break;
 
2151
        case PLUGIN_VAR_LONGLONG:
 
2152
          src= &((sessionvar_uint64_t_t*) plugin_var)->def_val;
 
2153
          break;
 
2154
        case PLUGIN_VAR_ENUM:
 
2155
          src= &((sessionvar_enum_t*) plugin_var)->def_val;
 
2156
          break;
 
2157
        case PLUGIN_VAR_SET:
 
2158
          src= &((sessionvar_set_t*) plugin_var)->def_val;
 
2159
          break;
 
2160
        case PLUGIN_VAR_BOOL:
 
2161
          src= &((sessionvar_bool_t*) plugin_var)->def_val;
 
2162
          break;
 
2163
        case PLUGIN_VAR_STR:
 
2164
          src= &((sessionvar_str_t*) plugin_var)->def_val;
 
2165
          break;
 
2166
        default:
 
2167
          assert(0);
 
2168
        }
 
2169
  }
 
2170
 
 
2171
  /* session must equal current_session if PLUGIN_VAR_SessionLOCAL flag is set */
 
2172
  assert(!(plugin_var->flags & PLUGIN_VAR_SessionLOCAL) ||
 
2173
              session == current_session);
 
2174
 
 
2175
  if (!(plugin_var->flags & PLUGIN_VAR_SessionLOCAL) || type == OPT_GLOBAL)
 
2176
  {
 
2177
    plugin_var->update(session, plugin_var, tgt, src);
 
2178
    pthread_mutex_unlock(&LOCK_global_system_variables);
 
2179
  }
 
2180
  else
 
2181
  {
 
2182
    pthread_mutex_unlock(&LOCK_global_system_variables);
 
2183
    plugin_var->update(session, plugin_var, tgt, src);
 
2184
  }
 
2185
}
 
2186
 
 
2187
 
 
2188
bool sys_var_pluginvar::update(Session *session, set_var *var)
 
2189
{
 
2190
  void *tgt;
 
2191
 
 
2192
  assert(is_readonly() || plugin_var->update);
 
2193
 
 
2194
  /* session must equal current_session if PLUGIN_VAR_SessionLOCAL flag is set */
 
2195
  assert(!(plugin_var->flags & PLUGIN_VAR_SessionLOCAL) ||
 
2196
              session == current_session);
 
2197
 
 
2198
  if (is_readonly())
 
2199
    return 1;
 
2200
 
 
2201
  pthread_mutex_lock(&LOCK_global_system_variables);
 
2202
  tgt= real_value_ptr(session, var->type);
 
2203
 
 
2204
  if (!(plugin_var->flags & PLUGIN_VAR_SessionLOCAL) || var->type == OPT_GLOBAL)
 
2205
  {
 
2206
    /* variable we are updating has global scope, so we unlock after updating */
 
2207
    plugin_var->update(session, plugin_var, tgt, &var->save_result);
 
2208
    pthread_mutex_unlock(&LOCK_global_system_variables);
 
2209
  }
 
2210
  else
 
2211
  {
 
2212
    pthread_mutex_unlock(&LOCK_global_system_variables);
 
2213
    plugin_var->update(session, plugin_var, tgt, &var->save_result);
 
2214
  }
 
2215
 return 0;
 
2216
}
 
2217
 
 
2218
 
 
2219
#define OPTION_SET_LIMITS(type, options, opt) \
 
2220
  options->var_type= type;                    \
 
2221
  options->def_value= (opt)->def_val;         \
 
2222
  options->min_value= (opt)->min_val;         \
 
2223
  options->max_value= (opt)->max_val;         \
 
2224
  options->block_size= (long) (opt)->blk_sz
 
2225
 
 
2226
 
 
2227
static void plugin_opt_set_limits(struct my_option *options,
 
2228
                                  const struct st_mysql_sys_var *opt)
 
2229
{
 
2230
  options->sub_size= 0;
 
2231
 
 
2232
  switch (opt->flags & (PLUGIN_VAR_TYPEMASK |
 
2233
                        PLUGIN_VAR_UNSIGNED | PLUGIN_VAR_SessionLOCAL)) {
 
2234
  /* global system variables */
 
2235
  case PLUGIN_VAR_INT:
 
2236
    OPTION_SET_LIMITS(GET_INT, options, (sysvar_int_t*) opt);
 
2237
    break;
 
2238
  case PLUGIN_VAR_INT | PLUGIN_VAR_UNSIGNED:
 
2239
    OPTION_SET_LIMITS(GET_UINT, options, (sysvar_uint_t*) opt);
 
2240
    break;
 
2241
  case PLUGIN_VAR_LONG:
 
2242
    OPTION_SET_LIMITS(GET_LONG, options, (sysvar_long_t*) opt);
 
2243
    break;
 
2244
  case PLUGIN_VAR_LONG | PLUGIN_VAR_UNSIGNED:
 
2245
    OPTION_SET_LIMITS(GET_ULONG, options, (sysvar_ulong_t*) opt);
 
2246
    break;
 
2247
  case PLUGIN_VAR_LONGLONG:
 
2248
    OPTION_SET_LIMITS(GET_LL, options, (sysvar_int64_t_t*) opt);
 
2249
    break;
 
2250
  case PLUGIN_VAR_LONGLONG | PLUGIN_VAR_UNSIGNED:
 
2251
    OPTION_SET_LIMITS(GET_ULL, options, (sysvar_uint64_t_t*) opt);
 
2252
    break;
 
2253
  case PLUGIN_VAR_ENUM:
 
2254
    options->var_type= GET_ENUM;
 
2255
    options->typelib= ((sysvar_enum_t*) opt)->typelib;
 
2256
    options->def_value= ((sysvar_enum_t*) opt)->def_val;
 
2257
    options->min_value= options->block_size= 0;
 
2258
    options->max_value= options->typelib->count - 1;
 
2259
    break;
 
2260
  case PLUGIN_VAR_SET:
 
2261
    options->var_type= GET_SET;
 
2262
    options->typelib= ((sysvar_set_t*) opt)->typelib;
 
2263
    options->def_value= ((sysvar_set_t*) opt)->def_val;
 
2264
    options->min_value= options->block_size= 0;
 
2265
    options->max_value= (1UL << options->typelib->count) - 1;
 
2266
    break;
 
2267
  case PLUGIN_VAR_BOOL:
 
2268
    options->var_type= GET_BOOL;
 
2269
    options->def_value= ((sysvar_bool_t*) opt)->def_val;
 
2270
    break;
 
2271
  case PLUGIN_VAR_STR:
 
2272
    options->var_type= ((opt->flags & PLUGIN_VAR_MEMALLOC) ?
 
2273
                        GET_STR_ALLOC : GET_STR);
 
2274
    options->def_value= (intptr_t) ((sysvar_str_t*) opt)->def_val;
 
2275
    break;
 
2276
  /* threadlocal variables */
 
2277
  case PLUGIN_VAR_INT | PLUGIN_VAR_SessionLOCAL:
 
2278
    OPTION_SET_LIMITS(GET_INT, options, (sessionvar_int_t*) opt);
 
2279
    break;
 
2280
  case PLUGIN_VAR_INT | PLUGIN_VAR_UNSIGNED | PLUGIN_VAR_SessionLOCAL:
 
2281
    OPTION_SET_LIMITS(GET_UINT, options, (sessionvar_uint_t*) opt);
 
2282
    break;
 
2283
  case PLUGIN_VAR_LONG | PLUGIN_VAR_SessionLOCAL:
 
2284
    OPTION_SET_LIMITS(GET_LONG, options, (sessionvar_long_t*) opt);
 
2285
    break;
 
2286
  case PLUGIN_VAR_LONG | PLUGIN_VAR_UNSIGNED | PLUGIN_VAR_SessionLOCAL:
 
2287
    OPTION_SET_LIMITS(GET_ULONG, options, (sessionvar_ulong_t*) opt);
 
2288
    break;
 
2289
  case PLUGIN_VAR_LONGLONG | PLUGIN_VAR_SessionLOCAL:
 
2290
    OPTION_SET_LIMITS(GET_LL, options, (sessionvar_int64_t_t*) opt);
 
2291
    break;
 
2292
  case PLUGIN_VAR_LONGLONG | PLUGIN_VAR_UNSIGNED | PLUGIN_VAR_SessionLOCAL:
 
2293
    OPTION_SET_LIMITS(GET_ULL, options, (sessionvar_uint64_t_t*) opt);
 
2294
    break;
 
2295
  case PLUGIN_VAR_ENUM | PLUGIN_VAR_SessionLOCAL:
 
2296
    options->var_type= GET_ENUM;
 
2297
    options->typelib= ((sessionvar_enum_t*) opt)->typelib;
 
2298
    options->def_value= ((sessionvar_enum_t*) opt)->def_val;
 
2299
    options->min_value= options->block_size= 0;
 
2300
    options->max_value= options->typelib->count - 1;
 
2301
    break;
 
2302
  case PLUGIN_VAR_SET | PLUGIN_VAR_SessionLOCAL:
 
2303
    options->var_type= GET_SET;
 
2304
    options->typelib= ((sessionvar_set_t*) opt)->typelib;
 
2305
    options->def_value= ((sessionvar_set_t*) opt)->def_val;
 
2306
    options->min_value= options->block_size= 0;
 
2307
    options->max_value= (1UL << options->typelib->count) - 1;
 
2308
    break;
 
2309
  case PLUGIN_VAR_BOOL | PLUGIN_VAR_SessionLOCAL:
 
2310
    options->var_type= GET_BOOL;
 
2311
    options->def_value= ((sessionvar_bool_t*) opt)->def_val;
 
2312
    break;
 
2313
  case PLUGIN_VAR_STR | PLUGIN_VAR_SessionLOCAL:
 
2314
    options->var_type= ((opt->flags & PLUGIN_VAR_MEMALLOC) ?
 
2315
                        GET_STR_ALLOC : GET_STR);
 
2316
    options->def_value= (intptr_t) ((sessionvar_str_t*) opt)->def_val;
 
2317
    break;
 
2318
  default:
 
2319
    assert(0);
 
2320
  }
 
2321
  options->arg_type= REQUIRED_ARG;
 
2322
  if (opt->flags & PLUGIN_VAR_NOCMDARG)
 
2323
    options->arg_type= NO_ARG;
 
2324
  if (opt->flags & PLUGIN_VAR_OPCMDARG)
 
2325
    options->arg_type= OPT_ARG;
 
2326
}
 
2327
 
 
2328
extern "C" bool get_one_plugin_option(int optid, const struct my_option *,
 
2329
                                         char *);
 
2330
 
 
2331
bool get_one_plugin_option(int, const struct my_option *, char *)
 
2332
{
 
2333
  return 0;
 
2334
}
 
2335
 
 
2336
 
 
2337
static int construct_options(MEM_ROOT *mem_root, struct st_plugin_int *tmp,
 
2338
                             my_option *options, bool can_disable)
 
2339
{
 
2340
  const char *plugin_name= tmp->plugin->name;
 
2341
  uint32_t namelen= strlen(plugin_name), optnamelen;
 
2342
  uint32_t buffer_length= namelen * 4 + (can_disable ? 75 : 10);
 
2343
  char *name= (char*) alloc_root(mem_root, buffer_length) + 1;
 
2344
  char *optname, *p;
 
2345
  int index= 0, offset= 0;
 
2346
  st_mysql_sys_var *opt, **plugin_option;
 
2347
  st_bookmark *v;
 
2348
 
 
2349
  /* support --skip-plugin-foo syntax */
 
2350
  memcpy(name, plugin_name, namelen + 1);
 
2351
  my_casedn_str(&my_charset_utf8_general_ci, name);
 
2352
  sprintf(name+namelen+1, "plugin-%s", name);
 
2353
  /* Now we have namelen + 1 + 7 + namelen + 1 == namelen * 2 + 9. */
 
2354
 
 
2355
  for (p= name + namelen*2 + 8; p > name; p--)
 
2356
    if (*p == '_')
 
2357
      *p= '-';
 
2358
 
 
2359
  if (can_disable)
 
2360
  {
 
2361
    sprintf(name+namelen*2+10,
 
2362
            "Enable %s plugin. Disable with --skip-%s (will save memory).",
 
2363
            plugin_name, name);
 
2364
    /*
 
2365
      Now we have namelen * 2 + 10 (one char unused) + 7 + namelen + 9 +
 
2366
      20 + namelen + 20 + 1 == namelen * 4 + 67.
 
2367
    */
 
2368
 
 
2369
    options[0].comment= name + namelen*2 + 10;
 
2370
  }
 
2371
 
 
2372
  options[1].name= (options[0].name= name) + namelen + 1;
 
2373
  options[0].id= options[1].id= 256; /* must be >255. dup id ok */
 
2374
  options[0].var_type= options[1].var_type= GET_BOOL;
 
2375
  options[0].arg_type= options[1].arg_type= NO_ARG;
 
2376
  options[0].def_value= options[1].def_value= true;
 
2377
  options[0].value= options[0].u_max_value=
 
2378
  options[1].value= options[1].u_max_value= (char**) (name - 1);
 
2379
  options+= 2;
 
2380
 
 
2381
  /*
 
2382
    Two passes as the 2nd pass will take pointer addresses for use
 
2383
    by my_getopt and register_var() in the first pass uses realloc
 
2384
  */
 
2385
 
 
2386
  for (plugin_option= tmp->plugin->system_vars;
 
2387
       plugin_option && *plugin_option; plugin_option++, index++)
 
2388
  {
 
2389
    opt= *plugin_option;
 
2390
    if (!(opt->flags & PLUGIN_VAR_SessionLOCAL))
 
2391
      continue;
 
2392
    if (!(register_var(name, opt->name, opt->flags)))
 
2393
      continue;
 
2394
    switch (opt->flags & PLUGIN_VAR_TYPEMASK) {
 
2395
    case PLUGIN_VAR_BOOL:
 
2396
      (((sessionvar_bool_t *)opt)->resolve)= mysql_sys_var_ptr_bool;
 
2397
      break;
 
2398
    case PLUGIN_VAR_INT:
 
2399
      (((sessionvar_int_t *)opt)->resolve)= mysql_sys_var_ptr_int;
 
2400
      break;
 
2401
    case PLUGIN_VAR_LONG:
 
2402
      (((sessionvar_long_t *)opt)->resolve)= mysql_sys_var_ptr_long;
 
2403
      break;
 
2404
    case PLUGIN_VAR_LONGLONG:
 
2405
      (((sessionvar_int64_t_t *)opt)->resolve)= mysql_sys_var_ptr_int64_t;
 
2406
      break;
 
2407
    case PLUGIN_VAR_STR:
 
2408
      (((sessionvar_str_t *)opt)->resolve)= mysql_sys_var_ptr_str;
 
2409
      break;
 
2410
    case PLUGIN_VAR_ENUM:
 
2411
      (((sessionvar_enum_t *)opt)->resolve)= mysql_sys_var_ptr_enum;
 
2412
      break;
 
2413
    case PLUGIN_VAR_SET:
 
2414
      (((sessionvar_set_t *)opt)->resolve)= mysql_sys_var_ptr_set;
 
2415
      break;
 
2416
    default:
 
2417
      errmsg_printf(ERRMSG_LVL_ERROR, _("Unknown variable type code 0x%x in plugin '%s'."),
 
2418
                      opt->flags, plugin_name);
 
2419
      return(-1);
 
2420
    };
 
2421
  }
 
2422
 
 
2423
  for (plugin_option= tmp->plugin->system_vars;
 
2424
       plugin_option && *plugin_option; plugin_option++, index++)
 
2425
  {
 
2426
    switch ((opt= *plugin_option)->flags & PLUGIN_VAR_TYPEMASK) {
 
2427
    case PLUGIN_VAR_BOOL:
 
2428
      if (!opt->check)
 
2429
        opt->check= check_func_bool;
 
2430
      if (!opt->update)
 
2431
        opt->update= update_func_bool;
 
2432
      break;
 
2433
    case PLUGIN_VAR_INT:
 
2434
      if (!opt->check)
 
2435
        opt->check= check_func_int;
 
2436
      if (!opt->update)
 
2437
        opt->update= update_func_int;
 
2438
      break;
 
2439
    case PLUGIN_VAR_LONG:
 
2440
      if (!opt->check)
 
2441
        opt->check= check_func_long;
 
2442
      if (!opt->update)
 
2443
        opt->update= update_func_long;
 
2444
      break;
 
2445
    case PLUGIN_VAR_LONGLONG:
 
2446
      if (!opt->check)
 
2447
        opt->check= check_func_int64_t;
 
2448
      if (!opt->update)
 
2449
        opt->update= update_func_int64_t;
 
2450
      break;
 
2451
    case PLUGIN_VAR_STR:
 
2452
      if (!opt->check)
 
2453
        opt->check= check_func_str;
 
2454
      if (!opt->update)
 
2455
      {
 
2456
        opt->update= update_func_str;
 
2457
        if ((opt->flags & (PLUGIN_VAR_MEMALLOC | PLUGIN_VAR_READONLY)) == false)
 
2458
        {
 
2459
          opt->flags|= PLUGIN_VAR_READONLY;
 
2460
          errmsg_printf(ERRMSG_LVL_WARN, _("Server variable %s of plugin %s was forced "
 
2461
                            "to be read-only: string variable without "
 
2462
                            "update_func and PLUGIN_VAR_MEMALLOC flag"),
 
2463
                            opt->name, plugin_name);
 
2464
        }
 
2465
      }
 
2466
      break;
 
2467
    case PLUGIN_VAR_ENUM:
 
2468
      if (!opt->check)
 
2469
        opt->check= check_func_enum;
 
2470
      if (!opt->update)
 
2471
        opt->update= update_func_long;
 
2472
      break;
 
2473
    case PLUGIN_VAR_SET:
 
2474
      if (!opt->check)
 
2475
        opt->check= check_func_set;
 
2476
      if (!opt->update)
 
2477
        opt->update= update_func_int64_t;
 
2478
      break;
 
2479
    default:
 
2480
      errmsg_printf(ERRMSG_LVL_ERROR, _("Unknown variable type code 0x%x in plugin '%s'."),
 
2481
                      opt->flags, plugin_name);
 
2482
      return(-1);
 
2483
    }
 
2484
 
 
2485
    if ((opt->flags & (PLUGIN_VAR_NOCMDOPT | PLUGIN_VAR_SessionLOCAL))
 
2486
                    == PLUGIN_VAR_NOCMDOPT)
 
2487
      continue;
 
2488
 
 
2489
    if (!opt->name)
 
2490
    {
 
2491
      errmsg_printf(ERRMSG_LVL_ERROR, _("Missing variable name in plugin '%s'."),
 
2492
                      plugin_name);
 
2493
      return(-1);
 
2494
    }
 
2495
 
 
2496
    if (!(opt->flags & PLUGIN_VAR_SessionLOCAL))
 
2497
    {
 
2498
      optnamelen= strlen(opt->name);
 
2499
      optname= (char*) alloc_root(mem_root, namelen + optnamelen + 2);
 
2500
      sprintf(optname, "%s-%s", name, opt->name);
 
2501
      optnamelen= namelen + optnamelen + 1;
 
2502
    }
 
2503
    else
 
2504
    {
 
2505
      /* this should not fail because register_var should create entry */
 
2506
      if (!(v= find_bookmark(name, opt->name, opt->flags)))
 
2507
      {
 
2508
        errmsg_printf(ERRMSG_LVL_ERROR, _("Thread local variable '%s' not allocated "
 
2509
                        "in plugin '%s'."), opt->name, plugin_name);
 
2510
        return(-1);
 
2511
      }
 
2512
 
 
2513
      *(int*)(opt + 1)= offset= v->offset;
 
2514
 
 
2515
      if (opt->flags & PLUGIN_VAR_NOCMDOPT)
 
2516
        continue;
 
2517
 
 
2518
      optname= (char*) memdup_root(mem_root, v->key + 1,
 
2519
                                   (optnamelen= v->name_len) + 1);
 
2520
    }
 
2521
 
 
2522
    /* convert '_' to '-' */
 
2523
    for (p= optname; *p; p++)
 
2524
      if (*p == '_')
 
2525
        *p= '-';
 
2526
 
 
2527
    options->name= optname;
 
2528
    options->comment= opt->comment;
 
2529
    options->app_type= opt;
 
2530
    options->id= (options-1)->id + 1;
 
2531
 
 
2532
    plugin_opt_set_limits(options, opt);
 
2533
 
 
2534
    if (opt->flags & PLUGIN_VAR_SessionLOCAL)
 
2535
      options->value= options->u_max_value= (char**)
 
2536
        (global_system_variables.dynamic_variables_ptr + offset);
 
2537
    else
 
2538
      options->value= options->u_max_value= *(char***) (opt + 1);
 
2539
 
 
2540
    options[1]= options[0];
 
2541
    options[1].name= p= (char*) alloc_root(mem_root, optnamelen + 8);
 
2542
    options[1].comment= 0; // hidden
 
2543
    sprintf(p,"plugin-%s",optname);
 
2544
 
 
2545
    options+= 2;
 
2546
  }
 
2547
 
 
2548
  return(0);
 
2549
}
 
2550
 
 
2551
 
 
2552
static my_option *construct_help_options(MEM_ROOT *mem_root,
 
2553
                                         struct st_plugin_int *p)
 
2554
{
 
2555
  st_mysql_sys_var **opt;
 
2556
  my_option *opts;
 
2557
  bool can_disable;
 
2558
  uint32_t count= EXTRA_OPTIONS;
 
2559
 
 
2560
  for (opt= p->plugin->system_vars; opt && *opt; opt++, count+= 2) {};
 
2561
 
 
2562
  if (!(opts= (my_option*) alloc_root(mem_root, sizeof(my_option) * count)))
 
2563
    return(NULL);
 
2564
 
 
2565
  memset(opts, 0, sizeof(my_option) * count);
 
2566
 
 
2567
  if ((my_strcasecmp(&my_charset_utf8_general_ci, p->name.str, "MyISAM") == 0))
 
2568
    can_disable= false;
 
2569
  else if ((my_strcasecmp(&my_charset_utf8_general_ci, p->name.str, "MEMORY") == 0))
 
2570
    can_disable= false;
 
2571
  else
 
2572
    can_disable= true;
 
2573
 
 
2574
 
 
2575
  if (construct_options(mem_root, p, opts, can_disable))
 
2576
    return(NULL);
 
2577
 
 
2578
  return(opts);
 
2579
}
562
2580
 
563
2581
 
564
2582
/*
566
2584
    test_plugin_options()
567
2585
    tmp_root                    temporary scratch space
568
2586
    plugin                      internal plugin structure
 
2587
    argc                        user supplied arguments
 
2588
    argv                        user supplied arguments
569
2589
    default_enabled             default plugin enable status
570
2590
  RETURNS:
571
2591
    0 SUCCESS - plugin should be enabled/loaded
572
2592
  NOTE:
573
2593
    Requires that a write-lock is held on LOCK_system_variables_hash
574
2594
*/
575
 
static int test_plugin_options(memory::Root *,
576
 
                               module::Module *test_module,
577
 
                               po::options_description &long_options)
 
2595
static int test_plugin_options(MEM_ROOT *tmp_root, struct st_plugin_int *tmp,
 
2596
                               int *argc, char **argv)
578
2597
{
579
 
 
580
 
  if (test_module->getManifest().init_options != NULL)
581
 
  {
582
 
    string plugin_section_title("Options used by ");
583
 
    plugin_section_title.append(test_module->getName());
584
 
    po::options_description module_options(plugin_section_title);
585
 
    module::option_context opt_ctx(test_module->getName(),
586
 
                                   module_options.add_options());
587
 
    test_module->getManifest().init_options(opt_ctx);
588
 
    long_options.add(module_options);
589
 
  }
590
 
 
591
 
  return 0;
 
2598
  struct sys_var_chain chain= { NULL, NULL };
 
2599
  bool enabled_saved= true;
 
2600
  bool can_disable;
 
2601
  MEM_ROOT *mem_root= alloc_root_inited(&tmp->mem_root) ?
 
2602
                      &tmp->mem_root : &plugin_mem_root;
 
2603
  st_mysql_sys_var **opt;
 
2604
  my_option *opts= NULL;
 
2605
  char *p, *varname;
 
2606
  int error;
 
2607
  st_mysql_sys_var *o;
 
2608
  sys_var *v;
 
2609
  struct st_bookmark *var;
 
2610
  uint32_t len, count= EXTRA_OPTIONS;
 
2611
  assert(tmp->plugin && tmp->name.str);
 
2612
 
 
2613
  for (opt= tmp->plugin->system_vars; opt && *opt; opt++)
 
2614
    count+= 2; /* --{plugin}-{optname} and --plugin-{plugin}-{optname} */
 
2615
 
 
2616
  if ((my_strcasecmp(&my_charset_utf8_general_ci, tmp->name.str, "MyISAM") == 0))
 
2617
    can_disable= false;
 
2618
  else if ((my_strcasecmp(&my_charset_utf8_general_ci, tmp->name.str, "MEMORY") == 0))
 
2619
    can_disable= false;
 
2620
  else
 
2621
    can_disable= true;
 
2622
 
 
2623
  if (count > EXTRA_OPTIONS || (*argc > 1))
 
2624
  {
 
2625
    if (!(opts= (my_option*) alloc_root(tmp_root, sizeof(my_option) * count)))
 
2626
    {
 
2627
      errmsg_printf(ERRMSG_LVL_ERROR, _("Out of memory for plugin '%s'."), tmp->name.str);
 
2628
      return(-1);
 
2629
    }
 
2630
    memset(opts, 0, sizeof(my_option) * count);
 
2631
 
 
2632
    if (construct_options(tmp_root, tmp, opts, can_disable))
 
2633
    {
 
2634
      errmsg_printf(ERRMSG_LVL_ERROR, _("Bad options for plugin '%s'."), tmp->name.str);
 
2635
      return(-1);
 
2636
    }
 
2637
 
 
2638
    error= handle_options(argc, &argv, opts, get_one_plugin_option);
 
2639
    (*argc)++; /* add back one for the program name */
 
2640
 
 
2641
    if (error)
 
2642
    {
 
2643
       errmsg_printf(ERRMSG_LVL_ERROR, _("Parsing options for plugin '%s' failed."),
 
2644
                       tmp->name.str);
 
2645
       goto err;
 
2646
    }
 
2647
  }
 
2648
 
 
2649
  error= 1;
 
2650
 
 
2651
  {
 
2652
    for (opt= tmp->plugin->system_vars; opt && *opt; opt++)
 
2653
    {
 
2654
      if (((o= *opt)->flags & PLUGIN_VAR_NOSYSVAR))
 
2655
        continue;
 
2656
 
 
2657
      if ((var= find_bookmark(tmp->name.str, o->name, o->flags)))
 
2658
        v= new (mem_root) sys_var_pluginvar(var->key + 1, o);
 
2659
      else
 
2660
      {
 
2661
        len= tmp->name.length + strlen(o->name) + 2;
 
2662
        varname= (char*) alloc_root(mem_root, len);
 
2663
        sprintf(varname,"%s-%s",tmp->name.str,o->name);
 
2664
        my_casedn_str(&my_charset_utf8_general_ci, varname);
 
2665
 
 
2666
        for (p= varname; *p; p++)
 
2667
          if (*p == '-')
 
2668
            *p= '_';
 
2669
 
 
2670
        v= new (mem_root) sys_var_pluginvar(varname, o);
 
2671
      }
 
2672
      assert(v); /* check that an object was actually constructed */
 
2673
 
 
2674
      /*
 
2675
        Add to the chain of variables.
 
2676
        Done like this for easier debugging so that the
 
2677
        pointer to v is not lost on optimized builds.
 
2678
      */
 
2679
      v->chain_sys_var(&chain);
 
2680
    }
 
2681
    if (chain.first)
 
2682
    {
 
2683
      chain.last->next = NULL;
 
2684
      if (mysql_add_sys_var_chain(chain.first, NULL))
 
2685
      {
 
2686
        errmsg_printf(ERRMSG_LVL_ERROR, _("Plugin '%s' has conflicting system variables"),
 
2687
                        tmp->name.str);
 
2688
        goto err;
 
2689
      }
 
2690
      tmp->system_vars= chain.first;
 
2691
    }
 
2692
    return(0);
 
2693
  }
 
2694
 
 
2695
  if (enabled_saved && global_system_variables.log_warnings)
 
2696
    errmsg_printf(ERRMSG_LVL_INFO, _("Plugin '%s' disabled by command line option"),
 
2697
                          tmp->name.str);
 
2698
err:
 
2699
  if (opts)
 
2700
    my_cleanup_options(opts);
 
2701
  return(error);
592
2702
}
593
2703
 
594
2704
 
596
2706
  Help Verbose text with Plugin System Variables
597
2707
****************************************************************************/
598
2708
 
599
 
class OptionCmp
600
 
{
601
 
public:
602
 
  bool operator() (const option &a, const option &b)
603
 
  {
604
 
    return my_strcasecmp(&my_charset_utf8_general_ci, a.name, b.name);
605
 
  }
606
 
};
607
 
 
608
 
 
609
 
void my_print_help_inc_plugins(option *main_options)
610
 
{
611
 
  module::Registry &registry= module::Registry::singleton();
612
 
  vector<option> all_options;
613
 
  memory::Root mem_root(4096);
614
 
 
 
2709
static int option_cmp(my_option *a, my_option *b)
 
2710
{
 
2711
  return my_strcasecmp(&my_charset_utf8_general_ci, a->name, b->name);
 
2712
}
 
2713
 
 
2714
 
 
2715
void my_print_help_inc_plugins(my_option *main_options, uint32_t size)
 
2716
{
 
2717
  DYNAMIC_ARRAY all_options;
 
2718
  struct st_plugin_int *p;
 
2719
  MEM_ROOT mem_root;
 
2720
  my_option *opt;
 
2721
 
 
2722
  init_alloc_root(&mem_root, 4096, 4096);
 
2723
  my_init_dynamic_array(&all_options, sizeof(my_option), size, size/4);
615
2724
 
616
2725
  if (initialized)
617
 
  {
618
 
    std::map<std::string, module::Module *>::const_iterator modules=
619
 
      registry.getModulesMap().begin();
620
 
    
621
 
    while (modules != registry.getModulesMap().end())
 
2726
    for (uint32_t idx= 0; idx < plugin_array.elements; idx++)
622
2727
    {
623
 
      module::Module *p= (*modules).second;
624
 
      ++modules;
 
2728
      p= *dynamic_element(&plugin_array, idx, struct st_plugin_int **);
625
2729
 
626
 
      /* If we have an init_options function, we are registering
627
 
         commmand line options that way, so don't do them this way */
628
 
      if (p->getManifest().init_options != NULL)
 
2730
      if (!p->plugin->system_vars ||
 
2731
          !(opt= construct_help_options(&mem_root, p)))
629
2732
        continue;
630
2733
 
 
2734
      /* Only options with a non-NULL comment are displayed in help text */
 
2735
      for (;opt->id; opt++)
 
2736
        if (opt->comment)
 
2737
          insert_dynamic(&all_options, (unsigned char*) opt);
631
2738
    }
632
 
  }
633
2739
 
634
2740
  for (;main_options->id; main_options++)
635
 
  {
636
 
    if (main_options->comment)
637
 
    {
638
 
      all_options.push_back(*main_options);
639
 
    }
640
 
  }
 
2741
    insert_dynamic(&all_options, (unsigned char*) main_options);
641
2742
 
642
 
  /** 
643
 
   * @TODO: Fix the option building so that it doens't break sort
644
 
   *
645
 
   * sort(all_options.begin(), all_options.end(), OptionCmp());
646
 
   */
 
2743
  sort_dynamic(&all_options, (qsort_cmp) option_cmp);
647
2744
 
648
2745
  /* main_options now points to the empty option terminator */
649
 
  all_options.push_back(*main_options);
650
 
 
651
 
  my_print_help(&*(all_options.begin()));
652
 
 
653
 
  mem_root.free_root(MYF(0));
 
2746
  insert_dynamic(&all_options, (unsigned char*) main_options);
 
2747
 
 
2748
  my_print_help((my_option*) all_options.buffer);
 
2749
  my_print_variables((my_option*) all_options.buffer);
 
2750
 
 
2751
  delete_dynamic(&all_options);
 
2752
  free_root(&mem_root, MYF(0));
654
2753
}
655
2754
 
656
 
} /* namespace drizzled */
657
 
 
658