← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to server/sql_plugin.cc

  • Committer: Brian Aker
  • Date: 2008-07-20 05:41:52 UTC
  • Revision ID: brian@tangent.org-20080720054152-5laf6plsb0o7h6ss
Documentation cleanup

Show diffs side-by-side

added added

removed removed

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