summaryrefslogtreecommitdiffstats
path: root/sql/sql_reload.cc
blob: 8f0f15a982a0ea5073a719b270d77f18577a3611 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
/* Copyright (c) 2010, 2016, Oracle and/or its affiliates.
   Copyright (c) 2011, 2016, MariaDB

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; version 2 of the License.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335  USA */

#include "mariadb.h"
#include "sql_reload.h"
#include "sql_priv.h"
#include "mysqld.h"      // select_errors
#include "sql_class.h"   // THD
#include "sql_acl.h"     // acl_reload
#include "sql_servers.h" // servers_reload
#include "sql_connect.h" // reset_mqh
#include "thread_cache.h"
#include "sql_base.h"    // close_cached_tables
#include "sql_parse.h"   // check_single_table_access
#include "sql_db.h"      // my_dbopt_cleanup
#include "hostname.h"    // hostname_cache_refresh
#include "sql_repl.h"    // reset_master, reset_slave
#include "rpl_mi.h"      // Master_info::data_lock
#include "sql_show.h"
#include "debug_sync.h"
#include "des_key_file.h"
#include "transaction.h"
#ifdef WITH_WSREP
#include "wsrep_mysqld.h"
#endif

static void disable_checkpoints(THD *thd);

/**
  Reload/resets privileges and the different caches.

  @param thd Thread handler (can be NULL!)
  @param options What should be reset/reloaded (tables, privileges, slave...)
  @param tables Tables to flush (if any)
  @param write_to_binlog < 0 if there was an error while interacting with the binary log inside
                         reload_acl_and_cache,
                         0 if we should not write to the binary log,
                         > 0 if we can write to the binlog.

               
  @note Depending on 'options', it may be very bad to write the
    query to the binlog (e.g. FLUSH SLAVE); this is a
    pointer where reload_acl_and_cache() will put 0 if
    it thinks we really should not write to the binlog.
    Otherwise it will put 1.

  @return Error status code
    @retval 0 Ok
    @retval !=0  Error; thd->killed is set or thd->is_error() is true
*/

bool reload_acl_and_cache(THD *thd, unsigned long long options,
                          TABLE_LIST *tables, int *write_to_binlog)
{
  bool result=0;
  select_errors=0;				/* Write if more errors */
  int tmp_write_to_binlog= *write_to_binlog= 1;

  DBUG_ASSERT(!thd || !thd->in_sub_stmt);

#ifndef NO_EMBEDDED_ACCESS_CHECKS
  if (options & REFRESH_GRANT)
  {
    THD *tmp_thd= 0;
    /*
      If reload_acl_and_cache() is called from SIGHUP handler we have to
      allocate temporary THD for execution of acl_reload()/grant_reload().
    */
    if (unlikely(!thd) && (thd= (tmp_thd= new THD(0))))
    {
      thd->thread_stack= (char*) &tmp_thd;
      thd->store_globals();
    }

    if (likely(thd))
    {
      bool reload_acl_failed= acl_reload(thd);
      bool reload_grants_failed= grant_reload(thd);
      bool reload_servers_failed= servers_reload(thd);

      if (reload_acl_failed || reload_grants_failed || reload_servers_failed)
      {
        result= 1;
        /*
          When an error is returned, my_message may have not been called and
          the client will hang waiting for a response.
        */
        my_error(ER_UNKNOWN_ERROR, MYF(0));
      }
    }
    opt_noacl= 0;

    if (unlikely(tmp_thd))
    {
      delete tmp_thd;
      thd= 0;
    }
    reset_mqh((LEX_USER *)NULL, TRUE);
  }
#endif
  if (options & REFRESH_LOG)
  {
    /*
      Flush the normal query log, the update log, the binary log,
      the slow query log, the relay log (if it exists) and the log
      tables.
    */

    options|= REFRESH_BINARY_LOG;
    options|= REFRESH_RELAY_LOG;
    options|= REFRESH_SLOW_LOG;
    options|= REFRESH_GENERAL_LOG;
    options|= REFRESH_ENGINE_LOG;
    options|= REFRESH_ERROR_LOG;
  }

  if (options & REFRESH_ERROR_LOG)
    if (unlikely(flush_error_log()))
      result= 1;

  if ((options & REFRESH_SLOW_LOG) && global_system_variables.sql_log_slow)
    logger.flush_slow_log();

  if ((options & REFRESH_GENERAL_LOG) && opt_log)
    logger.flush_general_log();

  if (options & REFRESH_ENGINE_LOG)
    if (ha_flush_logs())
      result= 1;

  if (options & REFRESH_BINARY_LOG)
  {
    /*
      Writing this command to the binlog may result in infinite loops
      when doing mysqlbinlog|mysql, and anyway it does not really make
      sense to log it automatically (would cause more trouble to users
      than it would help them)
    */
    tmp_write_to_binlog= 0;
    if (mysql_bin_log.is_open())
    {
      DYNAMIC_ARRAY *drop_gtid_domain=
        (thd && (thd->lex->delete_gtid_domain.elements > 0)) ?
        &thd->lex->delete_gtid_domain : NULL;
      if (mysql_bin_log.rotate_and_purge(true, drop_gtid_domain))
        *write_to_binlog= -1;

      /* Note that WSREP(thd) might not be true here e.g. during
      SST. */
      if (WSREP_ON)
      {
        /* Wait for last binlog checkpoint event to be logged. */
        mysql_bin_log.wait_for_last_checkpoint_event();
      }
    }
  }
  if (options & REFRESH_RELAY_LOG)
  {
#ifdef HAVE_REPLICATION
    LEX_CSTRING connection_name;
    Master_info *mi;
    if (thd)
      connection_name= thd->lex->relay_log_connection_name;
    else
    {
      connection_name.str= (char*) "";
      connection_name.length= 0;
    }

    /*
      Writing this command to the binlog may cause problems as the
      slave is not likely to have the same connection names.
    */
    tmp_write_to_binlog= 0;
    if (connection_name.length == 0)
    {
      if (master_info_index->flush_all_relay_logs())
          *write_to_binlog= -1;
    }
    else if (!(mi= (get_master_info(&connection_name,
                               Sql_condition::WARN_LEVEL_ERROR))))
    {
      result= 1;
    }
    else
    {
      mysql_mutex_lock(&mi->data_lock);
      if (rotate_relay_log(mi))
        *write_to_binlog= -1;
      mysql_mutex_unlock(&mi->data_lock);
      mi->release();
    }
#endif
  }
#ifdef HAVE_QUERY_CACHE
  if (options & REFRESH_QUERY_CACHE_FREE)
  {
    query_cache.pack(thd);              // FLUSH QUERY CACHE
    options &= ~REFRESH_QUERY_CACHE;    // Don't flush cache, just free memory
  }
  if (options & (REFRESH_TABLES | REFRESH_QUERY_CACHE))
  {
    query_cache.flush();			// RESET QUERY CACHE
  }
#endif /*HAVE_QUERY_CACHE*/

  DBUG_ASSERT(!thd || thd->locked_tables_mode ||
              !thd->mdl_context.has_locks() ||
              thd->handler_tables_hash.records ||
              thd->ull_hash.records ||
              thd->global_read_lock.is_acquired() ||
              thd->mdl_backup_lock ||
              thd->current_backup_stage != BACKUP_FINISHED
              );

  /*
    Note that if REFRESH_READ_LOCK bit is set then REFRESH_TABLES is set too
    (see sql_yacc.yy)
  */
  if (options & (REFRESH_TABLES | REFRESH_READ_LOCK)) 
  {
    if ((options & REFRESH_READ_LOCK) && thd)
    {
      DBUG_ASSERT(!(options & REFRESH_FAST) && !tables);
      /*
        On the first hand we need write lock on the tables to be flushed,
        on the other hand we must not try to aspire a global read lock
        if we have a write locked table as this would lead to a deadlock
        when trying to reopen (and re-lock) the table after the flush.
      */
      if (thd->locked_tables_mode)
      {
        my_error(ER_LOCK_OR_ACTIVE_TRANSACTION, MYF(0));
        return 1;
      }

      /*
	Writing to the binlog could cause deadlocks, as we don't log
	UNLOCK TABLES
      */
      tmp_write_to_binlog= 0;
      if (thd->global_read_lock.lock_global_read_lock(thd))
	return 1;                               // Killed
      if (flush_tables(thd, FLUSH_ALL))
      {
        /*
          NOTE: my_error() has been already called by reopen_tables() within
          close_cached_tables().
        */
        thd->global_read_lock.unlock_global_read_lock(thd);
        return 1;
      }

      if (thd->global_read_lock.make_global_read_lock_block_commit(thd)) // Killed
      {
        /* Don't leave things in a half-locked state */
        thd->global_read_lock.unlock_global_read_lock(thd);
        return 1;
      }
      if (options & REFRESH_CHECKPOINT)
        disable_checkpoints(thd);
      /*
        We need to do it second time after wsrep appliers were blocked in
        make_global_read_lock_block_commit(thd) above since they could have
        modified the tables too.
      */
      if (WSREP(thd) && flush_tables(thd, FLUSH_ALL))
        result= 1;
    }
    else
    {
      if (thd && thd->locked_tables_mode)
      {
        /*
          If we are under LOCK TABLES we should have a write
          lock on tables which we are going to flush.
        */
        if (tables)
        {
          int err;
          for (TABLE_LIST *t= tables; t; t= t->next_local)
            if (!find_table_for_mdl_upgrade(thd, t->db.str, t->table_name.str, &err))
            {
              if (is_locked_view(thd, t))
                t->next_local= t->next_global;
              else
              {
                my_error(err, MYF(0), t->table_name.str);
                return 1;
              }
            }
        }
        else
        {
          /*
            It is not safe to upgrade the metadata lock without GLOBAL IX lock.
            This can happen with FLUSH TABLES <list> WITH READ LOCK as we in
            these cases don't take a GLOBAL IX lock in order to be compatible
            with global read lock.
          */
          if (thd->open_tables &&
              !thd->mdl_context.is_lock_owner(MDL_key::BACKUP, "", "",
                                              MDL_BACKUP_DDL))
          {
            my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE, MYF(0),
                     thd->open_tables->s->table_name.str);
            return true;
          }

          for (TABLE *tab= thd->open_tables; tab; tab= tab->next)
          {
            if (! tab->mdl_ticket->is_upgradable_or_exclusive())
            {
              my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE, MYF(0),
                       tab->s->table_name.str);
              return 1;
            }
          }
        }
      }

#ifdef WITH_WSREP
      /* In case of applier thread, do not call flush tables */
      if (!thd || !thd->wsrep_applier)
#endif /* WITH_WSREP */
      {
        if (close_cached_tables(thd, tables,
                                ((options & REFRESH_FAST) ?  FALSE : TRUE),
                                (thd ? thd->variables.lock_wait_timeout :
                                 LONG_TIMEOUT)))
        {
          /*
            NOTE: my_error() has been already called by reopen_tables() within
            close_cached_tables().
          */
          result= 1;
        }
      }
    }
    my_dbopt_cleanup();
  }
  if (options & REFRESH_HOSTS)
    hostname_cache_refresh();
  if (thd && (options & REFRESH_STATUS))
    refresh_status(thd);
  if (options & REFRESH_THREADS)
    thread_cache.flush();
#ifdef HAVE_REPLICATION
  if (options & REFRESH_MASTER)
  {
    DBUG_ASSERT(thd);
    tmp_write_to_binlog= 0;
    if (reset_master(thd, NULL, 0, thd->lex->next_binlog_file_number))
    {
      /* NOTE: my_error() has been already called by reset_master(). */
      result= 1;
    }
  }
#endif
#ifdef HAVE_OPENSSL
   if (options & REFRESH_DES_KEY_FILE)
   {
     if (des_key_file && load_des_key_file(des_key_file))
     {
       /* NOTE: my_error() has been already called by load_des_key_file(). */
       result= 1;
     }
   }
#endif
#ifdef HAVE_REPLICATION
 if (options & REFRESH_SLAVE)
 {
   LEX_MASTER_INFO* lex_mi= &thd->lex->mi;
   Master_info *mi;
   tmp_write_to_binlog= 0;

   if (!(mi= get_master_info(&lex_mi->connection_name,
                             Sql_condition::WARN_LEVEL_ERROR)))
   {
     result= 1;
   }
   else
   {
     /* The following will fail if slave is running */
     if (reset_slave(thd, mi))
     {
       mi->release();
       /* NOTE: my_error() has been already called by reset_slave(). */
       result= 1;
     }
     else if (mi->connection_name.length && thd->lex->reset_slave_info.all)
     {
       /* If not default connection and 'all' is used */
       mi->release();
       mysql_mutex_lock(&LOCK_active_mi);
       if (master_info_index->remove_master_info(mi, 0))
         result= 1;
       mysql_mutex_unlock(&LOCK_active_mi);
     }
     else
       mi->release();
   }
 }
#endif
 if (options & REFRESH_USER_RESOURCES)
   reset_mqh((LEX_USER *) NULL, 0);             /* purecov: inspected */
 if (options & REFRESH_SSL)
 {
   if (reinit_ssl())
     result= 1;
#ifdef WITH_WSREP
   if (!result &&
       WSREP_ON && wsrep_reload_ssl())
   {
     my_message(ER_UNKNOWN_ERROR, "Failed to refresh WSREP SSL.", MYF(0));
     result= 1;
   }
#endif
 }
 if (options & REFRESH_GENERIC)
 {
   List_iterator_fast<LEX_CSTRING> li(thd->lex->view_list);
   LEX_CSTRING *ls;
   while ((ls= li++))
   {
     ST_SCHEMA_TABLE *table= find_schema_table(thd, ls);
     if (table->reset_table())
       result= 1;
   }
 }
 if (*write_to_binlog != -1)
   *write_to_binlog= tmp_write_to_binlog;
 /*
   If the query was killed then this function must fail.
 */
 return result || (thd ? thd->killed : 0);
}


/**
  Implementation of FLUSH TABLES <table_list> WITH READ LOCK
  and FLUSH TABLES <table_list> FOR EXPORT

  In brief: take exclusive locks, expel tables from the table
  cache, reopen the tables, enter the 'LOCKED TABLES' mode,
  downgrade the locks.
  Note: the function is written to be called from
  mysql_execute_command(), it is not reusable in arbitrary
  execution context.

  Required privileges
  -------------------
  Since the statement implicitly enters LOCK TABLES mode,
  it requires LOCK TABLES privilege on every table.
  But since the rest of FLUSH commands require
  the global RELOAD_ACL, it also requires RELOAD_ACL.

  Compatibility with the global read lock
  ---------------------------------------
  We don't wait for the GRL, since neither the
  5.1 combination that this new statement is intended to
  replace (LOCK TABLE <list> WRITE; FLUSH TABLES;),
  nor FLUSH TABLES WITH READ LOCK do.
  @todo: this is not implemented, Dmitry disagrees.
  Currently we wait for GRL in another connection,
  but are compatible with a GRL in our own connection.

  Behaviour under LOCK TABLES
  ---------------------------
  Bail out: i.e. don't perform an implicit UNLOCK TABLES.
  This is not consistent with LOCK TABLES statement, but is
  in line with behaviour of FLUSH TABLES WITH READ LOCK, and we
  try to not introduce any new statements with implicit
  semantics.

  Compatibility with parallel updates
  -----------------------------------
  As a result, we will wait for all open transactions
  against the tables to complete. After the lock downgrade,
  new transactions will be able to read the tables, but not
  write to them.

  Differences from FLUSH TABLES <list>
  -------------------------------------
  - you can't flush WITH READ LOCK a non-existent table
  - you can't flush WITH READ LOCK under LOCK TABLES

  Effect on views and temporary tables.
  ------------------------------------
  You can only apply this command to existing base tables.
  If a view with such name exists, ER_WRONG_OBJECT is returned.
  If a temporary table with such name exists, it's ignored:
  if there is a base table, it's used, otherwise ER_NO_SUCH_TABLE
  is returned.

  Handling of MERGE tables
  ------------------------
  For MERGE table this statement will open and lock child tables
  for read (it is impossible to lock parent table without it).
  Child tables won't be flushed unless they are explicitly present
  in the statement's table list.

  Implicit commit
  ---------------
  This statement causes an implicit commit before and
  after it.

  HANDLER SQL
  -----------
  If this connection has HANDLERs open against
  some of the tables being FLUSHed, these handlers
  are implicitly flushed (lose their position).
*/

bool flush_tables_with_read_lock(THD *thd, TABLE_LIST *all_tables)
{
  Lock_tables_prelocking_strategy lock_tables_prelocking_strategy;

  /*
    This is called from SQLCOM_FLUSH, the transaction has
    been committed implicitly.
  */

  if (thd->locked_tables_mode)
  {
    my_error(ER_LOCK_OR_ACTIVE_TRANSACTION, MYF(0));
    goto error;
  }

  if (thd->current_backup_stage != BACKUP_FINISHED)
  {
    my_error(ER_BACKUP_LOCK_IS_ACTIVE, MYF(0));
    goto error;
  }

  /* Should not flush tables while BACKUP LOCK is active */
  if (thd->mdl_backup_lock)
  {
    my_error(ER_LOCK_OR_ACTIVE_TRANSACTION, MYF(0));
    goto error;
  }

  if (thd->lex->type & REFRESH_READ_LOCK)
  {
    /*
      Acquire SNW locks on tables to be flushed. Don't acquire global
      IX and database-scope IX locks on the tables as this will make
      this statement incompatible with FLUSH TABLES WITH READ LOCK.
    */
    if (lock_table_names(thd, all_tables, NULL,
                         thd->variables.lock_wait_timeout,
                         MYSQL_OPEN_SKIP_SCOPED_MDL_LOCK))
      goto error;

    DEBUG_SYNC(thd,"flush_tables_with_read_lock_after_acquire_locks");

    /* Reset ticket to satisfy asserts in open_tables(). */
    for (auto table_list= all_tables; table_list;
         table_list= table_list->next_global)
      table_list->mdl_request.ticket= NULL;
  }

  thd->variables.option_bits|= OPTION_TABLE_LOCK;

  /*
    Before opening and locking tables the below call also waits
    for old shares to go away, so the fact that we don't pass
    MYSQL_OPEN_IGNORE_FLUSH flag to it is important.
    Also we don't pass MYSQL_OPEN_HAS_MDL_LOCK flag as we want
    to open underlying tables if merge table is flushed.
    For underlying tables of the merge the below call has to
    acquire SNW locks to ensure that they can be locked for
    read without further waiting.
  */
  if (open_and_lock_tables(thd, all_tables, FALSE,
                           MYSQL_OPEN_SKIP_SCOPED_MDL_LOCK,
                           &lock_tables_prelocking_strategy))
    goto error_reset_bits;

  if (thd->lex->type & (REFRESH_FOR_EXPORT|REFRESH_READ_LOCK))
  {
    for (TABLE_LIST *table_list= all_tables; table_list;
         table_list= table_list->next_global)
    {
      if (table_list->belong_to_view &&
          check_single_table_access(thd, PRIV_LOCK_TABLES, table_list, FALSE))
      {
        table_list->hide_view_error(thd);
        goto error_reset_bits;
      }
      if (table_list->is_view_or_derived())
        continue;
      if (thd->lex->type & REFRESH_FOR_EXPORT &&
          table_list->table &&
          !(table_list->table->file->ha_table_flags() & HA_CAN_EXPORT))
      {
        my_error(ER_ILLEGAL_HA, MYF(0),table_list->table->file->table_type(),
                 table_list->db.str, table_list->table_name.str);
        goto error_reset_bits;
      }
      if (thd->lex->type & REFRESH_READ_LOCK &&
          table_list->table &&
          table_list->table->file->extra(HA_EXTRA_FLUSH))
        goto error_reset_bits;
    }
  }

  if (thd->locked_tables_list.init_locked_tables(thd))
    goto error_reset_bits;


  /*
    We don't downgrade MDL_SHARED_NO_WRITE here as the intended
    post effect of this call is identical to LOCK TABLES <...> READ,
    and we didn't use thd->in_lock_talbes and
    thd->sql_command= SQLCOM_LOCK_TABLES hacks to enter the LTM.
  */

  return FALSE;

error_reset_bits:
  trans_rollback_stmt(thd);
  close_thread_tables(thd);
  thd->variables.option_bits&= ~OPTION_TABLE_LOCK;
error:
  return TRUE;
}


/**
   Disable checkpoints for all handlers
   This is released in unlock_global_read_lock()
*/

static void disable_checkpoints(THD *thd)
{
  if (!thd->global_disable_checkpoint)
  {
    thd->global_disable_checkpoint= 1;
    if (!global_disable_checkpoint++)
      ha_checkpoint_state(1);                   // Disable checkpoints
  }
}