1
/*****************************************************************************
3
Copyright (C) 1996, 2010, Innobase Oy. All Rights Reserved.
5
This program is free software; you can redistribute it and/or modify it under
6
the terms of the GNU General Public License as published by the Free Software
7
Foundation; version 2 of the License.
9
This program is distributed in the hope that it will be useful, but WITHOUT
10
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
13
You should have received a copy of the GNU General Public License along with
14
this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
15
St, Fifth Floor, Boston, MA 02110-1301 USA
17
*****************************************************************************/
19
/**************************************************//**
20
@file lock/lock0lock.c
21
The transaction lock system
23
Created 5/7/1996 Heikki Tuuri
24
*******************************************************/
26
#define LOCK_MODULE_IMPLEMENTATION
28
#include "lock0lock.h"
29
#include "lock0priv.h"
32
#include "lock0lock.ic"
33
#include "lock0priv.ic"
36
#include "ha_prototypes.h"
38
#include "trx0purge.h"
42
/* Restricts the length of search we will do in the waits-for
43
graph of transactions */
44
#define LOCK_MAX_N_STEPS_IN_DEADLOCK_CHECK 1000000
46
/* Restricts the recursion depth of the search we will do in the waits-for
47
graph of transactions */
48
#define LOCK_MAX_DEPTH_IN_DEADLOCK_CHECK 200
50
/* When releasing transaction locks, this specifies how often we release
51
the kernel mutex for a moment to give also others access to it */
53
#define LOCK_RELEASE_KERNEL_INTERVAL 1000
55
/* Safety margin when creating a new record lock: this many extra records
56
can be inserted to the page without need to create a lock with a bigger
59
#define LOCK_PAGE_BITMAP_MARGIN 64
61
/* An explicit record lock affects both the record and the gap before it.
62
An implicit x-lock does not affect the gap, it only locks the index
63
record from read or update.
65
If a transaction has modified or inserted an index record, then
66
it owns an implicit x-lock on the record. On a secondary index record,
67
a transaction has an implicit x-lock also if it has modified the
68
clustered index record, the max trx id of the page where the secondary
69
index record resides is >= trx id of the transaction (or database recovery
70
is running), and there are no explicit non-gap lock requests on the
71
secondary index record.
73
This complicated definition for a secondary index comes from the
74
implementation: we want to be able to determine if a secondary index
75
record has an implicit x-lock, just by looking at the present clustered
76
index record, not at the historical versions of the record. The
77
complicated definition can be explained to the user so that there is
78
nondeterminism in the access path when a query is answered: we may,
79
or may not, access the clustered index record and thus may, or may not,
80
bump into an x-lock set there.
82
Different transaction can have conflicting locks set on the gap at the
83
same time. The locks on the gap are purely inhibitive: an insert cannot
84
be made, or a select cursor may have to wait if a different transaction
85
has a conflicting lock on the gap. An x-lock on the gap does not give
86
the right to insert into the gap.
88
An explicit lock can be placed on a user record or the supremum record of
89
a page. The locks on the supremum record are always thought to be of the gap
90
type, though the gap bit is not set. When we perform an update of a record
91
where the size of the record changes, we may temporarily store its explicit
92
locks on the infimum record of the page, though the infimum otherwise never
95
A waiting record lock can also be of the gap type. A waiting lock request
96
can be granted when there is no conflicting mode lock request by another
97
transaction ahead of it in the explicit lock queue.
99
In version 4.0.5 we added yet another explicit lock type: LOCK_REC_NOT_GAP.
100
It only locks the record it is placed on, not the gap before the record.
101
This lock type is necessary to emulate an Oracle-like READ COMMITTED isolation
104
-------------------------------------------------------------------------
105
RULE 1: If there is an implicit x-lock on a record, and there are non-gap
107
lock requests waiting in the queue, then the transaction holding the implicit
108
x-lock also has an explicit non-gap record x-lock. Therefore, as locks are
109
released, we can grant locks to waiting lock requests purely by looking at
110
the explicit lock requests in the queue.
112
RULE 3: Different transactions cannot have conflicting granted non-gap locks
114
on a record at the same time. However, they can have conflicting granted gap
116
RULE 4: If a there is a waiting lock request in a queue, no lock request,
118
gap or not, can be inserted ahead of it in the queue. In record deletes
119
and page splits new gap type locks can be created by the database manager
120
for a transaction, and without rule 4, the waits-for graph of transactions
121
might become cyclic without the database noticing it, as the deadlock check
122
is only performed when a transaction itself requests a lock!
123
-------------------------------------------------------------------------
125
An insert is allowed to a gap if there are no explicit lock requests by
126
other transactions on the next record. It does not matter if these lock
127
requests are granted or waiting, gap bit set or not, with the exception
128
that a gap type request set by another transaction to wait for
129
its turn to do an insert is ignored. On the other hand, an
130
implicit x-lock by another transaction does not prevent an insert, which
131
allows for more concurrency when using an Oracle-style sequence number
132
generator for the primary key with many transactions doing inserts
135
A modify of a record is allowed if the transaction has an x-lock on the
136
record, or if other transactions do not have any non-gap lock requests on the
139
A read of a single user record with a cursor is allowed if the transaction
140
has a non-gap explicit, or an implicit lock on the record, or if the other
141
transactions have no x-lock requests on the record. At a page supremum a
142
read is always allowed.
144
In summary, an implicit lock is seen as a granted x-lock only on the
145
record, not on the gap. An explicit lock with no gap bit set is a lock
146
both on the record and the gap. If the gap bit is set, the lock is only
147
on the gap. Different transaction cannot own conflicting locks on the
148
record at the same time, but they may own conflicting locks on the gap.
149
Granted locks on a record give an access right to the record, but gap type
150
locks just inhibit operations.
152
NOTE: Finding out if some transaction has an implicit x-lock on a secondary
153
index record can be cumbersome. We may have to look at previous versions of
154
the corresponding clustered index record to find out if a delete marked
155
secondary index record was delete marked by an active transaction, not by
158
FACT A: If a transaction has inserted a row, it can delete it any time
159
without need to wait for locks.
161
PROOF: The transaction has an implicit x-lock on every index record inserted
162
for the row, and can thus modify each record without the need to wait. Q.E.D.
164
FACT B: If a transaction has read some result set with a cursor, it can read
165
it again, and retrieves the same result set, if it has not modified the
166
result set in the meantime. Hence, there is no phantom problem. If the
167
biggest record, in the alphabetical order, touched by the cursor is removed,
168
a lock wait may occur, otherwise not.
170
PROOF: When a read cursor proceeds, it sets an s-lock on each user record
171
it passes, and a gap type s-lock on each page supremum. The cursor must
172
wait until it has these locks granted. Then no other transaction can
173
have a granted x-lock on any of the user records, and therefore cannot
174
modify the user records. Neither can any other transaction insert into
175
the gaps which were passed over by the cursor. Page splits and merges,
176
and removal of obsolete versions of records do not affect this, because
177
when a user record or a page supremum is removed, the next record inherits
178
its locks as gap type locks, and therefore blocks inserts to the same gap.
179
Also, if a page supremum is inserted, it inherits its locks from the successor
180
record. When the cursor is positioned again at the start of the result set,
181
the records it will touch on its course are either records it touched
182
during the last pass or new inserted page supremums. It can immediately
183
access all these records, and when it arrives at the biggest record, it
184
notices that the result set is complete. If the biggest record was removed,
185
lock wait can occur because the next record only inherits a gap type lock,
186
and a wait may be needed. Q.E.D. */
188
/* If an index record should be changed or a new inserted, we must check
189
the lock on the record or the next. When a read cursor starts reading,
190
we will set a record level s-lock on each record it passes, except on the
191
initial record on which the cursor is positioned before we start to fetch
192
records. Our index tree search has the convention that the B-tree
193
cursor is positioned BEFORE the first possibly matching record in
194
the search. Optimizations are possible here: if the record is searched
195
on an equality condition to a unique key, we could actually set a special
196
lock on the record, a lock which would not prevent any insert before
197
this record. In the next key locking an x-lock set on a record also
198
prevents inserts just before that record.
199
There are special infimum and supremum records on each page.
200
A supremum record can be locked by a read cursor. This records cannot be
201
updated but the lock prevents insert of a user record to the end of
203
Next key locks will prevent the phantom problem where new rows
204
could appear to SELECT result sets after the select operation has been
205
performed. Prevention of phantoms ensures the serilizability of
207
What should we check if an insert of a new record is wanted?
208
Only the lock on the next record on the same page, because also the
209
supremum record can carry a lock. An s-lock prevents insertion, but
210
what about an x-lock? If it was set by a searched update, then there
211
is implicitly an s-lock, too, and the insert should be prevented.
212
What if our transaction owns an x-lock to the next record, but there is
213
a waiting s-lock request on the next record? If this s-lock was placed
214
by a read cursor moving in the ascending order in the index, we cannot
215
do the insert immediately, because when we finally commit our transaction,
216
the read cursor should see also the new inserted record. So we should
217
move the read cursor backward from the the next record for it to pass over
218
the new inserted record. This move backward may be too cumbersome to
219
implement. If we in this situation just enqueue a second x-lock request
220
for our transaction on the next record, then the deadlock mechanism
221
notices a deadlock between our transaction and the s-lock request
222
transaction. This seems to be an ok solution.
223
We could have the convention that granted explicit record locks,
224
lock the corresponding records from changing, and also lock the gaps
225
before them from inserting. A waiting explicit lock request locks the gap
226
before from inserting. Implicit record x-locks, which we derive from the
227
transaction id in the clustered index record, only lock the record itself
228
from modification, not the gap before it from inserting.
229
How should we store update locks? If the search is done by a unique
230
key, we could just modify the record trx id. Otherwise, we could put a record
231
x-lock on the record. If the update changes ordering fields of the
232
clustered index record, the inserted new record needs no record lock in
233
lock table, the trx id is enough. The same holds for a secondary index
234
record. Searched delete is similar to update.
237
What about waiting lock requests? If a transaction is waiting to make an
238
update to a record which another modified, how does the other transaction
239
know to send the end-lock-wait signal to the waiting transaction? If we have
240
the convention that a transaction may wait for just one lock at a time, how
241
do we preserve it if lock wait ends?
244
Checking the trx id label of a secondary index record. In the case of a
245
modification, not an insert, is this necessary? A secondary index record
246
is modified only by setting or resetting its deleted flag. A secondary index
247
record contains fields to uniquely determine the corresponding clustered
248
index record. A secondary index record is therefore only modified if we
249
also modify the clustered index record, and the trx id checking is done
250
on the clustered index record, before we come to modify the secondary index
251
record. So, in the case of delete marking or unmarking a secondary index
252
record, we do not have to care about trx ids, only the locks in the lock
253
table must be checked. In the case of a select from a secondary index, the
254
trx id is relevant, and in this case we may have to search the clustered
257
PROBLEM: How to update record locks when page is split or merged, or
258
--------------------------------------------------------------------
259
a record is deleted or updated?
260
If the size of fields in a record changes, we perform the update by
261
a delete followed by an insert. How can we retain the locks set or
262
waiting on the record? Because a record lock is indexed in the bitmap
263
by the heap number of the record, when we remove the record from the
264
record list, it is possible still to keep the lock bits. If the page
265
is reorganized, we could make a table of old and new heap numbers,
266
and permute the bitmaps in the locks accordingly. We can add to the
267
table a row telling where the updated record ended. If the update does
268
not require a reorganization of the page, we can simply move the lock
269
bits for the updated record to the position determined by its new heap
270
number (we may have to allocate a new lock, if we run out of the bitmap
272
A more complicated case is the one where the reinsertion of the
273
updated record is done pessimistically, because the structure of the
276
PROBLEM: If a supremum record is removed in a page merge, or a record
277
---------------------------------------------------------------------
278
removed in a purge, what to do to the waiting lock requests? In a split to
279
the right, we just move the lock requests to the new supremum. If a record
280
is removed, we could move the waiting lock request to its inheritor, the
281
next record in the index. But, the next record may already have lock
282
requests on its own queue. A new deadlock check should be made then. Maybe
283
it is easier just to release the waiting transactions. They can then enqueue
284
new lock requests on appropriate records.
286
PROBLEM: When a record is inserted, what locks should it inherit from the
287
-------------------------------------------------------------------------
288
upper neighbor? An insert of a new supremum record in a page split is
289
always possible, but an insert of a new user record requires that the upper
290
neighbor does not have any lock requests by other transactions, granted or
291
waiting, in its lock queue. Solution: We can copy the locks as gap type
292
locks, so that also the waiting locks are transformed to granted gap type
293
locks on the inserted record. */
295
/* LOCK COMPATIBILITY MATRIX
303
* Note that for rows, InnoDB only acquires S or X locks.
304
* For tables, InnoDB normally acquires IS or IX locks.
305
* S or X table locks are only acquired for LOCK TABLES.
306
* Auto-increment (AI) locks are needed because of
307
* statement-level MySQL binlog.
308
* See also lock_mode_compatible().
310
#define LK(a,b) (1 << ((a) * LOCK_NUM + (b)))
311
#define LKS(a,b) LK(a,b) | LK(b,a)
313
/* Define the lock compatibility matrix in a ulint. The first line below
314
defines the diagonal entries. The following lines define the compatibility
315
for LOCK_IX, LOCK_S, and LOCK_AUTO_INC using LKS(), since the matrix
317
#define LOCK_MODE_COMPATIBILITY 0 \
318
| LK(LOCK_IS, LOCK_IS) | LK(LOCK_IX, LOCK_IX) | LK(LOCK_S, LOCK_S) \
319
| LKS(LOCK_IX, LOCK_IS) | LKS(LOCK_IS, LOCK_AUTO_INC) \
320
| LKS(LOCK_S, LOCK_IS) \
321
| LKS(LOCK_AUTO_INC, LOCK_IS) | LKS(LOCK_AUTO_INC, LOCK_IX)
323
/* STRONGER-OR-EQUAL RELATION (mode1=row, mode2=column)
330
* See lock_mode_stronger_or_eq().
333
/* Define the stronger-or-equal lock relation in a ulint. This relation
334
contains all pairs LK(mode1, mode2) where mode1 is stronger than or
336
#define LOCK_MODE_STRONGER_OR_EQ 0 \
337
| LK(LOCK_IS, LOCK_IS) \
338
| LK(LOCK_IX, LOCK_IS) | LK(LOCK_IX, LOCK_IX) \
339
| LK(LOCK_S, LOCK_IS) | LK(LOCK_S, LOCK_S) \
340
| LK(LOCK_AUTO_INC, LOCK_AUTO_INC) \
341
| LK(LOCK_X, LOCK_IS) | LK(LOCK_X, LOCK_IX) | LK(LOCK_X, LOCK_S) \
342
| LK(LOCK_X, LOCK_AUTO_INC) | LK(LOCK_X, LOCK_X)
345
UNIV_INTERN ibool lock_print_waits = FALSE;
347
/*********************************************************************//**
348
Validates the lock system.
349
@return TRUE if ok */
355
/*********************************************************************//**
356
Validates the record lock queues on a page.
357
@return TRUE if ok */
360
lock_rec_validate_page(
361
/*===================*/
362
ulint space, /*!< in: space id */
363
ulint page_no);/*!< in: page number */
364
#endif /* UNIV_DEBUG */
366
/* The lock system */
367
UNIV_INTERN lock_sys_t* lock_sys = NULL;
369
/* We store info on the latest deadlock error to this buffer. InnoDB
370
Monitor will then fetch it and print */
371
UNIV_INTERN ibool lock_deadlock_found = FALSE;
372
UNIV_INTERN FILE* lock_latest_err_file;
374
/* Flags for recursive deadlock search */
375
#define LOCK_VICTIM_IS_START 1
376
#define LOCK_VICTIM_IS_OTHER 2
377
#define LOCK_EXCEED_MAX_DEPTH 3
379
/********************************************************************//**
380
Checks if a lock request results in a deadlock.
381
@return TRUE if a deadlock was detected and we chose trx as a victim;
382
FALSE if no deadlock, or there was a deadlock, but we chose other
383
transaction(s) as victim(s) */
386
lock_deadlock_occurs(
387
/*=================*/
388
lock_t* lock, /*!< in: lock the transaction is requesting */
389
trx_t* trx); /*!< in: transaction */
390
/********************************************************************//**
391
Looks recursively for a deadlock.
392
@return 0 if no deadlock found, LOCK_VICTIM_IS_START if there was a
393
deadlock and we chose 'start' as the victim, LOCK_VICTIM_IS_OTHER if a
394
deadlock was found and we chose some other trx as a victim: we must do
395
the search again in this last case because there may be another
397
LOCK_EXCEED_MAX_DEPTH if the lock search exceeds max steps or max depth. */
400
lock_deadlock_recursive(
401
/*====================*/
402
trx_t* start, /*!< in: recursion starting point */
403
trx_t* trx, /*!< in: a transaction waiting for a lock */
404
lock_t* wait_lock, /*!< in: lock that is waiting to be granted */
405
ulint* cost, /*!< in/out: number of calculation steps thus
406
far: if this exceeds LOCK_MAX_N_STEPS_...
407
we return LOCK_EXCEED_MAX_DEPTH */
408
ulint depth); /*!< in: recursion depth: if this exceeds
409
LOCK_MAX_DEPTH_IN_DEADLOCK_CHECK, we
410
return LOCK_EXCEED_MAX_DEPTH */
412
/*********************************************************************//**
413
Gets the nth bit of a record lock.
414
@return TRUE if bit set also if i == ULINT_UNDEFINED return FALSE*/
417
lock_rec_get_nth_bit(
418
/*=================*/
419
const lock_t* lock, /*!< in: record lock */
420
ulint i) /*!< in: index of the bit */
426
ut_ad(lock_get_type_low(lock) == LOCK_REC);
428
if (i >= lock->un_member.rec_lock.n_bits) {
436
return(1 & ((const byte*) &lock[1])[byte_index] >> bit_index);
439
/*************************************************************************/
441
#define lock_mutex_enter_kernel() mutex_enter(&kernel_mutex)
442
#define lock_mutex_exit_kernel() mutex_exit(&kernel_mutex)
444
/*********************************************************************//**
445
Checks that a transaction id is sensible, i.e., not in the future.
446
@return TRUE if ok */
449
lock_check_trx_id_sanity(
450
/*=====================*/
451
trx_id_t trx_id, /*!< in: trx id */
452
const rec_t* rec, /*!< in: user record */
453
dict_index_t* index, /*!< in: index */
454
const ulint* offsets, /*!< in: rec_get_offsets(rec, index) */
455
ibool has_kernel_mutex)/*!< in: TRUE if the caller owns the
460
ut_ad(rec_offs_validate(rec, index, offsets));
462
if (!has_kernel_mutex) {
463
mutex_enter(&kernel_mutex);
466
/* A sanity check: the trx_id in rec must be smaller than the global
469
if (UNIV_UNLIKELY(trx_id >= trx_sys->max_trx_id)) {
470
ut_print_timestamp(stderr);
471
fputs(" InnoDB: Error: transaction id associated"
474
rec_print_new(stderr, rec, offsets);
475
fputs("InnoDB: in ", stderr);
476
dict_index_name_print(stderr, NULL, index);
478
"InnoDB: is " TRX_ID_FMT " which is higher than the"
479
" global trx id counter " TRX_ID_FMT "!\n"
480
"InnoDB: The table is corrupt. You have to do"
481
" dump + drop + reimport.\n",
482
trx_id, trx_sys->max_trx_id);
487
if (!has_kernel_mutex) {
488
mutex_exit(&kernel_mutex);
494
/*********************************************************************//**
495
Checks that a record is seen in a consistent read.
496
@return TRUE if sees, or FALSE if an earlier version of the record
497
should be retrieved */
500
lock_clust_rec_cons_read_sees(
501
/*==========================*/
502
const rec_t* rec, /*!< in: user record which should be read or
503
passed over by a read cursor */
504
dict_index_t* index, /*!< in: clustered index */
505
const ulint* offsets,/*!< in: rec_get_offsets(rec, index) */
506
read_view_t* view) /*!< in: consistent read view */
510
ut_ad(dict_index_is_clust(index));
511
ut_ad(page_rec_is_user_rec(rec));
512
ut_ad(rec_offs_validate(rec, index, offsets));
514
/* NOTE that we call this function while holding the search
515
system latch. To obey the latching order we must NOT reserve the
516
kernel mutex here! */
518
trx_id = row_get_rec_trx_id(rec, index, offsets);
520
return(read_view_sees_trx_id(view, trx_id));
523
/*********************************************************************//**
524
Checks that a non-clustered index record is seen in a consistent read.
526
NOTE that a non-clustered index page contains so little information on
527
its modifications that also in the case FALSE, the present version of
528
rec may be the right, but we must check this from the clustered index
531
@return TRUE if certainly sees, or FALSE if an earlier version of the
532
clustered index record might be needed */
535
lock_sec_rec_cons_read_sees(
536
/*========================*/
537
const rec_t* rec, /*!< in: user record which
538
should be read or passed over
540
const read_view_t* view) /*!< in: consistent read view */
544
ut_ad(page_rec_is_user_rec(rec));
546
/* NOTE that we might call this function while holding the search
547
system latch. To obey the latching order we must NOT reserve the
548
kernel mutex here! */
550
if (recv_recovery_is_on()) {
555
max_trx_id = page_get_max_trx_id(page_align(rec));
558
return(max_trx_id < view->up_limit_id);
561
/*********************************************************************//**
562
Creates the lock system at database start. */
567
ulint n_cells) /*!< in: number of slots in lock hash table */
569
lock_sys = static_cast<lock_sys_t *>(mem_alloc(sizeof(lock_sys_t)));
571
lock_sys->rec_hash = hash_create(n_cells);
573
/* hash_create_mutexes(lock_sys->rec_hash, 2, SYNC_REC_LOCK); */
575
lock_latest_err_file = os_file_create_tmpfile();
576
ut_a(lock_latest_err_file);
579
/*********************************************************************//**
580
Closes the lock system at database shutdown. */
586
if (lock_latest_err_file != NULL) {
587
fclose(lock_latest_err_file);
588
lock_latest_err_file = NULL;
591
hash_table_free(lock_sys->rec_hash);
596
/*********************************************************************//**
597
Gets the size of a lock struct.
598
@return size in bytes */
604
return((ulint)sizeof(lock_t));
607
/*********************************************************************//**
608
Gets the mode of a lock.
614
const lock_t* lock) /*!< in: lock */
618
return static_cast<lock_mode>(lock->type_mode & LOCK_MODE_MASK);
621
/*********************************************************************//**
622
Gets the wait flag of a lock.
623
@return TRUE if waiting */
628
const lock_t* lock) /*!< in: lock */
632
if (UNIV_UNLIKELY(lock->type_mode & LOCK_WAIT)) {
640
/*********************************************************************//**
641
Gets the source table of an ALTER TABLE transaction. The table must be
642
covered by an IX or IS table lock.
643
@return the source table of transaction, if it is covered by an IX or
644
IS table lock; dest if there is no source table, and NULL if the
645
transaction is locking more than two tables or an inconsistency is
651
trx_t* trx, /*!< in: transaction */
652
dict_table_t* dest, /*!< in: destination of ALTER TABLE */
653
enum lock_mode* mode) /*!< out: lock mode of the source table */
661
for (lock = UT_LIST_GET_FIRST(trx->trx_locks);
663
lock = UT_LIST_GET_NEXT(trx_locks, lock)) {
664
lock_table_t* tab_lock;
665
enum lock_mode lock_mode;
666
if (!(lock_get_type_low(lock) & LOCK_TABLE)) {
667
/* We are only interested in table locks. */
670
tab_lock = &lock->un_member.tab_lock;
671
if (dest == tab_lock->table) {
672
/* We are not interested in the destination table. */
675
/* This presumably is the source table. */
676
src = tab_lock->table;
677
if (UT_LIST_GET_LEN(src->locks) != 1
678
|| UT_LIST_GET_FIRST(src->locks) != lock) {
679
/* We only support the case when
680
there is only one lock on this table. */
683
} else if (src != tab_lock->table) {
684
/* The transaction is locking more than
685
two tables (src and dest): abort */
689
/* Check that the source table is locked by
690
LOCK_IX or LOCK_IS. */
691
lock_mode = lock_get_mode(lock);
692
if (lock_mode == LOCK_IX || lock_mode == LOCK_IS) {
693
if (*mode != LOCK_NONE && *mode != lock_mode) {
694
/* There are multiple locks on src. */
702
/* No source table lock found: flag the situation to caller */
709
/*********************************************************************//**
710
Determine if the given table is exclusively "owned" by the given
711
transaction, i.e., transaction holds LOCK_IX and possibly LOCK_AUTO_INC
713
@return TRUE if table is only locked by trx, with LOCK_IX, and
714
possibly LOCK_AUTO_INC */
717
lock_is_table_exclusive(
718
/*====================*/
719
dict_table_t* table, /*!< in: table */
720
trx_t* trx) /*!< in: transaction */
728
lock_mutex_enter_kernel();
730
for (lock = UT_LIST_GET_FIRST(table->locks);
732
lock = UT_LIST_GET_NEXT(locks, &lock->un_member.tab_lock)) {
733
if (lock->trx != trx) {
734
/* A lock on the table is held
735
by some other transaction. */
739
if (!(lock_get_type_low(lock) & LOCK_TABLE)) {
740
/* We are interested in table locks only. */
744
switch (lock_get_mode(lock)) {
749
/* It is allowed for trx to hold an
750
auto_increment lock. */
754
/* Other table locks than LOCK_IX are not allowed. */
761
lock_mutex_exit_kernel();
766
/*********************************************************************//**
767
Sets the wait flag of a lock and the back pointer in trx to lock. */
770
lock_set_lock_and_trx_wait(
771
/*=======================*/
772
lock_t* lock, /*!< in: lock */
773
trx_t* trx) /*!< in: trx */
776
ut_ad(trx->wait_lock == NULL);
778
trx->wait_lock = lock;
779
lock->type_mode |= LOCK_WAIT;
782
/**********************************************************************//**
783
The back pointer to a waiting lock request in the transaction is set to NULL
784
and the wait bit in lock type_mode is reset. */
787
lock_reset_lock_and_trx_wait(
788
/*=========================*/
789
lock_t* lock) /*!< in: record lock */
791
ut_ad((lock->trx)->wait_lock == lock);
792
ut_ad(lock_get_wait(lock));
794
/* Reset the back pointer in trx to this waiting lock request */
796
(lock->trx)->wait_lock = NULL;
797
lock->type_mode &= ~LOCK_WAIT;
800
/*********************************************************************//**
801
Gets the gap flag of a record lock.
802
@return TRUE if gap flag set */
807
const lock_t* lock) /*!< in: record lock */
810
ut_ad(lock_get_type_low(lock) == LOCK_REC);
812
if (lock->type_mode & LOCK_GAP) {
820
/*********************************************************************//**
821
Gets the LOCK_REC_NOT_GAP flag of a record lock.
822
@return TRUE if LOCK_REC_NOT_GAP flag set */
825
lock_rec_get_rec_not_gap(
826
/*=====================*/
827
const lock_t* lock) /*!< in: record lock */
830
ut_ad(lock_get_type_low(lock) == LOCK_REC);
832
if (lock->type_mode & LOCK_REC_NOT_GAP) {
840
/*********************************************************************//**
841
Gets the waiting insert flag of a record lock.
842
@return TRUE if gap flag set */
845
lock_rec_get_insert_intention(
846
/*==========================*/
847
const lock_t* lock) /*!< in: record lock */
850
ut_ad(lock_get_type_low(lock) == LOCK_REC);
852
if (lock->type_mode & LOCK_INSERT_INTENTION) {
860
/*********************************************************************//**
861
Calculates if lock mode 1 is stronger or equal to lock mode 2.
862
@return nonzero if mode1 stronger or equal to mode2 */
865
lock_mode_stronger_or_eq(
866
/*=====================*/
867
enum lock_mode mode1, /*!< in: lock mode */
868
enum lock_mode mode2) /*!< in: lock mode */
870
ut_ad(mode1 == LOCK_X || mode1 == LOCK_S || mode1 == LOCK_IX
871
|| mode1 == LOCK_IS || mode1 == LOCK_AUTO_INC);
872
ut_ad(mode2 == LOCK_X || mode2 == LOCK_S || mode2 == LOCK_IX
873
|| mode2 == LOCK_IS || mode2 == LOCK_AUTO_INC);
875
return((LOCK_MODE_STRONGER_OR_EQ) & LK(mode1, mode2));
878
/*********************************************************************//**
879
Calculates if lock mode 1 is compatible with lock mode 2.
880
@return nonzero if mode1 compatible with mode2 */
883
lock_mode_compatible(
884
/*=================*/
885
enum lock_mode mode1, /*!< in: lock mode */
886
enum lock_mode mode2) /*!< in: lock mode */
888
ut_ad(mode1 == LOCK_X || mode1 == LOCK_S || mode1 == LOCK_IX
889
|| mode1 == LOCK_IS || mode1 == LOCK_AUTO_INC);
890
ut_ad(mode2 == LOCK_X || mode2 == LOCK_S || mode2 == LOCK_IX
891
|| mode2 == LOCK_IS || mode2 == LOCK_AUTO_INC);
893
return((LOCK_MODE_COMPATIBILITY) & LK(mode1, mode2));
896
/*********************************************************************//**
897
Checks if a lock request for a new lock has to wait for request lock2.
898
@return TRUE if new lock has to wait for lock2 to be removed */
901
lock_rec_has_to_wait(
902
/*=================*/
903
const trx_t* trx, /*!< in: trx of new lock */
904
ulint type_mode,/*!< in: precise mode of the new lock
905
to set: LOCK_S or LOCK_X, possibly
906
ORed to LOCK_GAP or LOCK_REC_NOT_GAP,
907
LOCK_INSERT_INTENTION */
908
const lock_t* lock2, /*!< in: another record lock; NOTE that
909
it is assumed that this has a lock bit
910
set on the same record as in the new
911
lock we are setting */
912
ibool lock_is_on_supremum) /*!< in: TRUE if we are setting the
913
lock on the 'supremum' record of an
914
index page: we know then that the lock
915
request is really for a 'gap' type lock */
918
ut_ad(lock_get_type_low(lock2) == LOCK_REC);
920
if (trx != lock2->trx
921
&& !lock_mode_compatible(static_cast<lock_mode>(LOCK_MODE_MASK & type_mode),
922
lock_get_mode(lock2))) {
924
/* We have somewhat complex rules when gap type record locks
927
if ((lock_is_on_supremum || (type_mode & LOCK_GAP))
928
&& !(type_mode & LOCK_INSERT_INTENTION)) {
930
/* Gap type locks without LOCK_INSERT_INTENTION flag
931
do not need to wait for anything. This is because
932
different users can have conflicting lock types
938
if (!(type_mode & LOCK_INSERT_INTENTION)
939
&& lock_rec_get_gap(lock2)) {
941
/* Record lock (LOCK_ORDINARY or LOCK_REC_NOT_GAP
942
does not need to wait for a gap type lock */
947
if ((type_mode & LOCK_GAP)
948
&& lock_rec_get_rec_not_gap(lock2)) {
950
/* Lock on gap does not need to wait for
951
a LOCK_REC_NOT_GAP type lock */
956
if (lock_rec_get_insert_intention(lock2)) {
958
/* No lock request needs to wait for an insert
959
intention lock to be removed. This is ok since our
960
rules allow conflicting locks on gaps. This eliminates
961
a spurious deadlock caused by a next-key lock waiting
962
for an insert intention lock; when the insert
963
intention lock was granted, the insert deadlocked on
964
the waiting next-key lock.
966
Also, insert intention locks do not disturb each
978
/*********************************************************************//**
979
Checks if a lock request lock1 has to wait for request lock2.
980
@return TRUE if lock1 has to wait for lock2 to be removed */
985
const lock_t* lock1, /*!< in: waiting lock */
986
const lock_t* lock2) /*!< in: another lock; NOTE that it is
987
assumed that this has a lock bit set
988
on the same record as in lock1 if the
989
locks are record locks */
991
ut_ad(lock1 && lock2);
993
if (lock1->trx != lock2->trx
994
&& !lock_mode_compatible(lock_get_mode(lock1),
995
lock_get_mode(lock2))) {
996
if (lock_get_type_low(lock1) == LOCK_REC) {
997
ut_ad(lock_get_type_low(lock2) == LOCK_REC);
999
/* If this lock request is for a supremum record
1000
then the second bit on the lock bitmap is set */
1002
return(lock_rec_has_to_wait(lock1->trx,
1003
lock1->type_mode, lock2,
1004
lock_rec_get_nth_bit(
1014
/*============== RECORD LOCK BASIC FUNCTIONS ============================*/
1016
/*********************************************************************//**
1017
Gets the number of bits in a record lock bitmap.
1018
@return number of bits */
1021
lock_rec_get_n_bits(
1022
/*================*/
1023
const lock_t* lock) /*!< in: record lock */
1025
return(lock->un_member.rec_lock.n_bits);
1028
/**********************************************************************//**
1029
Sets the nth bit of a record lock to TRUE. */
1032
lock_rec_set_nth_bit(
1033
/*=================*/
1034
lock_t* lock, /*!< in: record lock */
1035
ulint i) /*!< in: index of the bit */
1041
ut_ad(lock_get_type_low(lock) == LOCK_REC);
1042
ut_ad(i < lock->un_member.rec_lock.n_bits);
1047
((byte*) &lock[1])[byte_index] |= 1 << bit_index;
1050
/**********************************************************************//**
1051
Looks for a set bit in a record lock bitmap. Returns ULINT_UNDEFINED,
1053
@return bit index == heap number of the record, or ULINT_UNDEFINED if
1057
lock_rec_find_set_bit(
1058
/*==================*/
1059
const lock_t* lock) /*!< in: record lock with at least one bit set */
1063
for (i = 0; i < lock_rec_get_n_bits(lock); i++) {
1065
if (lock_rec_get_nth_bit(lock, i)) {
1071
return(ULINT_UNDEFINED);
1074
/**********************************************************************//**
1075
Resets the nth bit of a record lock. */
1078
lock_rec_reset_nth_bit(
1079
/*===================*/
1080
lock_t* lock, /*!< in: record lock */
1081
ulint i) /*!< in: index of the bit which must be set to TRUE
1082
when this function is called */
1088
ut_ad(lock_get_type_low(lock) == LOCK_REC);
1089
ut_ad(i < lock->un_member.rec_lock.n_bits);
1094
((byte*) &lock[1])[byte_index] &= ~(1 << bit_index);
1097
/*********************************************************************//**
1098
Gets the first or next record lock on a page.
1099
@return next lock, NULL if none exists */
1102
lock_rec_get_next_on_page(
1103
/*======================*/
1104
lock_t* lock) /*!< in: a record lock */
1109
ut_ad(mutex_own(&kernel_mutex));
1110
ut_ad(lock_get_type_low(lock) == LOCK_REC);
1112
space = lock->un_member.rec_lock.space;
1113
page_no = lock->un_member.rec_lock.page_no;
1116
lock = static_cast<lock_t *>(HASH_GET_NEXT(hash, lock));
1123
if ((lock->un_member.rec_lock.space == space)
1124
&& (lock->un_member.rec_lock.page_no == page_no)) {
1133
/*********************************************************************//**
1134
Gets the first record lock on a page, where the page is identified by its
1136
@return first lock, NULL if none exists */
1139
lock_rec_get_first_on_page_addr(
1140
/*============================*/
1141
ulint space, /*!< in: space */
1142
ulint page_no)/*!< in: page number */
1146
ut_ad(mutex_own(&kernel_mutex));
1148
lock = static_cast<lock_t *>(HASH_GET_FIRST(lock_sys->rec_hash,
1149
lock_rec_hash(space, page_no)));
1151
if ((lock->un_member.rec_lock.space == space)
1152
&& (lock->un_member.rec_lock.page_no == page_no)) {
1157
lock = static_cast<lock_t *>(HASH_GET_NEXT(hash, lock));
1163
/*********************************************************************//**
1164
Returns TRUE if there are explicit record locks on a page.
1165
@return TRUE if there are explicit record locks on the page */
1168
lock_rec_expl_exist_on_page(
1169
/*========================*/
1170
ulint space, /*!< in: space id */
1171
ulint page_no)/*!< in: page number */
1175
mutex_enter(&kernel_mutex);
1177
if (lock_rec_get_first_on_page_addr(space, page_no)) {
1183
mutex_exit(&kernel_mutex);
1188
/*********************************************************************//**
1189
Gets the first record lock on a page, where the page is identified by a
1191
@return first lock, NULL if none exists */
1194
lock_rec_get_first_on_page(
1195
/*=======================*/
1196
const buf_block_t* block) /*!< in: buffer block */
1200
ulint space = buf_block_get_space(block);
1201
ulint page_no = buf_block_get_page_no(block);
1203
ut_ad(mutex_own(&kernel_mutex));
1205
hash = buf_block_get_lock_hash_val(block);
1207
lock = static_cast<lock_t *>(HASH_GET_FIRST(lock_sys->rec_hash, hash));
1210
if ((lock->un_member.rec_lock.space == space)
1211
&& (lock->un_member.rec_lock.page_no == page_no)) {
1216
lock = static_cast<lock_t *>(HASH_GET_NEXT(hash, lock));
1222
/*********************************************************************//**
1223
Gets the next explicit lock request on a record.
1224
@return next lock, NULL if none exists or if heap_no == ULINT_UNDEFINED */
1229
ulint heap_no,/*!< in: heap number of the record */
1230
lock_t* lock) /*!< in: lock */
1232
ut_ad(mutex_own(&kernel_mutex));
1235
ut_ad(lock_get_type_low(lock) == LOCK_REC);
1236
lock = lock_rec_get_next_on_page(lock);
1237
} while (lock && !lock_rec_get_nth_bit(lock, heap_no));
1242
/*********************************************************************//**
1243
Gets the first explicit lock request on a record.
1244
@return first lock, NULL if none exists */
1249
const buf_block_t* block, /*!< in: block containing the record */
1250
ulint heap_no)/*!< in: heap number of the record */
1254
ut_ad(mutex_own(&kernel_mutex));
1256
for (lock = lock_rec_get_first_on_page(block); lock;
1257
lock = lock_rec_get_next_on_page(lock)) {
1258
if (lock_rec_get_nth_bit(lock, heap_no)) {
1266
/*********************************************************************//**
1267
Resets the record lock bitmap to zero. NOTE: does not touch the wait_lock
1268
pointer in the transaction! This function is used in lock object creation
1272
lock_rec_bitmap_reset(
1273
/*==================*/
1274
lock_t* lock) /*!< in: record lock */
1278
ut_ad(lock_get_type_low(lock) == LOCK_REC);
1280
/* Reset to zero the bitmap which resides immediately after the lock
1283
n_bytes = lock_rec_get_n_bits(lock) / 8;
1285
ut_ad((lock_rec_get_n_bits(lock) % 8) == 0);
1287
memset(&lock[1], 0, n_bytes);
1290
/*********************************************************************//**
1291
Copies a record lock to heap.
1292
@return copy of lock */
1297
const lock_t* lock, /*!< in: record lock */
1298
mem_heap_t* heap) /*!< in: memory heap */
1302
ut_ad(lock_get_type_low(lock) == LOCK_REC);
1304
size = sizeof(lock_t) + lock_rec_get_n_bits(lock) / 8;
1306
return static_cast<lock_t *>(mem_heap_dup(heap, lock, size));
1309
/*********************************************************************//**
1310
Gets the previous record lock set on a record.
1311
@return previous lock on the same record, NULL if none exists */
1316
const lock_t* in_lock,/*!< in: record lock */
1317
ulint heap_no)/*!< in: heap number of the record */
1322
lock_t* found_lock = NULL;
1324
ut_ad(mutex_own(&kernel_mutex));
1325
ut_ad(lock_get_type_low(in_lock) == LOCK_REC);
1327
space = in_lock->un_member.rec_lock.space;
1328
page_no = in_lock->un_member.rec_lock.page_no;
1330
lock = lock_rec_get_first_on_page_addr(space, page_no);
1335
if (lock == in_lock) {
1340
if (lock_rec_get_nth_bit(lock, heap_no)) {
1345
lock = lock_rec_get_next_on_page(lock);
1349
/*============= FUNCTIONS FOR ANALYZING TABLE LOCK QUEUE ================*/
1351
/*********************************************************************//**
1352
Checks if a transaction has the specified table lock, or stronger.
1353
@return lock or NULL */
1358
trx_t* trx, /*!< in: transaction */
1359
dict_table_t* table, /*!< in: table */
1360
enum lock_mode mode) /*!< in: lock mode */
1364
ut_ad(mutex_own(&kernel_mutex));
1366
/* Look for stronger locks the same trx already has on the table */
1368
lock = UT_LIST_GET_LAST(table->locks);
1370
while (lock != NULL) {
1372
if (lock->trx == trx
1373
&& lock_mode_stronger_or_eq(lock_get_mode(lock), mode)) {
1375
/* The same trx already has locked the table in
1376
a mode stronger or equal to the mode given */
1378
ut_ad(!lock_get_wait(lock));
1383
lock = UT_LIST_GET_PREV(un_member.tab_lock.locks, lock);
1389
/*============= FUNCTIONS FOR ANALYZING RECORD LOCK QUEUE ================*/
1391
/*********************************************************************//**
1392
Checks if a transaction has a GRANTED explicit lock on rec stronger or equal
1394
@return lock or NULL */
1399
ulint precise_mode,/*!< in: LOCK_S or LOCK_X
1400
possibly ORed to LOCK_GAP or
1401
LOCK_REC_NOT_GAP, for a
1402
supremum record we regard this
1403
always a gap type request */
1404
const buf_block_t* block, /*!< in: buffer block containing
1406
ulint heap_no,/*!< in: heap number of the record */
1407
trx_t* trx) /*!< in: transaction */
1411
ut_ad(mutex_own(&kernel_mutex));
1412
ut_ad((precise_mode & LOCK_MODE_MASK) == LOCK_S
1413
|| (precise_mode & LOCK_MODE_MASK) == LOCK_X);
1414
ut_ad(!(precise_mode & LOCK_INSERT_INTENTION));
1416
lock = lock_rec_get_first(block, heap_no);
1419
if (lock->trx == trx
1420
&& lock_mode_stronger_or_eq(lock_get_mode(lock),
1421
static_cast<lock_mode>(precise_mode & LOCK_MODE_MASK))
1422
&& !lock_get_wait(lock)
1423
&& (!lock_rec_get_rec_not_gap(lock)
1424
|| (precise_mode & LOCK_REC_NOT_GAP)
1425
|| heap_no == PAGE_HEAP_NO_SUPREMUM)
1426
&& (!lock_rec_get_gap(lock)
1427
|| (precise_mode & LOCK_GAP)
1428
|| heap_no == PAGE_HEAP_NO_SUPREMUM)
1429
&& (!lock_rec_get_insert_intention(lock))) {
1434
lock = lock_rec_get_next(heap_no, lock);
1441
/*********************************************************************//**
1442
Checks if some other transaction has a lock request in the queue.
1443
@return lock or NULL */
1446
lock_rec_other_has_expl_req(
1447
/*========================*/
1448
enum lock_mode mode, /*!< in: LOCK_S or LOCK_X */
1449
ulint gap, /*!< in: LOCK_GAP if also gap
1450
locks are taken into account,
1452
ulint wait, /*!< in: LOCK_WAIT if also
1453
waiting locks are taken into
1454
account, or 0 if not */
1455
const buf_block_t* block, /*!< in: buffer block containing
1457
ulint heap_no,/*!< in: heap number of the record */
1458
const trx_t* trx) /*!< in: transaction, or NULL if
1459
requests by all transactions
1460
are taken into account */
1464
ut_ad(mutex_own(&kernel_mutex));
1465
ut_ad(mode == LOCK_X || mode == LOCK_S);
1466
ut_ad(gap == 0 || gap == LOCK_GAP);
1467
ut_ad(wait == 0 || wait == LOCK_WAIT);
1469
lock = lock_rec_get_first(block, heap_no);
1472
if (lock->trx != trx
1474
|| !(lock_rec_get_gap(lock)
1475
|| heap_no == PAGE_HEAP_NO_SUPREMUM))
1476
&& (wait || !lock_get_wait(lock))
1477
&& lock_mode_stronger_or_eq(lock_get_mode(lock), mode)) {
1482
lock = lock_rec_get_next(heap_no, lock);
1487
#endif /* UNIV_DEBUG */
1489
/*********************************************************************//**
1490
Checks if some other transaction has a conflicting explicit lock request
1491
in the queue, so that we have to wait.
1492
@return lock or NULL */
1495
lock_rec_other_has_conflicting(
1496
/*===========================*/
1497
enum lock_mode mode, /*!< in: LOCK_S or LOCK_X,
1498
possibly ORed to LOCK_GAP or
1500
LOCK_INSERT_INTENTION */
1501
const buf_block_t* block, /*!< in: buffer block containing
1503
ulint heap_no,/*!< in: heap number of the record */
1504
trx_t* trx) /*!< in: our transaction */
1508
ut_ad(mutex_own(&kernel_mutex));
1510
lock = lock_rec_get_first(block, heap_no);
1512
if (UNIV_LIKELY_NULL(lock)) {
1513
if (UNIV_UNLIKELY(heap_no == PAGE_HEAP_NO_SUPREMUM)) {
1516
if (lock_rec_has_to_wait(trx, mode, lock,
1521
lock = lock_rec_get_next(heap_no, lock);
1526
if (lock_rec_has_to_wait(trx, mode, lock,
1531
lock = lock_rec_get_next(heap_no, lock);
1539
/*********************************************************************//**
1540
Looks for a suitable type record lock struct by the same trx on the same page.
1541
This can be used to save space when a new record lock should be set on a page:
1542
no new struct is needed, if a suitable old is found.
1543
@return lock or NULL */
1546
lock_rec_find_similar_on_page(
1547
/*==========================*/
1548
ulint type_mode, /*!< in: lock type_mode field */
1549
ulint heap_no, /*!< in: heap number of the record */
1550
lock_t* lock, /*!< in: lock_rec_get_first_on_page() */
1551
const trx_t* trx) /*!< in: transaction */
1553
ut_ad(mutex_own(&kernel_mutex));
1555
while (lock != NULL) {
1556
if (lock->trx == trx
1557
&& lock->type_mode == type_mode
1558
&& lock_rec_get_n_bits(lock) > heap_no) {
1563
lock = lock_rec_get_next_on_page(lock);
1569
/*********************************************************************//**
1570
Checks if some transaction has an implicit x-lock on a record in a secondary
1572
@return transaction which has the x-lock, or NULL */
1575
lock_sec_rec_some_has_impl_off_kernel(
1576
/*==================================*/
1577
const rec_t* rec, /*!< in: user record */
1578
dict_index_t* index, /*!< in: secondary index */
1579
const ulint* offsets)/*!< in: rec_get_offsets(rec, index) */
1581
const page_t* page = page_align(rec);
1583
ut_ad(mutex_own(&kernel_mutex));
1584
ut_ad(!dict_index_is_clust(index));
1585
ut_ad(page_rec_is_user_rec(rec));
1586
ut_ad(rec_offs_validate(rec, index, offsets));
1588
/* Some transaction may have an implicit x-lock on the record only
1589
if the max trx id for the page >= min trx id for the trx list, or
1590
database recovery is running. We do not write the changes of a page
1591
max trx id to the log, and therefore during recovery, this value
1592
for a page may be incorrect. */
1594
if (page_get_max_trx_id(page) < trx_list_get_min_trx_id()
1595
&& !recv_recovery_is_on()) {
1600
/* Ok, in this case it is possible that some transaction has an
1601
implicit x-lock. We have to look in the clustered index. */
1603
if (!lock_check_trx_id_sanity(page_get_max_trx_id(page),
1604
rec, index, offsets, TRUE)) {
1605
buf_page_print(page, 0);
1607
/* The page is corrupt: try to avoid a crash by returning
1612
return(row_vers_impl_x_locked_off_kernel(rec, index, offsets));
1615
/*********************************************************************//**
1616
Return approximate number or record locks (bits set in the bitmap) for
1617
this transaction. Since delete-marked records may be removed, the
1618
record count will not be precise. */
1621
lock_number_of_rows_locked(
1622
/*=======================*/
1623
const trx_t* trx) /*!< in: transaction */
1626
ulint n_records = 0;
1630
lock = UT_LIST_GET_FIRST(trx->trx_locks);
1633
if (lock_get_type_low(lock) == LOCK_REC) {
1634
n_bits = lock_rec_get_n_bits(lock);
1636
for (n_bit = 0; n_bit < n_bits; n_bit++) {
1637
if (lock_rec_get_nth_bit(lock, n_bit)) {
1643
lock = UT_LIST_GET_NEXT(trx_locks, lock);
1649
/*============== RECORD LOCK CREATION AND QUEUE MANAGEMENT =============*/
1651
/*********************************************************************//**
1652
Creates a new record lock and inserts it to the lock queue. Does NOT check
1653
for deadlocks or lock compatibility!
1654
@return created lock */
1659
ulint type_mode,/*!< in: lock mode and wait
1660
flag, type is ignored and
1661
replaced by LOCK_REC */
1662
const buf_block_t* block, /*!< in: buffer block containing
1664
ulint heap_no,/*!< in: heap number of the record */
1665
dict_index_t* index, /*!< in: index of record */
1666
trx_t* trx) /*!< in: transaction */
1675
ut_ad(mutex_own(&kernel_mutex));
1677
space = buf_block_get_space(block);
1678
page_no = buf_block_get_page_no(block);
1679
page = block->frame;
1681
ut_ad(!!page_is_comp(page) == dict_table_is_comp(index->table));
1683
/* If rec is the supremum record, then we reset the gap and
1684
LOCK_REC_NOT_GAP bits, as all locks on the supremum are
1685
automatically of the gap type */
1687
if (UNIV_UNLIKELY(heap_no == PAGE_HEAP_NO_SUPREMUM)) {
1688
ut_ad(!(type_mode & LOCK_REC_NOT_GAP));
1690
type_mode = type_mode & ~(LOCK_GAP | LOCK_REC_NOT_GAP);
1693
/* Make lock bitmap bigger by a safety margin */
1694
n_bits = page_dir_get_n_heap(page) + LOCK_PAGE_BITMAP_MARGIN;
1695
n_bytes = 1 + n_bits / 8;
1697
lock = static_cast<lock_t *>(mem_heap_alloc(trx->lock_heap, sizeof(lock_t) + n_bytes));
1699
UT_LIST_ADD_LAST(trx_locks, trx->trx_locks, lock);
1703
lock->type_mode = (type_mode & ~LOCK_TYPE_MASK) | LOCK_REC;
1704
lock->index = index;
1706
lock->un_member.rec_lock.space = space;
1707
lock->un_member.rec_lock.page_no = page_no;
1708
lock->un_member.rec_lock.n_bits = n_bytes * 8;
1710
/* Reset to zero the bitmap which resides immediately after the
1713
lock_rec_bitmap_reset(lock);
1715
/* Set the bit corresponding to rec */
1716
lock_rec_set_nth_bit(lock, heap_no);
1718
HASH_INSERT(lock_t, hash, lock_sys->rec_hash,
1719
lock_rec_fold(space, page_no), lock);
1720
if (UNIV_UNLIKELY(type_mode & LOCK_WAIT)) {
1722
lock_set_lock_and_trx_wait(lock, trx);
1728
/*********************************************************************//**
1729
Enqueues a waiting request for a lock which cannot be granted immediately.
1730
Checks for deadlocks.
1731
@return DB_LOCK_WAIT, DB_DEADLOCK, or DB_QUE_THR_SUSPENDED, or
1732
DB_SUCCESS_LOCKED_REC; DB_SUCCESS_LOCKED_REC means that
1733
there was a deadlock, but another transaction was chosen as a victim,
1734
and we got the lock immediately: no need to wait then */
1737
lock_rec_enqueue_waiting(
1738
/*=====================*/
1739
ulint type_mode,/*!< in: lock mode this
1740
transaction is requesting:
1741
LOCK_S or LOCK_X, possibly
1742
ORed with LOCK_GAP or
1743
LOCK_REC_NOT_GAP, ORed with
1744
LOCK_INSERT_INTENTION if this
1745
waiting lock request is set
1746
when performing an insert of
1748
const buf_block_t* block, /*!< in: buffer block containing
1750
ulint heap_no,/*!< in: heap number of the record */
1751
dict_index_t* index, /*!< in: index of record */
1752
que_thr_t* thr) /*!< in: query thread */
1757
ut_ad(mutex_own(&kernel_mutex));
1759
/* Test if there already is some other reason to suspend thread:
1760
we do not enqueue a lock request if the query thread should be
1763
if (UNIV_UNLIKELY(que_thr_stop(thr))) {
1767
return(DB_QUE_THR_SUSPENDED);
1770
trx = thr_get_trx(thr);
1772
switch (trx_get_dict_operation(trx)) {
1773
case TRX_DICT_OP_NONE:
1775
case TRX_DICT_OP_TABLE:
1776
case TRX_DICT_OP_INDEX:
1777
ut_print_timestamp(stderr);
1778
fputs(" InnoDB: Error: a record lock wait happens"
1779
" in a dictionary operation!\n"
1780
"InnoDB: ", stderr);
1781
dict_index_name_print(stderr, trx, index);
1783
"InnoDB: Submit a detailed bug report"
1784
" to http://bugs.mysql.com\n",
1788
/* Enqueue the lock request that will wait to be granted */
1789
lock = lock_rec_create(type_mode | LOCK_WAIT,
1790
block, heap_no, index, trx);
1792
/* Check if a deadlock occurs: if yes, remove the lock request and
1793
return an error code */
1795
if (UNIV_UNLIKELY(lock_deadlock_occurs(lock, trx))) {
1797
lock_reset_lock_and_trx_wait(lock);
1798
lock_rec_reset_nth_bit(lock, heap_no);
1800
return(DB_DEADLOCK);
1803
/* If there was a deadlock but we chose another transaction as a
1804
victim, it is possible that we already have the lock now granted! */
1806
if (trx->wait_lock == NULL) {
1808
return(DB_SUCCESS_LOCKED_REC);
1811
trx->que_state = TRX_QUE_LOCK_WAIT;
1812
trx->was_chosen_as_deadlock_victim = FALSE;
1813
trx->wait_started = time(NULL);
1815
ut_a(que_thr_stop(thr));
1818
if (lock_print_waits) {
1819
fprintf(stderr, "Lock wait for trx " TRX_ID_FMT " in index ",
1821
ut_print_name(stderr, trx, FALSE, index->name);
1823
#endif /* UNIV_DEBUG */
1825
return(DB_LOCK_WAIT);
1828
/*********************************************************************//**
1829
Adds a record lock request in the record queue. The request is normally
1830
added as the last in the queue, but if there are no waiting lock requests
1831
on the record, and the request to be added is not a waiting request, we
1832
can reuse a suitable record lock object already existing on the same page,
1833
just setting the appropriate bit in its bitmap. This is a low-level function
1834
which does NOT check for deadlocks or lock compatibility!
1835
@return lock where the bit was set */
1838
lock_rec_add_to_queue(
1839
/*==================*/
1840
ulint type_mode,/*!< in: lock mode, wait, gap
1841
etc. flags; type is ignored
1842
and replaced by LOCK_REC */
1843
const buf_block_t* block, /*!< in: buffer block containing
1845
ulint heap_no,/*!< in: heap number of the record */
1846
dict_index_t* index, /*!< in: index of record */
1847
trx_t* trx) /*!< in: transaction */
1851
ut_ad(mutex_own(&kernel_mutex));
1853
switch (type_mode & LOCK_MODE_MASK) {
1861
if (!(type_mode & (LOCK_WAIT | LOCK_GAP))) {
1862
enum lock_mode mode = (type_mode & LOCK_MODE_MASK) == LOCK_S
1866
= lock_rec_other_has_expl_req(mode, 0, LOCK_WAIT,
1867
block, heap_no, trx);
1870
#endif /* UNIV_DEBUG */
1872
type_mode |= LOCK_REC;
1874
/* If rec is the supremum record, then we can reset the gap bit, as
1875
all locks on the supremum are automatically of the gap type, and we
1876
try to avoid unnecessary memory consumption of a new record lock
1877
struct for a gap type lock */
1879
if (UNIV_UNLIKELY(heap_no == PAGE_HEAP_NO_SUPREMUM)) {
1880
ut_ad(!(type_mode & LOCK_REC_NOT_GAP));
1882
/* There should never be LOCK_REC_NOT_GAP on a supremum
1883
record, but let us play safe */
1885
type_mode = type_mode & ~(LOCK_GAP | LOCK_REC_NOT_GAP);
1888
/* Look for a waiting lock request on the same record or on a gap */
1890
lock = lock_rec_get_first_on_page(block);
1892
while (lock != NULL) {
1893
if (lock_get_wait(lock)
1894
&& (lock_rec_get_nth_bit(lock, heap_no))) {
1896
goto somebody_waits;
1899
lock = lock_rec_get_next_on_page(lock);
1902
if (UNIV_LIKELY(!(type_mode & LOCK_WAIT))) {
1904
/* Look for a similar record lock on the same page:
1905
if one is found and there are no waiting lock requests,
1906
we can just set the bit */
1908
lock = lock_rec_find_similar_on_page(
1910
lock_rec_get_first_on_page(block), trx);
1914
lock_rec_set_nth_bit(lock, heap_no);
1921
return(lock_rec_create(type_mode, block, heap_no, index, trx));
1924
/** Record locking request status */
1925
enum lock_rec_req_status {
1926
/** Failed to acquire a lock */
1928
/** Succeeded in acquiring a lock (implicit or already acquired) */
1930
/** Explicitly created a new lock */
1931
LOCK_REC_SUCCESS_CREATED
1934
/*********************************************************************//**
1935
This is a fast routine for locking a record in the most common cases:
1936
there are no explicit locks on the page, or there is just one lock, owned
1937
by this transaction, and of the right type_mode. This is a low-level function
1938
which does NOT look at implicit locks! Checks lock compatibility within
1939
explicit locks. This function sets a normal next-key lock, or in the case of
1940
a page supremum record, a gap type lock.
1941
@return whether the locking succeeded */
1943
enum lock_rec_req_status
1946
ibool impl, /*!< in: if TRUE, no lock is set
1947
if no wait is necessary: we
1948
assume that the caller will
1949
set an implicit lock */
1950
ulint mode, /*!< in: lock mode: LOCK_X or
1951
LOCK_S possibly ORed to either
1952
LOCK_GAP or LOCK_REC_NOT_GAP */
1953
const buf_block_t* block, /*!< in: buffer block containing
1955
ulint heap_no,/*!< in: heap number of record */
1956
dict_index_t* index, /*!< in: index of record */
1957
que_thr_t* thr) /*!< in: query thread */
1962
ut_ad(mutex_own(&kernel_mutex));
1963
ut_ad((LOCK_MODE_MASK & mode) != LOCK_S
1964
|| lock_table_has(thr_get_trx(thr), index->table, LOCK_IS));
1965
ut_ad((LOCK_MODE_MASK & mode) != LOCK_X
1966
|| lock_table_has(thr_get_trx(thr), index->table, LOCK_IX));
1967
ut_ad((LOCK_MODE_MASK & mode) == LOCK_S
1968
|| (LOCK_MODE_MASK & mode) == LOCK_X);
1969
ut_ad(mode - (LOCK_MODE_MASK & mode) == LOCK_GAP
1970
|| mode - (LOCK_MODE_MASK & mode) == 0
1971
|| mode - (LOCK_MODE_MASK & mode) == LOCK_REC_NOT_GAP);
1973
lock = lock_rec_get_first_on_page(block);
1975
trx = thr_get_trx(thr);
1979
lock_rec_create(mode, block, heap_no, index, trx);
1982
return(LOCK_REC_SUCCESS_CREATED);
1985
if (lock_rec_get_next_on_page(lock)) {
1987
return(LOCK_REC_FAIL);
1990
if (lock->trx != trx
1991
|| lock->type_mode != (mode | LOCK_REC)
1992
|| lock_rec_get_n_bits(lock) <= heap_no) {
1994
return(LOCK_REC_FAIL);
1998
/* If the nth bit of the record lock is already set then we
1999
do not set a new lock bit, otherwise we do set */
2001
if (!lock_rec_get_nth_bit(lock, heap_no)) {
2002
lock_rec_set_nth_bit(lock, heap_no);
2003
return(LOCK_REC_SUCCESS_CREATED);
2007
return(LOCK_REC_SUCCESS);
2010
/*********************************************************************//**
2011
This is the general, and slower, routine for locking a record. This is a
2012
low-level function which does NOT look at implicit locks! Checks lock
2013
compatibility within explicit locks. This function sets a normal next-key
2014
lock, or in the case of a page supremum record, a gap type lock.
2015
@return DB_SUCCESS, DB_SUCCESS_LOCKED_REC, DB_LOCK_WAIT, DB_DEADLOCK,
2016
or DB_QUE_THR_SUSPENDED */
2021
ibool impl, /*!< in: if TRUE, no lock is set
2022
if no wait is necessary: we
2023
assume that the caller will
2024
set an implicit lock */
2025
ulint mode, /*!< in: lock mode: LOCK_X or
2026
LOCK_S possibly ORed to either
2027
LOCK_GAP or LOCK_REC_NOT_GAP */
2028
const buf_block_t* block, /*!< in: buffer block containing
2030
ulint heap_no,/*!< in: heap number of record */
2031
dict_index_t* index, /*!< in: index of record */
2032
que_thr_t* thr) /*!< in: query thread */
2036
ut_ad(mutex_own(&kernel_mutex));
2037
ut_ad((LOCK_MODE_MASK & mode) != LOCK_S
2038
|| lock_table_has(thr_get_trx(thr), index->table, LOCK_IS));
2039
ut_ad((LOCK_MODE_MASK & mode) != LOCK_X
2040
|| lock_table_has(thr_get_trx(thr), index->table, LOCK_IX));
2041
ut_ad((LOCK_MODE_MASK & mode) == LOCK_S
2042
|| (LOCK_MODE_MASK & mode) == LOCK_X);
2043
ut_ad(mode - (LOCK_MODE_MASK & mode) == LOCK_GAP
2044
|| mode - (LOCK_MODE_MASK & mode) == 0
2045
|| mode - (LOCK_MODE_MASK & mode) == LOCK_REC_NOT_GAP);
2047
trx = thr_get_trx(thr);
2049
if (lock_rec_has_expl(mode, block, heap_no, trx)) {
2050
/* The trx already has a strong enough lock on rec: do
2053
} else if (lock_rec_other_has_conflicting(static_cast<lock_mode>(mode), block, heap_no, trx)) {
2055
/* If another transaction has a non-gap conflicting request in
2056
the queue, as this transaction does not have a lock strong
2057
enough already granted on the record, we have to wait. */
2059
return(lock_rec_enqueue_waiting(mode, block, heap_no,
2062
/* Set the requested lock on the record */
2064
lock_rec_add_to_queue(LOCK_REC | mode, block,
2065
heap_no, index, trx);
2066
return(DB_SUCCESS_LOCKED_REC);
2072
/*********************************************************************//**
2073
Tries to lock the specified record in the mode requested. If not immediately
2074
possible, enqueues a waiting lock request. This is a low-level function
2075
which does NOT look at implicit locks! Checks lock compatibility within
2076
explicit locks. This function sets a normal next-key lock, or in the case
2077
of a page supremum record, a gap type lock.
2078
@return DB_SUCCESS, DB_SUCCESS_LOCKED_REC, DB_LOCK_WAIT, DB_DEADLOCK,
2079
or DB_QUE_THR_SUSPENDED */
2084
ibool impl, /*!< in: if TRUE, no lock is set
2085
if no wait is necessary: we
2086
assume that the caller will
2087
set an implicit lock */
2088
ulint mode, /*!< in: lock mode: LOCK_X or
2089
LOCK_S possibly ORed to either
2090
LOCK_GAP or LOCK_REC_NOT_GAP */
2091
const buf_block_t* block, /*!< in: buffer block containing
2093
ulint heap_no,/*!< in: heap number of record */
2094
dict_index_t* index, /*!< in: index of record */
2095
que_thr_t* thr) /*!< in: query thread */
2097
ut_ad(mutex_own(&kernel_mutex));
2098
ut_ad((LOCK_MODE_MASK & mode) != LOCK_S
2099
|| lock_table_has(thr_get_trx(thr), index->table, LOCK_IS));
2100
ut_ad((LOCK_MODE_MASK & mode) != LOCK_X
2101
|| lock_table_has(thr_get_trx(thr), index->table, LOCK_IX));
2102
ut_ad((LOCK_MODE_MASK & mode) == LOCK_S
2103
|| (LOCK_MODE_MASK & mode) == LOCK_X);
2104
ut_ad(mode - (LOCK_MODE_MASK & mode) == LOCK_GAP
2105
|| mode - (LOCK_MODE_MASK & mode) == LOCK_REC_NOT_GAP
2106
|| mode - (LOCK_MODE_MASK & mode) == 0);
2108
/* We try a simplified and faster subroutine for the most
2110
switch (lock_rec_lock_fast(impl, mode, block, heap_no, index, thr)) {
2111
case LOCK_REC_SUCCESS:
2113
case LOCK_REC_SUCCESS_CREATED:
2114
return(DB_SUCCESS_LOCKED_REC);
2116
return(lock_rec_lock_slow(impl, mode, block,
2117
heap_no, index, thr));
2124
/*********************************************************************//**
2125
Checks if a waiting record lock request still has to wait in a queue.
2126
@return TRUE if still has to wait */
2129
lock_rec_has_to_wait_in_queue(
2130
/*==========================*/
2131
lock_t* wait_lock) /*!< in: waiting record lock */
2138
ut_ad(mutex_own(&kernel_mutex));
2139
ut_ad(lock_get_wait(wait_lock));
2140
ut_ad(lock_get_type_low(wait_lock) == LOCK_REC);
2142
space = wait_lock->un_member.rec_lock.space;
2143
page_no = wait_lock->un_member.rec_lock.page_no;
2144
heap_no = lock_rec_find_set_bit(wait_lock);
2146
lock = lock_rec_get_first_on_page_addr(space, page_no);
2148
while (lock != wait_lock) {
2150
if (lock_rec_get_nth_bit(lock, heap_no)
2151
&& lock_has_to_wait(wait_lock, lock)) {
2156
lock = lock_rec_get_next_on_page(lock);
2162
/*************************************************************//**
2163
Grants a lock to a waiting lock request and releases the waiting
2169
lock_t* lock) /*!< in/out: waiting lock request */
2171
ut_ad(mutex_own(&kernel_mutex));
2173
lock_reset_lock_and_trx_wait(lock);
2175
if (lock_get_mode(lock) == LOCK_AUTO_INC) {
2176
trx_t* trx = lock->trx;
2177
dict_table_t* table = lock->un_member.tab_lock.table;
2179
if (table->autoinc_trx == trx) {
2181
"InnoDB: Error: trx already had"
2182
" an AUTO-INC lock!\n");
2184
table->autoinc_trx = trx;
2186
ib_vector_push(trx->autoinc_locks, lock);
2191
if (lock_print_waits) {
2192
fprintf(stderr, "Lock wait for trx " TRX_ID_FMT " ends\n",
2195
#endif /* UNIV_DEBUG */
2197
/* If we are resolving a deadlock by choosing another transaction
2198
as a victim, then our original transaction may not be in the
2199
TRX_QUE_LOCK_WAIT state, and there is no need to end the lock wait
2202
if (lock->trx->que_state == TRX_QUE_LOCK_WAIT) {
2203
trx_end_lock_wait(lock->trx);
2207
/*************************************************************//**
2208
Cancels a waiting record lock request and releases the waiting transaction
2209
that requested it. NOTE: does NOT check if waiting lock requests behind this
2210
one can now be granted! */
2215
lock_t* lock) /*!< in: waiting record lock request */
2217
ut_ad(mutex_own(&kernel_mutex));
2218
ut_ad(lock_get_type_low(lock) == LOCK_REC);
2220
/* Reset the bit (there can be only one set bit) in the lock bitmap */
2221
lock_rec_reset_nth_bit(lock, lock_rec_find_set_bit(lock));
2223
/* Reset the wait flag and the back pointer to lock in trx */
2225
lock_reset_lock_and_trx_wait(lock);
2227
/* The following function releases the trx from lock wait */
2229
trx_end_lock_wait(lock->trx);
2232
/*************************************************************//**
2233
Removes a record lock request, waiting or granted, from the queue and
2234
grants locks to other transactions in the queue if they now are entitled
2235
to a lock. NOTE: all record locks contained in in_lock are removed. */
2238
lock_rec_dequeue_from_page(
2239
/*=======================*/
2240
lock_t* in_lock)/*!< in: record lock object: all record locks which
2241
are contained in this lock object are removed;
2242
transactions waiting behind will get their lock
2243
requests granted, if they are now qualified to it */
2250
ut_ad(mutex_own(&kernel_mutex));
2251
ut_ad(lock_get_type_low(in_lock) == LOCK_REC);
2255
space = in_lock->un_member.rec_lock.space;
2256
page_no = in_lock->un_member.rec_lock.page_no;
2258
HASH_DELETE(lock_t, hash, lock_sys->rec_hash,
2259
lock_rec_fold(space, page_no), in_lock);
2261
UT_LIST_REMOVE(trx_locks, trx->trx_locks, in_lock);
2263
/* Check if waiting locks in the queue can now be granted: grant
2264
locks if there are no conflicting locks ahead. */
2266
lock = lock_rec_get_first_on_page_addr(space, page_no);
2268
while (lock != NULL) {
2269
if (lock_get_wait(lock)
2270
&& !lock_rec_has_to_wait_in_queue(lock)) {
2272
/* Grant the lock */
2276
lock = lock_rec_get_next_on_page(lock);
2280
/*************************************************************//**
2281
Removes a record lock request, waiting or granted, from the queue. */
2286
lock_t* in_lock)/*!< in: record lock object: all record locks which
2287
are contained in this lock object are removed */
2293
ut_ad(mutex_own(&kernel_mutex));
2294
ut_ad(lock_get_type_low(in_lock) == LOCK_REC);
2298
space = in_lock->un_member.rec_lock.space;
2299
page_no = in_lock->un_member.rec_lock.page_no;
2301
HASH_DELETE(lock_t, hash, lock_sys->rec_hash,
2302
lock_rec_fold(space, page_no), in_lock);
2304
UT_LIST_REMOVE(trx_locks, trx->trx_locks, in_lock);
2307
/*************************************************************//**
2308
Removes record lock objects set on an index page which is discarded. This
2309
function does not move locks, or check for waiting locks, therefore the
2310
lock bitmaps must already be reset when this function is called. */
2313
lock_rec_free_all_from_discard_page(
2314
/*================================*/
2315
const buf_block_t* block) /*!< in: page to be discarded */
2322
ut_ad(mutex_own(&kernel_mutex));
2324
space = buf_block_get_space(block);
2325
page_no = buf_block_get_page_no(block);
2327
lock = lock_rec_get_first_on_page_addr(space, page_no);
2329
while (lock != NULL) {
2330
ut_ad(lock_rec_find_set_bit(lock) == ULINT_UNDEFINED);
2331
ut_ad(!lock_get_wait(lock));
2333
next_lock = lock_rec_get_next_on_page(lock);
2335
lock_rec_discard(lock);
2341
/*============= RECORD LOCK MOVING AND INHERITING ===================*/
2343
/*************************************************************//**
2344
Resets the lock bits for a single record. Releases transactions waiting for
2345
lock requests here. */
2348
lock_rec_reset_and_release_wait(
2349
/*============================*/
2350
const buf_block_t* block, /*!< in: buffer block containing
2352
ulint heap_no)/*!< in: heap number of record */
2356
ut_ad(mutex_own(&kernel_mutex));
2358
lock = lock_rec_get_first(block, heap_no);
2360
while (lock != NULL) {
2361
if (lock_get_wait(lock)) {
2362
lock_rec_cancel(lock);
2364
lock_rec_reset_nth_bit(lock, heap_no);
2367
lock = lock_rec_get_next(heap_no, lock);
2371
/*************************************************************//**
2372
Makes a record to inherit the locks (except LOCK_INSERT_INTENTION type)
2373
of another record as gap type locks, but does not reset the lock bits of
2374
the other record. Also waiting lock requests on rec are inherited as
2375
GRANTED gap locks. */
2378
lock_rec_inherit_to_gap(
2379
/*====================*/
2380
const buf_block_t* heir_block, /*!< in: block containing the
2381
record which inherits */
2382
const buf_block_t* block, /*!< in: block containing the
2383
record from which inherited;
2384
does NOT reset the locks on
2386
ulint heir_heap_no, /*!< in: heap_no of the
2387
inheriting record */
2388
ulint heap_no) /*!< in: heap_no of the
2393
ut_ad(mutex_own(&kernel_mutex));
2395
lock = lock_rec_get_first(block, heap_no);
2397
/* If srv_locks_unsafe_for_binlog is TRUE or session is using
2398
READ COMMITTED isolation level, we do not want locks set
2399
by an UPDATE or a DELETE to be inherited as gap type locks. But we
2400
DO want S-locks set by a consistency constraint to be inherited also
2403
while (lock != NULL) {
2404
if (!lock_rec_get_insert_intention(lock)
2405
&& !((srv_locks_unsafe_for_binlog
2406
|| lock->trx->isolation_level
2407
<= TRX_ISO_READ_COMMITTED)
2408
&& lock_get_mode(lock) == LOCK_X)) {
2410
lock_rec_add_to_queue(LOCK_REC | LOCK_GAP
2411
| lock_get_mode(lock),
2412
heir_block, heir_heap_no,
2413
lock->index, lock->trx);
2416
lock = lock_rec_get_next(heap_no, lock);
2420
/*************************************************************//**
2421
Makes a record to inherit the gap locks (except LOCK_INSERT_INTENTION type)
2422
of another record as gap type locks, but does not reset the lock bits of the
2423
other record. Also waiting lock requests are inherited as GRANTED gap locks. */
2426
lock_rec_inherit_to_gap_if_gap_lock(
2427
/*================================*/
2428
const buf_block_t* block, /*!< in: buffer block */
2429
ulint heir_heap_no, /*!< in: heap_no of
2430
record which inherits */
2431
ulint heap_no) /*!< in: heap_no of record
2432
from which inherited;
2433
does NOT reset the locks
2438
ut_ad(mutex_own(&kernel_mutex));
2440
lock = lock_rec_get_first(block, heap_no);
2442
while (lock != NULL) {
2443
if (!lock_rec_get_insert_intention(lock)
2444
&& (heap_no == PAGE_HEAP_NO_SUPREMUM
2445
|| !lock_rec_get_rec_not_gap(lock))) {
2447
lock_rec_add_to_queue(LOCK_REC | LOCK_GAP
2448
| lock_get_mode(lock),
2449
block, heir_heap_no,
2450
lock->index, lock->trx);
2453
lock = lock_rec_get_next(heap_no, lock);
2457
/*************************************************************//**
2458
Moves the locks of a record to another record and resets the lock bits of
2459
the donating record. */
2464
const buf_block_t* receiver, /*!< in: buffer block containing
2465
the receiving record */
2466
const buf_block_t* donator, /*!< in: buffer block containing
2467
the donating record */
2468
ulint receiver_heap_no,/*!< in: heap_no of the record
2469
which gets the locks; there
2470
must be no lock requests
2472
ulint donator_heap_no)/*!< in: heap_no of the record
2473
which gives the locks */
2477
ut_ad(mutex_own(&kernel_mutex));
2479
lock = lock_rec_get_first(donator, donator_heap_no);
2481
ut_ad(lock_rec_get_first(receiver, receiver_heap_no) == NULL);
2483
while (lock != NULL) {
2484
const ulint type_mode = lock->type_mode;
2486
lock_rec_reset_nth_bit(lock, donator_heap_no);
2488
if (UNIV_UNLIKELY(type_mode & LOCK_WAIT)) {
2489
lock_reset_lock_and_trx_wait(lock);
2492
/* Note that we FIRST reset the bit, and then set the lock:
2493
the function works also if donator == receiver */
2495
lock_rec_add_to_queue(type_mode, receiver, receiver_heap_no,
2496
lock->index, lock->trx);
2497
lock = lock_rec_get_next(donator_heap_no, lock);
2500
ut_ad(lock_rec_get_first(donator, donator_heap_no) == NULL);
2503
/*************************************************************//**
2504
Updates the lock table when we have reorganized a page. NOTE: we copy
2505
also the locks set on the infimum of the page; the infimum may carry
2506
locks if an update of a record is occurring on the page, and its locks
2507
were temporarily stored on the infimum. */
2510
lock_move_reorganize_page(
2511
/*======================*/
2512
const buf_block_t* block, /*!< in: old index page, now
2514
const buf_block_t* oblock) /*!< in: copy of the old, not
2518
UT_LIST_BASE_NODE_T(lock_t) old_locks;
2519
mem_heap_t* heap = NULL;
2522
lock_mutex_enter_kernel();
2524
lock = lock_rec_get_first_on_page(block);
2527
lock_mutex_exit_kernel();
2532
heap = mem_heap_create(256);
2534
/* Copy first all the locks on the page to heap and reset the
2535
bitmaps in the original locks; chain the copies of the locks
2536
using the trx_locks field in them. */
2538
UT_LIST_INIT(old_locks);
2541
/* Make a copy of the lock */
2542
lock_t* old_lock = lock_rec_copy(lock, heap);
2544
UT_LIST_ADD_LAST(trx_locks, old_locks, old_lock);
2546
/* Reset bitmap of lock */
2547
lock_rec_bitmap_reset(lock);
2549
if (lock_get_wait(lock)) {
2550
lock_reset_lock_and_trx_wait(lock);
2553
lock = lock_rec_get_next_on_page(lock);
2554
} while (lock != NULL);
2556
comp = page_is_comp(block->frame);
2557
ut_ad(comp == page_is_comp(oblock->frame));
2559
for (lock = UT_LIST_GET_FIRST(old_locks); lock;
2560
lock = UT_LIST_GET_NEXT(trx_locks, lock)) {
2561
/* NOTE: we copy also the locks set on the infimum and
2562
supremum of the page; the infimum may carry locks if an
2563
update of a record is occurring on the page, and its locks
2564
were temporarily stored on the infimum */
2568
page_cur_set_before_first(block, &cur1);
2569
page_cur_set_before_first(oblock, &cur2);
2571
/* Set locks according to old locks */
2576
ut_ad(comp || !memcmp(page_cur_get_rec(&cur1),
2577
page_cur_get_rec(&cur2),
2578
rec_get_data_size_old(
2581
if (UNIV_LIKELY(comp)) {
2582
old_heap_no = rec_get_heap_no_new(
2583
page_cur_get_rec(&cur2));
2584
new_heap_no = rec_get_heap_no_new(
2585
page_cur_get_rec(&cur1));
2587
old_heap_no = rec_get_heap_no_old(
2588
page_cur_get_rec(&cur2));
2589
new_heap_no = rec_get_heap_no_old(
2590
page_cur_get_rec(&cur1));
2593
if (lock_rec_get_nth_bit(lock, old_heap_no)) {
2595
/* Clear the bit in old_lock. */
2596
ut_d(lock_rec_reset_nth_bit(lock,
2599
/* NOTE that the old lock bitmap could be too
2600
small for the new heap number! */
2602
lock_rec_add_to_queue(lock->type_mode, block,
2604
lock->index, lock->trx);
2606
/* if (new_heap_no == PAGE_HEAP_NO_SUPREMUM
2607
&& lock_get_wait(lock)) {
2609
"---\n--\n!!!Lock reorg: supr type %lu\n",
2615
(new_heap_no == PAGE_HEAP_NO_SUPREMUM)) {
2617
ut_ad(old_heap_no == PAGE_HEAP_NO_SUPREMUM);
2621
page_cur_move_to_next(&cur1);
2622
page_cur_move_to_next(&cur2);
2627
ulint i = lock_rec_find_set_bit(lock);
2629
/* Check that all locks were moved. */
2630
if (UNIV_UNLIKELY(i != ULINT_UNDEFINED)) {
2632
"lock_move_reorganize_page():"
2633
" %lu not moved in %p\n",
2634
(ulong) i, (void*) lock);
2638
#endif /* UNIV_DEBUG */
2641
lock_mutex_exit_kernel();
2643
mem_heap_free(heap);
2645
#ifdef UNIV_DEBUG_LOCK_VALIDATE
2646
ut_ad(lock_rec_validate_page(buf_block_get_space(block),
2647
buf_block_get_page_no(block)));
2651
/*************************************************************//**
2652
Moves the explicit locks on user records to another page if a record
2653
list end is moved to another page. */
2656
lock_move_rec_list_end(
2657
/*===================*/
2658
const buf_block_t* new_block, /*!< in: index page to move to */
2659
const buf_block_t* block, /*!< in: index page */
2660
const rec_t* rec) /*!< in: record on page: this
2661
is the first record moved */
2664
const ulint comp = page_rec_is_comp(rec);
2666
lock_mutex_enter_kernel();
2668
/* Note: when we move locks from record to record, waiting locks
2669
and possible granted gap type locks behind them are enqueued in
2670
the original order, because new elements are inserted to a hash
2671
table to the end of the hash chain, and lock_rec_add_to_queue
2672
does not reuse locks if there are waiters in the queue. */
2674
for (lock = lock_rec_get_first_on_page(block); lock;
2675
lock = lock_rec_get_next_on_page(lock)) {
2678
const ulint type_mode = lock->type_mode;
2680
page_cur_position(rec, block, &cur1);
2682
if (page_cur_is_before_first(&cur1)) {
2683
page_cur_move_to_next(&cur1);
2686
page_cur_set_before_first(new_block, &cur2);
2687
page_cur_move_to_next(&cur2);
2689
/* Copy lock requests on user records to new page and
2690
reset the lock bits on the old */
2692
while (!page_cur_is_after_last(&cur1)) {
2696
heap_no = rec_get_heap_no_new(
2697
page_cur_get_rec(&cur1));
2699
heap_no = rec_get_heap_no_old(
2700
page_cur_get_rec(&cur1));
2701
ut_ad(!memcmp(page_cur_get_rec(&cur1),
2702
page_cur_get_rec(&cur2),
2703
rec_get_data_size_old(
2704
page_cur_get_rec(&cur2))));
2707
if (lock_rec_get_nth_bit(lock, heap_no)) {
2708
lock_rec_reset_nth_bit(lock, heap_no);
2710
if (UNIV_UNLIKELY(type_mode & LOCK_WAIT)) {
2711
lock_reset_lock_and_trx_wait(lock);
2715
heap_no = rec_get_heap_no_new(
2716
page_cur_get_rec(&cur2));
2718
heap_no = rec_get_heap_no_old(
2719
page_cur_get_rec(&cur2));
2722
lock_rec_add_to_queue(type_mode,
2724
lock->index, lock->trx);
2727
page_cur_move_to_next(&cur1);
2728
page_cur_move_to_next(&cur2);
2732
lock_mutex_exit_kernel();
2734
#ifdef UNIV_DEBUG_LOCK_VALIDATE
2735
ut_ad(lock_rec_validate_page(buf_block_get_space(block),
2736
buf_block_get_page_no(block)));
2737
ut_ad(lock_rec_validate_page(buf_block_get_space(new_block),
2738
buf_block_get_page_no(new_block)));
2742
/*************************************************************//**
2743
Moves the explicit locks on user records to another page if a record
2744
list start is moved to another page. */
2747
lock_move_rec_list_start(
2748
/*=====================*/
2749
const buf_block_t* new_block, /*!< in: index page to move to */
2750
const buf_block_t* block, /*!< in: index page */
2751
const rec_t* rec, /*!< in: record on page:
2753
record NOT copied */
2754
const rec_t* old_end) /*!< in: old
2761
const ulint comp = page_rec_is_comp(rec);
2763
ut_ad(block->frame == page_align(rec));
2764
ut_ad(new_block->frame == page_align(old_end));
2766
lock_mutex_enter_kernel();
2768
for (lock = lock_rec_get_first_on_page(block); lock;
2769
lock = lock_rec_get_next_on_page(lock)) {
2772
const ulint type_mode = lock->type_mode;
2774
page_cur_set_before_first(block, &cur1);
2775
page_cur_move_to_next(&cur1);
2777
page_cur_position(old_end, new_block, &cur2);
2778
page_cur_move_to_next(&cur2);
2780
/* Copy lock requests on user records to new page and
2781
reset the lock bits on the old */
2783
while (page_cur_get_rec(&cur1) != rec) {
2787
heap_no = rec_get_heap_no_new(
2788
page_cur_get_rec(&cur1));
2790
heap_no = rec_get_heap_no_old(
2791
page_cur_get_rec(&cur1));
2792
ut_ad(!memcmp(page_cur_get_rec(&cur1),
2793
page_cur_get_rec(&cur2),
2794
rec_get_data_size_old(
2799
if (lock_rec_get_nth_bit(lock, heap_no)) {
2800
lock_rec_reset_nth_bit(lock, heap_no);
2802
if (UNIV_UNLIKELY(type_mode & LOCK_WAIT)) {
2803
lock_reset_lock_and_trx_wait(lock);
2807
heap_no = rec_get_heap_no_new(
2808
page_cur_get_rec(&cur2));
2810
heap_no = rec_get_heap_no_old(
2811
page_cur_get_rec(&cur2));
2814
lock_rec_add_to_queue(type_mode,
2816
lock->index, lock->trx);
2819
page_cur_move_to_next(&cur1);
2820
page_cur_move_to_next(&cur2);
2824
if (page_rec_is_supremum(rec)) {
2827
for (i = PAGE_HEAP_NO_USER_LOW;
2828
i < lock_rec_get_n_bits(lock); i++) {
2830
(lock_rec_get_nth_bit(lock, i))) {
2833
"lock_move_rec_list_start():"
2834
" %lu not moved in %p\n",
2835
(ulong) i, (void*) lock);
2840
#endif /* UNIV_DEBUG */
2843
lock_mutex_exit_kernel();
2845
#ifdef UNIV_DEBUG_LOCK_VALIDATE
2846
ut_ad(lock_rec_validate_page(buf_block_get_space(block),
2847
buf_block_get_page_no(block)));
2851
/*************************************************************//**
2852
Updates the lock table when a page is split to the right. */
2855
lock_update_split_right(
2856
/*====================*/
2857
const buf_block_t* right_block, /*!< in: right page */
2858
const buf_block_t* left_block) /*!< in: left page */
2860
ulint heap_no = lock_get_min_heap_no(right_block);
2862
lock_mutex_enter_kernel();
2864
/* Move the locks on the supremum of the left page to the supremum
2865
of the right page */
2867
lock_rec_move(right_block, left_block,
2868
PAGE_HEAP_NO_SUPREMUM, PAGE_HEAP_NO_SUPREMUM);
2870
/* Inherit the locks to the supremum of left page from the successor
2871
of the infimum on right page */
2873
lock_rec_inherit_to_gap(left_block, right_block,
2874
PAGE_HEAP_NO_SUPREMUM, heap_no);
2876
lock_mutex_exit_kernel();
2879
/*************************************************************//**
2880
Updates the lock table when a page is merged to the right. */
2883
lock_update_merge_right(
2884
/*====================*/
2885
const buf_block_t* right_block, /*!< in: right page to
2887
const rec_t* orig_succ, /*!< in: original
2888
successor of infimum
2891
const buf_block_t* left_block) /*!< in: merged index
2895
lock_mutex_enter_kernel();
2897
/* Inherit the locks from the supremum of the left page to the
2898
original successor of infimum on the right page, to which the left
2901
lock_rec_inherit_to_gap(right_block, left_block,
2902
page_rec_get_heap_no(orig_succ),
2903
PAGE_HEAP_NO_SUPREMUM);
2905
/* Reset the locks on the supremum of the left page, releasing
2906
waiting transactions */
2908
lock_rec_reset_and_release_wait(left_block,
2909
PAGE_HEAP_NO_SUPREMUM);
2911
lock_rec_free_all_from_discard_page(left_block);
2913
lock_mutex_exit_kernel();
2916
/*************************************************************//**
2917
Updates the lock table when the root page is copied to another in
2918
btr_root_raise_and_insert. Note that we leave lock structs on the
2919
root page, even though they do not make sense on other than leaf
2920
pages: the reason is that in a pessimistic update the infimum record
2921
of the root page will act as a dummy carrier of the locks of the record
2925
lock_update_root_raise(
2926
/*===================*/
2927
const buf_block_t* block, /*!< in: index page to which copied */
2928
const buf_block_t* root) /*!< in: root page */
2930
lock_mutex_enter_kernel();
2932
/* Move the locks on the supremum of the root to the supremum
2935
lock_rec_move(block, root,
2936
PAGE_HEAP_NO_SUPREMUM, PAGE_HEAP_NO_SUPREMUM);
2937
lock_mutex_exit_kernel();
2940
/*************************************************************//**
2941
Updates the lock table when a page is copied to another and the original page
2942
is removed from the chain of leaf pages, except if page is the root! */
2945
lock_update_copy_and_discard(
2946
/*=========================*/
2947
const buf_block_t* new_block, /*!< in: index page to
2949
const buf_block_t* block) /*!< in: index page;
2952
lock_mutex_enter_kernel();
2954
/* Move the locks on the supremum of the old page to the supremum
2957
lock_rec_move(new_block, block,
2958
PAGE_HEAP_NO_SUPREMUM, PAGE_HEAP_NO_SUPREMUM);
2959
lock_rec_free_all_from_discard_page(block);
2961
lock_mutex_exit_kernel();
2964
/*************************************************************//**
2965
Updates the lock table when a page is split to the left. */
2968
lock_update_split_left(
2969
/*===================*/
2970
const buf_block_t* right_block, /*!< in: right page */
2971
const buf_block_t* left_block) /*!< in: left page */
2973
ulint heap_no = lock_get_min_heap_no(right_block);
2975
lock_mutex_enter_kernel();
2977
/* Inherit the locks to the supremum of the left page from the
2978
successor of the infimum on the right page */
2980
lock_rec_inherit_to_gap(left_block, right_block,
2981
PAGE_HEAP_NO_SUPREMUM, heap_no);
2983
lock_mutex_exit_kernel();
2986
/*************************************************************//**
2987
Updates the lock table when a page is merged to the left. */
2990
lock_update_merge_left(
2991
/*===================*/
2992
const buf_block_t* left_block, /*!< in: left page to
2994
const rec_t* orig_pred, /*!< in: original predecessor
2995
of supremum on the left page
2997
const buf_block_t* right_block) /*!< in: merged index page
2998
which will be discarded */
3000
const rec_t* left_next_rec;
3002
ut_ad(left_block->frame == page_align(orig_pred));
3004
lock_mutex_enter_kernel();
3006
left_next_rec = page_rec_get_next_const(orig_pred);
3008
if (!page_rec_is_supremum(left_next_rec)) {
3010
/* Inherit the locks on the supremum of the left page to the
3011
first record which was moved from the right page */
3013
lock_rec_inherit_to_gap(left_block, left_block,
3014
page_rec_get_heap_no(left_next_rec),
3015
PAGE_HEAP_NO_SUPREMUM);
3017
/* Reset the locks on the supremum of the left page,
3018
releasing waiting transactions */
3020
lock_rec_reset_and_release_wait(left_block,
3021
PAGE_HEAP_NO_SUPREMUM);
3024
/* Move the locks from the supremum of right page to the supremum
3027
lock_rec_move(left_block, right_block,
3028
PAGE_HEAP_NO_SUPREMUM, PAGE_HEAP_NO_SUPREMUM);
3030
lock_rec_free_all_from_discard_page(right_block);
3032
lock_mutex_exit_kernel();
3035
/*************************************************************//**
3036
Resets the original locks on heir and replaces them with gap type locks
3037
inherited from rec. */
3040
lock_rec_reset_and_inherit_gap_locks(
3041
/*=================================*/
3042
const buf_block_t* heir_block, /*!< in: block containing the
3043
record which inherits */
3044
const buf_block_t* block, /*!< in: block containing the
3045
record from which inherited;
3046
does NOT reset the locks on
3048
ulint heir_heap_no, /*!< in: heap_no of the
3049
inheriting record */
3050
ulint heap_no) /*!< in: heap_no of the
3053
mutex_enter(&kernel_mutex);
3055
lock_rec_reset_and_release_wait(heir_block, heir_heap_no);
3057
lock_rec_inherit_to_gap(heir_block, block, heir_heap_no, heap_no);
3059
mutex_exit(&kernel_mutex);
3062
/*************************************************************//**
3063
Updates the lock table when a page is discarded. */
3066
lock_update_discard(
3067
/*================*/
3068
const buf_block_t* heir_block, /*!< in: index page
3069
which will inherit the locks */
3070
ulint heir_heap_no, /*!< in: heap_no of the record
3071
which will inherit the locks */
3072
const buf_block_t* block) /*!< in: index page
3073
which will be discarded */
3075
const page_t* page = block->frame;
3079
lock_mutex_enter_kernel();
3081
if (!lock_rec_get_first_on_page(block)) {
3082
/* No locks exist on page, nothing to do */
3084
lock_mutex_exit_kernel();
3089
/* Inherit all the locks on the page to the record and reset all
3090
the locks on the page */
3092
if (page_is_comp(page)) {
3093
rec = page + PAGE_NEW_INFIMUM;
3096
heap_no = rec_get_heap_no_new(rec);
3098
lock_rec_inherit_to_gap(heir_block, block,
3099
heir_heap_no, heap_no);
3101
lock_rec_reset_and_release_wait(block, heap_no);
3103
rec = page + rec_get_next_offs(rec, TRUE);
3104
} while (heap_no != PAGE_HEAP_NO_SUPREMUM);
3106
rec = page + PAGE_OLD_INFIMUM;
3109
heap_no = rec_get_heap_no_old(rec);
3111
lock_rec_inherit_to_gap(heir_block, block,
3112
heir_heap_no, heap_no);
3114
lock_rec_reset_and_release_wait(block, heap_no);
3116
rec = page + rec_get_next_offs(rec, FALSE);
3117
} while (heap_no != PAGE_HEAP_NO_SUPREMUM);
3120
lock_rec_free_all_from_discard_page(block);
3122
lock_mutex_exit_kernel();
3125
/*************************************************************//**
3126
Updates the lock table when a new user record is inserted. */
3131
const buf_block_t* block, /*!< in: buffer block containing rec */
3132
const rec_t* rec) /*!< in: the inserted record */
3134
ulint receiver_heap_no;
3135
ulint donator_heap_no;
3137
ut_ad(block->frame == page_align(rec));
3139
/* Inherit the gap-locking locks for rec, in gap mode, from the next
3142
if (page_rec_is_comp(rec)) {
3143
receiver_heap_no = rec_get_heap_no_new(rec);
3144
donator_heap_no = rec_get_heap_no_new(
3145
page_rec_get_next_low(rec, TRUE));
3147
receiver_heap_no = rec_get_heap_no_old(rec);
3148
donator_heap_no = rec_get_heap_no_old(
3149
page_rec_get_next_low(rec, FALSE));
3152
lock_mutex_enter_kernel();
3153
lock_rec_inherit_to_gap_if_gap_lock(block,
3154
receiver_heap_no, donator_heap_no);
3155
lock_mutex_exit_kernel();
3158
/*************************************************************//**
3159
Updates the lock table when a record is removed. */
3164
const buf_block_t* block, /*!< in: buffer block containing rec */
3165
const rec_t* rec) /*!< in: the record to be removed */
3167
const page_t* page = block->frame;
3171
ut_ad(page == page_align(rec));
3173
if (page_is_comp(page)) {
3174
heap_no = rec_get_heap_no_new(rec);
3175
next_heap_no = rec_get_heap_no_new(page
3176
+ rec_get_next_offs(rec,
3179
heap_no = rec_get_heap_no_old(rec);
3180
next_heap_no = rec_get_heap_no_old(page
3181
+ rec_get_next_offs(rec,
3185
lock_mutex_enter_kernel();
3187
/* Let the next record inherit the locks from rec, in gap mode */
3189
lock_rec_inherit_to_gap(block, block, next_heap_no, heap_no);
3191
/* Reset the lock bits on rec and release waiting transactions */
3193
lock_rec_reset_and_release_wait(block, heap_no);
3195
lock_mutex_exit_kernel();
3198
/*********************************************************************//**
3199
Stores on the page infimum record the explicit locks of another record.
3200
This function is used to store the lock state of a record when it is
3201
updated and the size of the record changes in the update. The record
3202
is moved in such an update, perhaps to another page. The infimum record
3203
acts as a dummy carrier record, taking care of lock releases while the
3204
actual record is being moved. */
3207
lock_rec_store_on_page_infimum(
3208
/*===========================*/
3209
const buf_block_t* block, /*!< in: buffer block containing rec */
3210
const rec_t* rec) /*!< in: record whose lock state
3211
is stored on the infimum
3212
record of the same page; lock
3213
bits are reset on the
3216
ulint heap_no = page_rec_get_heap_no(rec);
3218
ut_ad(block->frame == page_align(rec));
3220
lock_mutex_enter_kernel();
3222
lock_rec_move(block, block, PAGE_HEAP_NO_INFIMUM, heap_no);
3224
lock_mutex_exit_kernel();
3227
/*********************************************************************//**
3228
Restores the state of explicit lock requests on a single record, where the
3229
state was stored on the infimum of the page. */
3232
lock_rec_restore_from_page_infimum(
3233
/*===============================*/
3234
const buf_block_t* block, /*!< in: buffer block containing rec */
3235
const rec_t* rec, /*!< in: record whose lock state
3237
const buf_block_t* donator)/*!< in: page (rec is not
3238
necessarily on this page)
3239
whose infimum stored the lock
3240
state; lock bits are reset on
3243
ulint heap_no = page_rec_get_heap_no(rec);
3245
lock_mutex_enter_kernel();
3247
lock_rec_move(block, donator, heap_no, PAGE_HEAP_NO_INFIMUM);
3249
lock_mutex_exit_kernel();
3252
/*=========== DEADLOCK CHECKING ======================================*/
3254
/********************************************************************//**
3255
Checks if a lock request results in a deadlock.
3256
@return TRUE if a deadlock was detected and we chose trx as a victim;
3257
FALSE if no deadlock, or there was a deadlock, but we chose other
3258
transaction(s) as victim(s) */
3261
lock_deadlock_occurs(
3262
/*=================*/
3263
lock_t* lock, /*!< in: lock the transaction is requesting */
3264
trx_t* trx) /*!< in: transaction */
3272
ut_ad(mutex_own(&kernel_mutex));
3274
/* We check that adding this trx to the waits-for graph
3275
does not produce a cycle. First mark all active transactions
3278
mark_trx = UT_LIST_GET_FIRST(trx_sys->trx_list);
3281
mark_trx->deadlock_mark = 0;
3282
mark_trx = UT_LIST_GET_NEXT(trx_list, mark_trx);
3285
ret = lock_deadlock_recursive(trx, trx, lock, &cost, 0);
3288
case LOCK_VICTIM_IS_OTHER:
3289
/* We chose some other trx as a victim: retry if there still
3293
case LOCK_EXCEED_MAX_DEPTH:
3294
/* If the lock search exceeds the max step
3295
or the max depth, the current trx will be
3296
the victim. Print its information. */
3297
rewind(lock_latest_err_file);
3298
ut_print_timestamp(lock_latest_err_file);
3300
fputs("TOO DEEP OR LONG SEARCH IN THE LOCK TABLE"
3301
" WAITS-FOR GRAPH, WE WILL ROLL BACK"
3302
" FOLLOWING TRANSACTION \n",
3303
lock_latest_err_file);
3305
fputs("\n*** TRANSACTION:\n", lock_latest_err_file);
3306
trx_print(lock_latest_err_file, trx, 3000);
3308
fputs("*** WAITING FOR THIS LOCK TO BE GRANTED:\n",
3309
lock_latest_err_file);
3311
if (lock_get_type(lock) == LOCK_REC) {
3312
lock_rec_print(lock_latest_err_file, lock);
3314
lock_table_print(lock_latest_err_file, lock);
3318
case LOCK_VICTIM_IS_START:
3319
fputs("*** WE ROLL BACK TRANSACTION (2)\n",
3320
lock_latest_err_file);
3324
/* No deadlock detected*/
3328
lock_deadlock_found = TRUE;
3333
/********************************************************************//**
3334
Looks recursively for a deadlock.
3335
@return 0 if no deadlock found, LOCK_VICTIM_IS_START if there was a
3336
deadlock and we chose 'start' as the victim, LOCK_VICTIM_IS_OTHER if a
3337
deadlock was found and we chose some other trx as a victim: we must do
3338
the search again in this last case because there may be another
3340
LOCK_EXCEED_MAX_DEPTH if the lock search exceeds max steps or max depth. */
3343
lock_deadlock_recursive(
3344
/*====================*/
3345
trx_t* start, /*!< in: recursion starting point */
3346
trx_t* trx, /*!< in: a transaction waiting for a lock */
3347
lock_t* wait_lock, /*!< in: lock that is waiting to be granted */
3348
ulint* cost, /*!< in/out: number of calculation steps thus
3349
far: if this exceeds LOCK_MAX_N_STEPS_...
3350
we return LOCK_EXCEED_MAX_DEPTH */
3351
ulint depth) /*!< in: recursion depth: if this exceeds
3352
LOCK_MAX_DEPTH_IN_DEADLOCK_CHECK, we
3353
return LOCK_EXCEED_MAX_DEPTH */
3358
ulint heap_no = ULINT_UNDEFINED;
3363
ut_ad(mutex_own(&kernel_mutex));
3365
if (trx->deadlock_mark == 1) {
3366
/* We have already exhaustively searched the subtree starting
3374
if (lock_get_type_low(wait_lock) == LOCK_REC) {
3378
heap_no = lock_rec_find_set_bit(wait_lock);
3379
ut_a(heap_no != ULINT_UNDEFINED);
3381
space = wait_lock->un_member.rec_lock.space;
3382
page_no = wait_lock->un_member.rec_lock.page_no;
3384
lock = lock_rec_get_first_on_page_addr(space, page_no);
3386
/* Position the iterator on the first matching record lock. */
3388
&& lock != wait_lock
3389
&& !lock_rec_get_nth_bit(lock, heap_no)) {
3391
lock = lock_rec_get_next_on_page(lock);
3394
if (lock == wait_lock) {
3398
ut_ad(lock == NULL || lock_rec_get_nth_bit(lock, heap_no));
3404
/* Look at the locks ahead of wait_lock in the lock queue */
3407
/* Get previous table lock. */
3408
if (heap_no == ULINT_UNDEFINED) {
3410
lock = UT_LIST_GET_PREV(
3411
un_member.tab_lock.locks, lock);
3415
/* We can mark this subtree as searched */
3416
trx->deadlock_mark = 1;
3421
if (lock_has_to_wait(wait_lock, lock)) {
3424
= depth > LOCK_MAX_DEPTH_IN_DEADLOCK_CHECK
3425
|| *cost > LOCK_MAX_N_STEPS_IN_DEADLOCK_CHECK;
3427
lock_trx = lock->trx;
3429
if (lock_trx == start) {
3431
/* We came back to the recursion starting
3432
point: a deadlock detected; or we have
3433
searched the waits-for graph too long */
3435
FILE* ef = lock_latest_err_file;
3438
ut_print_timestamp(ef);
3440
fputs("\n*** (1) TRANSACTION:\n", ef);
3442
trx_print(ef, wait_lock->trx, 3000);
3444
fputs("*** (1) WAITING FOR THIS LOCK"
3445
" TO BE GRANTED:\n", ef);
3447
if (lock_get_type_low(wait_lock) == LOCK_REC) {
3448
lock_rec_print(ef, wait_lock);
3450
lock_table_print(ef, wait_lock);
3453
fputs("*** (2) TRANSACTION:\n", ef);
3455
trx_print(ef, lock->trx, 3000);
3457
fputs("*** (2) HOLDS THE LOCK(S):\n", ef);
3459
if (lock_get_type_low(lock) == LOCK_REC) {
3460
lock_rec_print(ef, lock);
3462
lock_table_print(ef, lock);
3465
fputs("*** (2) WAITING FOR THIS LOCK"
3466
" TO BE GRANTED:\n", ef);
3468
if (lock_get_type_low(start->wait_lock)
3470
lock_rec_print(ef, start->wait_lock);
3472
lock_table_print(ef, start->wait_lock);
3475
if (lock_print_waits) {
3476
fputs("Deadlock detected\n",
3479
#endif /* UNIV_DEBUG */
3481
if (trx_weight_ge(wait_lock->trx, start)) {
3482
/* Our recursion starting point
3483
transaction is 'smaller', let us
3484
choose 'start' as the victim and roll
3487
return(LOCK_VICTIM_IS_START);
3490
lock_deadlock_found = TRUE;
3492
/* Let us choose the transaction of wait_lock
3493
as a victim to try to avoid deadlocking our
3494
recursion starting point transaction */
3496
fputs("*** WE ROLL BACK TRANSACTION (1)\n",
3499
wait_lock->trx->was_chosen_as_deadlock_victim
3502
lock_cancel_waiting_and_release(wait_lock);
3504
/* Since trx and wait_lock are no longer
3505
in the waits-for graph, we can return FALSE;
3506
note that our selective algorithm can choose
3507
several transactions as victims, but still
3508
we may end up rolling back also the recursion
3509
starting point transaction! */
3511
return(LOCK_VICTIM_IS_OTHER);
3517
if (lock_print_waits) {
3518
fputs("Deadlock search exceeds"
3519
" max steps or depth.\n",
3522
#endif /* UNIV_DEBUG */
3523
/* The information about transaction/lock
3524
to be rolled back is available in the top
3525
level. Do not print anything here. */
3526
return(LOCK_EXCEED_MAX_DEPTH);
3529
if (lock_trx->que_state == TRX_QUE_LOCK_WAIT) {
3531
/* Another trx ahead has requested lock in an
3532
incompatible mode, and is itself waiting for
3535
ret = lock_deadlock_recursive(
3537
lock_trx->wait_lock, cost, depth + 1);
3545
/* Get the next record lock to check. */
3546
if (heap_no != ULINT_UNDEFINED) {
3551
lock = lock_rec_get_next_on_page(lock);
3552
} while (lock != NULL
3553
&& lock != wait_lock
3554
&& !lock_rec_get_nth_bit(lock, heap_no));
3556
if (lock == wait_lock) {
3560
}/* end of the 'for (;;)'-loop */
3563
/*========================= TABLE LOCKS ==============================*/
3565
/*********************************************************************//**
3566
Creates a table lock object and adds it as the last in the lock queue
3567
of the table. Does NOT check for deadlocks or lock compatibility.
3568
@return own: new lock object */
3573
dict_table_t* table, /*!< in: database table in dictionary cache */
3574
ulint type_mode,/*!< in: lock mode possibly ORed with
3576
trx_t* trx) /*!< in: trx */
3580
ut_ad(table && trx);
3581
ut_ad(mutex_own(&kernel_mutex));
3583
if ((type_mode & LOCK_MODE_MASK) == LOCK_AUTO_INC) {
3584
++table->n_waiting_or_granted_auto_inc_locks;
3587
/* For AUTOINC locking we reuse the lock instance only if
3588
there is no wait involved else we allocate the waiting lock
3589
from the transaction lock heap. */
3590
if (type_mode == LOCK_AUTO_INC) {
3592
lock = table->autoinc_lock;
3594
table->autoinc_trx = trx;
3596
ib_vector_push(trx->autoinc_locks, lock);
3598
lock = static_cast<lock_t *>(mem_heap_alloc(trx->lock_heap, sizeof(lock_t)));
3601
UT_LIST_ADD_LAST(trx_locks, trx->trx_locks, lock);
3603
lock->type_mode = type_mode | LOCK_TABLE;
3606
lock->un_member.tab_lock.table = table;
3608
UT_LIST_ADD_LAST(un_member.tab_lock.locks, table->locks, lock);
3610
if (UNIV_UNLIKELY(type_mode & LOCK_WAIT)) {
3612
lock_set_lock_and_trx_wait(lock, trx);
3618
/*************************************************************//**
3619
Removes a table lock request from the queue and the trx list of locks;
3620
this is a low-level function which does NOT check if waiting requests
3621
can now be granted. */
3624
lock_table_remove_low(
3625
/*==================*/
3626
lock_t* lock) /*!< in: table lock */
3629
dict_table_t* table;
3631
ut_ad(mutex_own(&kernel_mutex));
3634
table = lock->un_member.tab_lock.table;
3636
/* Remove the table from the transaction's AUTOINC vector, if
3637
the lock that is being release is an AUTOINC lock. */
3638
if (lock_get_mode(lock) == LOCK_AUTO_INC) {
3640
/* The table's AUTOINC lock can get transferred to
3641
another transaction before we get here. */
3642
if (table->autoinc_trx == trx) {
3643
table->autoinc_trx = NULL;
3646
/* The locks must be freed in the reverse order from
3647
the one in which they were acquired. This is to avoid
3648
traversing the AUTOINC lock vector unnecessarily.
3650
We only store locks that were granted in the
3651
trx->autoinc_locks vector (see lock_table_create()
3652
and lock_grant()). Therefore it can be empty and we
3653
need to check for that. */
3655
if (!lock_get_wait(lock)
3656
&& !ib_vector_is_empty(trx->autoinc_locks)) {
3657
lock_t* autoinc_lock;
3659
autoinc_lock = static_cast<lock_t *>(ib_vector_pop(trx->autoinc_locks));
3660
ut_a(autoinc_lock == lock);
3663
ut_a(table->n_waiting_or_granted_auto_inc_locks > 0);
3664
--table->n_waiting_or_granted_auto_inc_locks;
3667
UT_LIST_REMOVE(trx_locks, trx->trx_locks, lock);
3668
UT_LIST_REMOVE(un_member.tab_lock.locks, table->locks, lock);
3671
/*********************************************************************//**
3672
Enqueues a waiting request for a table lock which cannot be granted
3673
immediately. Checks for deadlocks.
3674
@return DB_LOCK_WAIT, DB_DEADLOCK, or DB_QUE_THR_SUSPENDED, or
3675
DB_SUCCESS; DB_SUCCESS means that there was a deadlock, but another
3676
transaction was chosen as a victim, and we got the lock immediately:
3677
no need to wait then */
3680
lock_table_enqueue_waiting(
3681
/*=======================*/
3682
ulint mode, /*!< in: lock mode this transaction is
3684
dict_table_t* table, /*!< in: table */
3685
que_thr_t* thr) /*!< in: query thread */
3690
ut_ad(mutex_own(&kernel_mutex));
3692
/* Test if there already is some other reason to suspend thread:
3693
we do not enqueue a lock request if the query thread should be
3696
if (que_thr_stop(thr)) {
3699
return(DB_QUE_THR_SUSPENDED);
3702
trx = thr_get_trx(thr);
3704
switch (trx_get_dict_operation(trx)) {
3705
case TRX_DICT_OP_NONE:
3707
case TRX_DICT_OP_TABLE:
3708
case TRX_DICT_OP_INDEX:
3709
ut_print_timestamp(stderr);
3710
fputs(" InnoDB: Error: a table lock wait happens"
3711
" in a dictionary operation!\n"
3712
"InnoDB: Table name ", stderr);
3713
ut_print_name(stderr, trx, TRUE, table->name);
3715
"InnoDB: Submit a detailed bug report"
3716
" to http://bugs.mysql.com\n",
3720
/* Enqueue the lock request that will wait to be granted */
3722
lock = lock_table_create(table, mode | LOCK_WAIT, trx);
3724
/* Check if a deadlock occurs: if yes, remove the lock request and
3725
return an error code */
3727
if (lock_deadlock_occurs(lock, trx)) {
3729
/* The order here is important, we don't want to
3730
lose the state of the lock before calling remove. */
3731
lock_table_remove_low(lock);
3732
lock_reset_lock_and_trx_wait(lock);
3734
return(DB_DEADLOCK);
3737
if (trx->wait_lock == NULL) {
3738
/* Deadlock resolution chose another transaction as a victim,
3739
and we accidentally got our lock granted! */
3741
return(DB_SUCCESS_LOCKED_REC);
3744
trx->que_state = TRX_QUE_LOCK_WAIT;
3745
trx->was_chosen_as_deadlock_victim = FALSE;
3746
trx->wait_started = time(NULL);
3748
ut_a(que_thr_stop(thr));
3750
return(DB_LOCK_WAIT);
3753
/*********************************************************************//**
3754
Checks if other transactions have an incompatible mode lock request in
3756
@return lock or NULL */
3759
lock_table_other_has_incompatible(
3760
/*==============================*/
3761
trx_t* trx, /*!< in: transaction, or NULL if all
3762
transactions should be included */
3763
ulint wait, /*!< in: LOCK_WAIT if also waiting locks are
3764
taken into account, or 0 if not */
3765
dict_table_t* table, /*!< in: table */
3766
enum lock_mode mode) /*!< in: lock mode */
3770
ut_ad(mutex_own(&kernel_mutex));
3772
lock = UT_LIST_GET_LAST(table->locks);
3774
while (lock != NULL) {
3776
if ((lock->trx != trx)
3777
&& (!lock_mode_compatible(lock_get_mode(lock), mode))
3778
&& (wait || !(lock_get_wait(lock)))) {
3783
lock = UT_LIST_GET_PREV(un_member.tab_lock.locks, lock);
3789
/*********************************************************************//**
3790
Locks the specified database table in the mode given. If the lock cannot
3791
be granted immediately, the query thread is put to wait.
3792
@return DB_SUCCESS, DB_LOCK_WAIT, DB_DEADLOCK, or DB_QUE_THR_SUSPENDED */
3797
ulint flags, /*!< in: if BTR_NO_LOCKING_FLAG bit is set,
3799
dict_table_t* table, /*!< in: database table in dictionary cache */
3800
enum lock_mode mode, /*!< in: lock mode */
3801
que_thr_t* thr) /*!< in: query thread */
3806
ut_ad(table && thr);
3808
if (flags & BTR_NO_LOCKING_FLAG) {
3810
return(DB_SUCCESS_LOCKED_REC);
3815
trx = thr_get_trx(thr);
3817
lock_mutex_enter_kernel();
3819
/* Look for stronger locks the same trx already has on the table */
3821
if (lock_table_has(trx, table, mode)) {
3823
lock_mutex_exit_kernel();
3828
/* We have to check if the new lock is compatible with any locks
3829
other transactions have in the table lock queue. */
3831
if (lock_table_other_has_incompatible(trx, LOCK_WAIT, table, mode)) {
3833
/* Another trx has a request on the table in an incompatible
3834
mode: this trx may have to wait */
3836
err = lock_table_enqueue_waiting(mode | flags, table, thr);
3838
lock_mutex_exit_kernel();
3843
lock_table_create(table, mode | flags, trx);
3845
ut_a(!flags || mode == LOCK_S || mode == LOCK_X);
3847
lock_mutex_exit_kernel();
3852
/*********************************************************************//**
3853
Checks if a waiting table lock request still has to wait in a queue.
3854
@return TRUE if still has to wait */
3857
lock_table_has_to_wait_in_queue(
3858
/*============================*/
3859
lock_t* wait_lock) /*!< in: waiting table lock */
3861
dict_table_t* table;
3864
ut_ad(mutex_own(&kernel_mutex));
3865
ut_ad(lock_get_wait(wait_lock));
3867
table = wait_lock->un_member.tab_lock.table;
3869
lock = UT_LIST_GET_FIRST(table->locks);
3871
while (lock != wait_lock) {
3873
if (lock_has_to_wait(wait_lock, lock)) {
3878
lock = UT_LIST_GET_NEXT(un_member.tab_lock.locks, lock);
3884
/*************************************************************//**
3885
Removes a table lock request, waiting or granted, from the queue and grants
3886
locks to other transactions in the queue, if they now are entitled to a
3892
lock_t* in_lock)/*!< in: table lock object; transactions waiting
3893
behind will get their lock requests granted, if
3894
they are now qualified to it */
3898
ut_ad(mutex_own(&kernel_mutex));
3899
ut_a(lock_get_type_low(in_lock) == LOCK_TABLE);
3901
lock = UT_LIST_GET_NEXT(un_member.tab_lock.locks, in_lock);
3903
lock_table_remove_low(in_lock);
3905
/* Check if waiting locks in the queue can now be granted: grant
3906
locks if there are no conflicting locks ahead. */
3908
while (lock != NULL) {
3910
if (lock_get_wait(lock)
3911
&& !lock_table_has_to_wait_in_queue(lock)) {
3913
/* Grant the lock */
3917
lock = UT_LIST_GET_NEXT(un_member.tab_lock.locks, lock);
3921
/*=========================== LOCK RELEASE ==============================*/
3923
/*************************************************************//**
3924
Removes a granted record lock of a transaction from the queue and grants
3925
locks to other transactions waiting in the queue if they now are entitled
3931
trx_t* trx, /*!< in: transaction that has
3932
set a record lock */
3933
const buf_block_t* block, /*!< in: buffer block containing rec */
3934
const rec_t* rec, /*!< in: record */
3935
enum lock_mode lock_mode)/*!< in: LOCK_S or LOCK_X */
3942
ut_ad(block->frame == page_align(rec));
3944
heap_no = page_rec_get_heap_no(rec);
3946
mutex_enter(&kernel_mutex);
3948
first_lock = lock_rec_get_first(block, heap_no);
3950
/* Find the last lock with the same lock_mode and transaction
3953
for (lock = first_lock; lock != NULL;
3954
lock = lock_rec_get_next(heap_no, lock)) {
3955
if (lock->trx == trx && lock_get_mode(lock) == lock_mode) {
3956
ut_a(!lock_get_wait(lock));
3957
lock_rec_reset_nth_bit(lock, heap_no);
3962
mutex_exit(&kernel_mutex);
3963
ut_print_timestamp(stderr);
3965
" InnoDB: Error: unlock row could not"
3966
" find a %lu mode lock on the record\n",
3972
/* Check if we can now grant waiting lock requests */
3974
for (lock = first_lock; lock != NULL;
3975
lock = lock_rec_get_next(heap_no, lock)) {
3976
if (lock_get_wait(lock)
3977
&& !lock_rec_has_to_wait_in_queue(lock)) {
3979
/* Grant the lock */
3984
mutex_exit(&kernel_mutex);
3987
/*********************************************************************//**
3988
Releases transaction locks, and releases possible other transactions waiting
3989
because of these locks. */
3992
lock_release_off_kernel(
3993
/*====================*/
3994
trx_t* trx) /*!< in: transaction */
3996
dict_table_t* table;
4000
ut_ad(mutex_own(&kernel_mutex));
4002
lock = UT_LIST_GET_LAST(trx->trx_locks);
4006
while (lock != NULL) {
4010
if (lock_get_type_low(lock) == LOCK_REC) {
4012
lock_rec_dequeue_from_page(lock);
4014
ut_ad(lock_get_type_low(lock) & LOCK_TABLE);
4016
if (lock_get_mode(lock) != LOCK_IS
4017
&& trx->undo_no != 0) {
4019
/* The trx may have modified the table. We
4020
block the use of the MySQL query cache for
4021
all currently active transactions. */
4023
table = lock->un_member.tab_lock.table;
4025
table->query_cache_inv_trx_id
4026
= trx_sys->max_trx_id;
4029
lock_table_dequeue(lock);
4032
if (count == LOCK_RELEASE_KERNEL_INTERVAL) {
4033
/* Release the kernel mutex for a while, so that we
4034
do not monopolize it */
4036
lock_mutex_exit_kernel();
4038
lock_mutex_enter_kernel();
4043
lock = UT_LIST_GET_LAST(trx->trx_locks);
4046
ut_a(ib_vector_size(trx->autoinc_locks) == 0);
4048
mem_heap_empty(trx->lock_heap);
4051
/*********************************************************************//**
4052
Cancels a waiting lock request and releases possible other transactions
4053
waiting behind it. */
4056
lock_cancel_waiting_and_release(
4057
/*============================*/
4058
lock_t* lock) /*!< in: waiting lock request */
4060
ut_ad(mutex_own(&kernel_mutex));
4062
if (lock_get_type_low(lock) == LOCK_REC) {
4064
lock_rec_dequeue_from_page(lock);
4066
ut_ad(lock_get_type_low(lock) & LOCK_TABLE);
4068
if (lock->trx->autoinc_locks != NULL) {
4069
/* Release the transaction's AUTOINC locks/ */
4070
lock_release_autoinc_locks(lock->trx);
4073
lock_table_dequeue(lock);
4076
/* Reset the wait flag and the back pointer to lock in trx */
4078
lock_reset_lock_and_trx_wait(lock);
4080
/* The following function releases the trx from lock wait */
4082
trx_end_lock_wait(lock->trx);
4085
/* True if a lock mode is S or X */
4086
#define IS_LOCK_S_OR_X(lock) \
4087
(lock_get_mode(lock) == LOCK_S \
4088
|| lock_get_mode(lock) == LOCK_X)
4091
/*********************************************************************//**
4092
Removes locks of a transaction on a table to be dropped.
4093
If remove_also_table_sx_locks is TRUE then table-level S and X locks are
4094
also removed in addition to other table-level and record-level locks.
4095
No lock, that is going to be removed, is allowed to be a wait lock. */
4098
lock_remove_all_on_table_for_trx(
4099
/*=============================*/
4100
dict_table_t* table, /*!< in: table to be dropped */
4101
trx_t* trx, /*!< in: a transaction */
4102
ibool remove_also_table_sx_locks)/*!< in: also removes
4103
table S and X locks */
4108
ut_ad(mutex_own(&kernel_mutex));
4110
lock = UT_LIST_GET_LAST(trx->trx_locks);
4112
while (lock != NULL) {
4113
prev_lock = UT_LIST_GET_PREV(trx_locks, lock);
4115
if (lock_get_type_low(lock) == LOCK_REC
4116
&& lock->index->table == table) {
4117
ut_a(!lock_get_wait(lock));
4119
lock_rec_discard(lock);
4120
} else if (lock_get_type_low(lock) & LOCK_TABLE
4121
&& lock->un_member.tab_lock.table == table
4122
&& (remove_also_table_sx_locks
4123
|| !IS_LOCK_S_OR_X(lock))) {
4125
ut_a(!lock_get_wait(lock));
4127
lock_table_remove_low(lock);
4134
/*********************************************************************//**
4135
Removes locks on a table to be dropped or truncated.
4136
If remove_also_table_sx_locks is TRUE then table-level S and X locks are
4137
also removed in addition to other table-level and record-level locks.
4138
No lock, that is going to be removed, is allowed to be a wait lock. */
4141
lock_remove_all_on_table(
4142
/*=====================*/
4143
dict_table_t* table, /*!< in: table to be dropped
4145
ibool remove_also_table_sx_locks)/*!< in: also removes
4146
table S and X locks */
4151
mutex_enter(&kernel_mutex);
4153
lock = UT_LIST_GET_FIRST(table->locks);
4155
while (lock != NULL) {
4157
prev_lock = UT_LIST_GET_PREV(un_member.tab_lock.locks,
4160
/* If we should remove all locks (remove_also_table_sx_locks
4161
is TRUE), or if the lock is not table-level S or X lock,
4162
then check we are not going to remove a wait lock. */
4163
if (remove_also_table_sx_locks
4164
|| !(lock_get_type(lock) == LOCK_TABLE
4165
&& IS_LOCK_S_OR_X(lock))) {
4167
ut_a(!lock_get_wait(lock));
4170
lock_remove_all_on_table_for_trx(table, lock->trx,
4171
remove_also_table_sx_locks);
4173
if (prev_lock == NULL) {
4174
if (lock == UT_LIST_GET_FIRST(table->locks)) {
4175
/* lock was not removed, pick its successor */
4176
lock = UT_LIST_GET_NEXT(
4177
un_member.tab_lock.locks, lock);
4179
/* lock was removed, pick the first one */
4180
lock = UT_LIST_GET_FIRST(table->locks);
4182
} else if (UT_LIST_GET_NEXT(un_member.tab_lock.locks,
4183
prev_lock) != lock) {
4184
/* If lock was removed by
4185
lock_remove_all_on_table_for_trx() then pick the
4186
successor of prev_lock ... */
4187
lock = UT_LIST_GET_NEXT(
4188
un_member.tab_lock.locks, prev_lock);
4190
/* ... otherwise pick the successor of lock. */
4191
lock = UT_LIST_GET_NEXT(
4192
un_member.tab_lock.locks, lock);
4196
mutex_exit(&kernel_mutex);
4199
/*===================== VALIDATION AND DEBUGGING ====================*/
4201
/*********************************************************************//**
4202
Prints info of a table lock. */
4207
FILE* file, /*!< in: file where to print */
4208
const lock_t* lock) /*!< in: table type lock */
4210
ut_ad(mutex_own(&kernel_mutex));
4211
ut_a(lock_get_type_low(lock) == LOCK_TABLE);
4213
fputs("TABLE LOCK table ", file);
4214
ut_print_name(file, lock->trx, TRUE,
4215
lock->un_member.tab_lock.table->name);
4216
fprintf(file, " trx id " TRX_ID_FMT, lock->trx->id);
4218
if (lock_get_mode(lock) == LOCK_S) {
4219
fputs(" lock mode S", file);
4220
} else if (lock_get_mode(lock) == LOCK_X) {
4221
fputs(" lock mode X", file);
4222
} else if (lock_get_mode(lock) == LOCK_IS) {
4223
fputs(" lock mode IS", file);
4224
} else if (lock_get_mode(lock) == LOCK_IX) {
4225
fputs(" lock mode IX", file);
4226
} else if (lock_get_mode(lock) == LOCK_AUTO_INC) {
4227
fputs(" lock mode AUTO-INC", file);
4229
fprintf(file, " unknown lock mode %lu",
4230
(ulong) lock_get_mode(lock));
4233
if (lock_get_wait(lock)) {
4234
fputs(" waiting", file);
4240
/*********************************************************************//**
4241
Prints info of a record lock. */
4246
FILE* file, /*!< in: file where to print */
4247
const lock_t* lock) /*!< in: record type lock */
4249
const buf_block_t* block;
4254
mem_heap_t* heap = NULL;
4255
ulint offsets_[REC_OFFS_NORMAL_SIZE];
4256
ulint* offsets = offsets_;
4257
rec_offs_init(offsets_);
4259
ut_ad(mutex_own(&kernel_mutex));
4260
ut_a(lock_get_type_low(lock) == LOCK_REC);
4262
space = lock->un_member.rec_lock.space;
4263
page_no = lock->un_member.rec_lock.page_no;
4265
fprintf(file, "RECORD LOCKS space id %lu page no %lu n bits %lu ",
4266
(ulong) space, (ulong) page_no,
4267
(ulong) lock_rec_get_n_bits(lock));
4268
dict_index_name_print(file, lock->trx, lock->index);
4269
fprintf(file, " trx id " TRX_ID_FMT, lock->trx->id);
4271
if (lock_get_mode(lock) == LOCK_S) {
4272
fputs(" lock mode S", file);
4273
} else if (lock_get_mode(lock) == LOCK_X) {
4274
fputs(" lock_mode X", file);
4279
if (lock_rec_get_gap(lock)) {
4280
fputs(" locks gap before rec", file);
4283
if (lock_rec_get_rec_not_gap(lock)) {
4284
fputs(" locks rec but not gap", file);
4287
if (lock_rec_get_insert_intention(lock)) {
4288
fputs(" insert intention", file);
4291
if (lock_get_wait(lock)) {
4292
fputs(" waiting", file);
4299
block = buf_page_try_get(space, page_no, &mtr);
4301
for (i = 0; i < lock_rec_get_n_bits(lock); ++i) {
4303
if (!lock_rec_get_nth_bit(lock, i)) {
4307
fprintf(file, "Record lock, heap no %lu", (ulong) i);
4312
rec = page_find_rec_with_heap_no(
4313
buf_block_get_frame(block), i);
4315
offsets = rec_get_offsets(
4316
rec, lock->index, offsets,
4317
ULINT_UNDEFINED, &heap);
4320
rec_print_new(file, rec, offsets);
4327
if (UNIV_LIKELY_NULL(heap)) {
4328
mem_heap_free(heap);
4333
/* Print the number of lock structs from lock_print_info_summary() only
4334
in non-production builds for performance reasons, see
4335
http://bugs.mysql.com/36942 */
4336
#define PRINT_NUM_OF_LOCK_STRUCTS
4337
#endif /* UNIV_DEBUG */
4339
#ifdef PRINT_NUM_OF_LOCK_STRUCTS
4340
/*********************************************************************//**
4341
Calculates the number of record lock structs in the record lock hash table.
4342
@return number of record locks */
4345
lock_get_n_rec_locks(void)
4346
/*======================*/
4352
ut_ad(mutex_own(&kernel_mutex));
4354
for (i = 0; i < hash_get_n_cells(lock_sys->rec_hash); i++) {
4356
lock = HASH_GET_FIRST(lock_sys->rec_hash, i);
4361
lock = HASH_GET_NEXT(hash, lock);
4367
#endif /* PRINT_NUM_OF_LOCK_STRUCTS */
4369
/*********************************************************************//**
4370
Prints info of locks for all transactions.
4371
@return FALSE if not able to obtain kernel mutex
4372
and exits without printing info */
4375
lock_print_info_summary(
4376
/*====================*/
4377
FILE* file, /*!< in: file where to print */
4378
ibool nowait) /*!< in: whether to wait for the kernel mutex */
4380
/* if nowait is FALSE, wait on the kernel mutex,
4381
otherwise return immediately if fail to obtain the
4384
lock_mutex_enter_kernel();
4385
} else if (mutex_enter_nowait(&kernel_mutex)) {
4386
fputs("FAIL TO OBTAIN KERNEL MUTEX, "
4387
"SKIP LOCK INFO PRINTING\n", file);
4391
if (lock_deadlock_found) {
4392
fputs("------------------------\n"
4393
"LATEST DETECTED DEADLOCK\n"
4394
"------------------------\n", file);
4396
ut_copy_file(file, lock_latest_err_file);
4399
fputs("------------\n"
4401
"------------\n", file);
4403
fprintf(file, "Trx id counter " TRX_ID_FMT "\n",
4404
trx_sys->max_trx_id);
4407
"Purge done for trx's n:o < " TRX_ID_FMT
4408
" undo n:o < " TRX_ID_FMT "\n",
4409
purge_sys->purge_trx_no,
4410
purge_sys->purge_undo_no);
4413
"History list length %lu\n",
4414
(ulong) trx_sys->rseg_history_len);
4416
#ifdef PRINT_NUM_OF_LOCK_STRUCTS
4418
"Total number of lock structs in row lock hash table %lu\n",
4419
(ulong) lock_get_n_rec_locks());
4420
#endif /* PRINT_NUM_OF_LOCK_STRUCTS */
4424
/*********************************************************************//**
4425
Prints info of locks for each transaction. */
4428
lock_print_info_all_transactions(
4429
/*=============================*/
4430
FILE* file) /*!< in: file where to print */
4433
ibool load_page_first = TRUE;
4440
fprintf(file, "LIST OF TRANSACTIONS FOR EACH SESSION:\n");
4442
/* First print info on non-active transactions */
4444
trx = UT_LIST_GET_FIRST(trx_sys->mysql_trx_list);
4447
if (trx->conc_state == TRX_NOT_STARTED) {
4449
trx_print(file, trx, 600);
4452
trx = UT_LIST_GET_NEXT(mysql_trx_list, trx);
4456
trx = UT_LIST_GET_FIRST(trx_sys->trx_list);
4460
/* Since we temporarily release the kernel mutex when
4461
reading a database page in below, variable trx may be
4462
obsolete now and we must loop through the trx list to
4463
get probably the same trx, or some other trx. */
4465
while (trx && (i < nth_trx)) {
4466
trx = UT_LIST_GET_NEXT(trx_list, trx);
4471
lock_mutex_exit_kernel();
4473
ut_ad(lock_validate());
4478
if (nth_lock == 0) {
4480
trx_print(file, trx, 600);
4482
if (trx->read_view) {
4484
"Trx read view will not see trx with"
4485
" id >= " TRX_ID_FMT
4486
", sees < " TRX_ID_FMT "\n",
4487
trx->read_view->low_limit_id,
4488
trx->read_view->up_limit_id);
4491
if (trx->que_state == TRX_QUE_LOCK_WAIT) {
4493
"------- TRX HAS BEEN WAITING %lu SEC"
4494
" FOR THIS LOCK TO BE GRANTED:\n",
4495
(ulong) difftime(time(NULL),
4496
trx->wait_started));
4498
if (lock_get_type_low(trx->wait_lock) == LOCK_REC) {
4499
lock_rec_print(file, trx->wait_lock);
4501
lock_table_print(file, trx->wait_lock);
4504
fputs("------------------\n", file);
4508
if (!srv_print_innodb_lock_monitor) {
4515
/* Look at the note about the trx loop above why we loop here:
4516
lock may be an obsolete pointer now. */
4518
lock = UT_LIST_GET_FIRST(trx->trx_locks);
4520
while (lock && (i < nth_lock)) {
4521
lock = UT_LIST_GET_NEXT(trx_locks, lock);
4532
if (lock_get_type_low(lock) == LOCK_REC) {
4533
if (load_page_first) {
4534
ulint space = lock->un_member.rec_lock.space;
4535
ulint zip_size= fil_space_get_zip_size(space);
4536
ulint page_no = lock->un_member.rec_lock.page_no;
4538
if (UNIV_UNLIKELY(zip_size == ULINT_UNDEFINED)) {
4540
/* It is a single table tablespace and
4541
the .ibd file is missing (TRUNCATE
4542
TABLE probably stole the locks): just
4543
print the lock without attempting to
4544
load the page in the buffer pool. */
4546
fprintf(file, "RECORD LOCKS on"
4547
" non-existing space %lu\n",
4552
lock_mutex_exit_kernel();
4556
buf_page_get_with_no_latch(space, zip_size,
4561
load_page_first = FALSE;
4563
lock_mutex_enter_kernel();
4569
lock_rec_print(file, lock);
4571
ut_ad(lock_get_type_low(lock) & LOCK_TABLE);
4573
lock_table_print(file, lock);
4576
load_page_first = TRUE;
4580
if (nth_lock >= 10) {
4581
fputs("10 LOCKS PRINTED FOR THIS TRX:"
4582
" SUPPRESSING FURTHER PRINTS\n",
4595
/*********************************************************************//**
4596
Validates the lock queue on a table.
4597
@return TRUE if ok */
4600
lock_table_queue_validate(
4601
/*======================*/
4602
dict_table_t* table) /*!< in: table */
4606
ut_ad(mutex_own(&kernel_mutex));
4608
lock = UT_LIST_GET_FIRST(table->locks);
4611
ut_a(((lock->trx)->conc_state == TRX_ACTIVE)
4612
|| ((lock->trx)->conc_state == TRX_PREPARED)
4613
|| ((lock->trx)->conc_state == TRX_COMMITTED_IN_MEMORY));
4615
if (!lock_get_wait(lock)) {
4617
ut_a(!lock_table_other_has_incompatible(
4618
lock->trx, 0, table,
4619
lock_get_mode(lock)));
4622
ut_a(lock_table_has_to_wait_in_queue(lock));
4625
lock = UT_LIST_GET_NEXT(un_member.tab_lock.locks, lock);
4631
/*********************************************************************//**
4632
Validates the lock queue on a single record.
4633
@return TRUE if ok */
4636
lock_rec_queue_validate(
4637
/*====================*/
4638
const buf_block_t* block, /*!< in: buffer block containing rec */
4639
const rec_t* rec, /*!< in: record to look at */
4640
dict_index_t* index, /*!< in: index, or NULL if not known */
4641
const ulint* offsets)/*!< in: rec_get_offsets(rec, index) */
4648
ut_a(block->frame == page_align(rec));
4649
ut_ad(rec_offs_validate(rec, index, offsets));
4650
ut_ad(!page_rec_is_comp(rec) == !rec_offs_comp(offsets));
4652
heap_no = page_rec_get_heap_no(rec);
4654
lock_mutex_enter_kernel();
4656
if (!page_rec_is_user_rec(rec)) {
4658
lock = lock_rec_get_first(block, heap_no);
4661
switch(lock->trx->conc_state) {
4664
case TRX_COMMITTED_IN_MEMORY:
4670
ut_a(trx_in_trx_list(lock->trx));
4672
if (lock_get_wait(lock)) {
4673
ut_a(lock_rec_has_to_wait_in_queue(lock));
4677
ut_a(lock->index == index);
4680
lock = lock_rec_get_next(heap_no, lock);
4683
lock_mutex_exit_kernel();
4689
else if (dict_index_is_clust(index)) {
4691
impl_trx = lock_clust_rec_some_has_impl(rec, index, offsets);
4694
&& lock_rec_other_has_expl_req(LOCK_S, 0, LOCK_WAIT,
4695
block, heap_no, impl_trx)) {
4697
ut_a(lock_rec_has_expl(LOCK_X | LOCK_REC_NOT_GAP,
4698
block, heap_no, impl_trx));
4703
/* The kernel mutex may get released temporarily in the
4704
next function call: we have to release lock table mutex
4705
to obey the latching order */
4707
/* If this thread is holding the file space latch
4708
(fil_space_t::latch), the following check WILL break
4709
latching order and may cause a deadlock of threads. */
4711
/* NOTE: This is a bogus check that would fail in the
4712
following case: Our transaction is updating a
4713
row. After it has updated the clustered index record,
4714
it goes to a secondary index record and finds someone
4715
else holding an explicit S- or X-lock on that
4716
secondary index record, presumably from a locking
4717
read. Our transaction cannot update the secondary
4718
index immediately, but places a waiting X-lock request
4719
on the secondary index record. There is nothing
4720
illegal in this. The assertion is simply too strong. */
4722
/* From the locking point of view, each secondary
4723
index is a separate table. A lock that is held on
4724
secondary index rec does not give any rights to modify
4725
or read the clustered index rec. Therefore, we can
4726
think of the sec index as a separate 'table' from the
4727
clust index 'table'. Conversely, a transaction that
4728
has acquired a lock on and modified a clustered index
4729
record may need to wait for a lock on the
4730
corresponding record in a secondary index. */
4732
impl_trx = lock_sec_rec_some_has_impl_off_kernel(
4733
rec, index, offsets);
4736
&& lock_rec_other_has_expl_req(LOCK_S, 0, LOCK_WAIT,
4737
block, heap_no, impl_trx)) {
4739
ut_a(lock_rec_has_expl(LOCK_X | LOCK_REC_NOT_GAP,
4740
block, heap_no, impl_trx));
4745
lock = lock_rec_get_first(block, heap_no);
4748
ut_a(lock->trx->conc_state == TRX_ACTIVE
4749
|| lock->trx->conc_state == TRX_PREPARED
4750
|| lock->trx->conc_state == TRX_COMMITTED_IN_MEMORY);
4751
ut_a(trx_in_trx_list(lock->trx));
4754
ut_a(lock->index == index);
4757
if (!lock_rec_get_gap(lock) && !lock_get_wait(lock)) {
4759
enum lock_mode mode;
4761
if (lock_get_mode(lock) == LOCK_S) {
4766
ut_a(!lock_rec_other_has_expl_req(
4767
mode, 0, 0, block, heap_no, lock->trx));
4769
} else if (lock_get_wait(lock) && !lock_rec_get_gap(lock)) {
4771
ut_a(lock_rec_has_to_wait_in_queue(lock));
4774
lock = lock_rec_get_next(heap_no, lock);
4777
lock_mutex_exit_kernel();
4782
/*********************************************************************//**
4783
Validates the record lock queues on a page.
4784
@return TRUE if ok */
4787
lock_rec_validate_page(
4788
/*===================*/
4789
ulint space, /*!< in: space id */
4790
ulint page_no)/*!< in: page number */
4792
dict_index_t* index;
4802
mem_heap_t* heap = NULL;
4803
ulint offsets_[REC_OFFS_NORMAL_SIZE];
4804
ulint* offsets = offsets_;
4805
rec_offs_init(offsets_);
4807
ut_ad(!mutex_own(&kernel_mutex));
4811
zip_size = fil_space_get_zip_size(space);
4812
ut_ad(zip_size != ULINT_UNDEFINED);
4813
block = buf_page_get(space, zip_size, page_no, RW_X_LATCH, &mtr);
4814
buf_block_dbg_add_level(block, SYNC_NO_ORDER_CHECK);
4816
page = block->frame;
4818
lock_mutex_enter_kernel();
4820
lock = lock_rec_get_first_on_page_addr(space, page_no);
4826
for (i = 0; i < nth_lock; i++) {
4828
lock = lock_rec_get_next_on_page(lock);
4835
ut_a(trx_in_trx_list(lock->trx));
4836
ut_a(lock->trx->conc_state == TRX_ACTIVE
4837
|| lock->trx->conc_state == TRX_PREPARED
4838
|| lock->trx->conc_state == TRX_COMMITTED_IN_MEMORY);
4840
# ifdef UNIV_SYNC_DEBUG
4841
/* Only validate the record queues when this thread is not
4842
holding a space->latch. Deadlocks are possible due to
4843
latching order violation when UNIV_DEBUG is defined while
4844
UNIV_SYNC_DEBUG is not. */
4845
if (!sync_thread_levels_contains(SYNC_FSP))
4846
# endif /* UNIV_SYNC_DEBUG */
4847
for (i = nth_bit; i < lock_rec_get_n_bits(lock); i++) {
4849
if (i == 1 || lock_rec_get_nth_bit(lock, i)) {
4851
index = lock->index;
4852
rec = page_find_rec_with_heap_no(page, i);
4854
offsets = rec_get_offsets(rec, index, offsets,
4855
ULINT_UNDEFINED, &heap);
4858
"Validating %lu %lu\n",
4859
(ulong) space, (ulong) page_no);
4861
lock_mutex_exit_kernel();
4863
/* If this thread is holding the file space
4864
latch (fil_space_t::latch), the following
4865
check WILL break the latching order and may
4866
cause a deadlock of threads. */
4868
lock_rec_queue_validate(block, rec, index, offsets);
4870
lock_mutex_enter_kernel();
4884
lock_mutex_exit_kernel();
4888
if (UNIV_LIKELY_NULL(heap)) {
4889
mem_heap_free(heap);
4894
/*********************************************************************//**
4895
Validates the lock system.
4896
@return TRUE if ok */
4909
lock_mutex_enter_kernel();
4911
trx = UT_LIST_GET_FIRST(trx_sys->trx_list);
4914
lock = UT_LIST_GET_FIRST(trx->trx_locks);
4917
if (lock_get_type_low(lock) & LOCK_TABLE) {
4919
lock_table_queue_validate(
4920
lock->un_member.tab_lock.table);
4923
lock = UT_LIST_GET_NEXT(trx_locks, lock);
4926
trx = UT_LIST_GET_NEXT(trx_list, trx);
4929
for (i = 0; i < hash_get_n_cells(lock_sys->rec_hash); i++) {
4934
lock = HASH_GET_FIRST(lock_sys->rec_hash, i);
4937
ib_uint64_t space_page;
4938
ut_a(trx_in_trx_list(lock->trx));
4940
space = lock->un_member.rec_lock.space;
4941
page_no = lock->un_member.rec_lock.page_no;
4943
space_page = ut_ull_create(space, page_no);
4945
if (space_page >= limit) {
4949
lock = HASH_GET_NEXT(hash, lock);
4957
lock_mutex_exit_kernel();
4959
lock_rec_validate_page(space, page_no);
4961
lock_mutex_enter_kernel();
4963
limit = ut_ull_create(space, page_no + 1);
4967
lock_mutex_exit_kernel();
4971
#endif /* UNIV_DEBUG */
4972
/*============ RECORD LOCK CHECKS FOR ROW OPERATIONS ====================*/
4974
/*********************************************************************//**
4975
Checks if locks of other transactions prevent an immediate insert of
4976
a record. If they do, first tests if the query thread should anyway
4977
be suspended for some reason; if not, then puts the transaction and
4978
the query thread to the lock wait state and inserts a waiting request
4979
for a gap x-lock to the lock queue.
4980
@return DB_SUCCESS, DB_LOCK_WAIT, DB_DEADLOCK, or DB_QUE_THR_SUSPENDED */
4983
lock_rec_insert_check_and_lock(
4984
/*===========================*/
4985
ulint flags, /*!< in: if BTR_NO_LOCKING_FLAG bit is
4986
set, does nothing */
4987
const rec_t* rec, /*!< in: record after which to insert */
4988
buf_block_t* block, /*!< in/out: buffer block of rec */
4989
dict_index_t* index, /*!< in: index */
4990
que_thr_t* thr, /*!< in: query thread */
4991
mtr_t* mtr, /*!< in/out: mini-transaction */
4992
ibool* inherit)/*!< out: set to TRUE if the new
4993
inserted record maybe should inherit
4994
LOCK_GAP type locks from the successor
4997
const rec_t* next_rec;
5001
ulint next_rec_heap_no;
5003
ut_ad(block->frame == page_align(rec));
5005
if (flags & BTR_NO_LOCKING_FLAG) {
5010
trx = thr_get_trx(thr);
5011
next_rec = page_rec_get_next_const(rec);
5012
next_rec_heap_no = page_rec_get_heap_no(next_rec);
5014
lock_mutex_enter_kernel();
5016
/* When inserting a record into an index, the table must be at
5017
least IX-locked or we must be building an index, in which case
5018
the table must be at least S-locked. */
5019
ut_ad(lock_table_has(trx, index->table, LOCK_IX)
5020
|| (*index->name == TEMP_INDEX_PREFIX
5021
&& lock_table_has(trx, index->table, LOCK_S)));
5023
lock = lock_rec_get_first(block, next_rec_heap_no);
5025
if (UNIV_LIKELY(lock == NULL)) {
5026
/* We optimize CPU time usage in the simplest case */
5028
lock_mutex_exit_kernel();
5030
if (!dict_index_is_clust(index)) {
5031
/* Update the page max trx id field */
5032
page_update_max_trx_id(block,
5033
buf_block_get_page_zip(block),
5044
/* If another transaction has an explicit lock request which locks
5045
the gap, waiting or granted, on the successor, the insert has to wait.
5047
An exception is the case where the lock by the another transaction
5048
is a gap type lock which it placed to wait for its turn to insert. We
5049
do not consider that kind of a lock conflicting with our insert. This
5050
eliminates an unnecessary deadlock which resulted when 2 transactions
5051
had to wait for their insert. Both had waiting gap type lock requests
5052
on the successor, which produced an unnecessary deadlock. */
5054
if (lock_rec_other_has_conflicting(
5055
static_cast<lock_mode>(LOCK_X | LOCK_GAP | LOCK_INSERT_INTENTION),
5056
block, next_rec_heap_no, trx)) {
5058
/* Note that we may get DB_SUCCESS also here! */
5059
err = lock_rec_enqueue_waiting(LOCK_X | LOCK_GAP
5060
| LOCK_INSERT_INTENTION,
5061
block, next_rec_heap_no,
5067
lock_mutex_exit_kernel();
5070
case DB_SUCCESS_LOCKED_REC:
5074
if (dict_index_is_clust(index)) {
5077
/* Update the page max trx id field */
5078
page_update_max_trx_id(block,
5079
buf_block_get_page_zip(block),
5085
mem_heap_t* heap = NULL;
5086
ulint offsets_[REC_OFFS_NORMAL_SIZE];
5087
const ulint* offsets;
5088
rec_offs_init(offsets_);
5090
offsets = rec_get_offsets(next_rec, index, offsets_,
5091
ULINT_UNDEFINED, &heap);
5092
ut_ad(lock_rec_queue_validate(block,
5093
next_rec, index, offsets));
5094
if (UNIV_LIKELY_NULL(heap)) {
5095
mem_heap_free(heap);
5098
#endif /* UNIV_DEBUG */
5103
/*********************************************************************//**
5104
If a transaction has an implicit x-lock on a record, but no explicit x-lock
5105
set on the record, sets one for it. NOTE that in the case of a secondary
5106
index, the kernel mutex may get temporarily released. */
5109
lock_rec_convert_impl_to_expl(
5110
/*==========================*/
5111
const buf_block_t* block, /*!< in: buffer block of rec */
5112
const rec_t* rec, /*!< in: user record on page */
5113
dict_index_t* index, /*!< in: index of record */
5114
const ulint* offsets)/*!< in: rec_get_offsets(rec, index) */
5118
ut_ad(mutex_own(&kernel_mutex));
5119
ut_ad(page_rec_is_user_rec(rec));
5120
ut_ad(rec_offs_validate(rec, index, offsets));
5121
ut_ad(!page_rec_is_comp(rec) == !rec_offs_comp(offsets));
5123
if (dict_index_is_clust(index)) {
5124
impl_trx = lock_clust_rec_some_has_impl(rec, index, offsets);
5126
impl_trx = lock_sec_rec_some_has_impl_off_kernel(
5127
rec, index, offsets);
5131
ulint heap_no = page_rec_get_heap_no(rec);
5133
/* If the transaction has no explicit x-lock set on the
5134
record, set one for it */
5136
if (!lock_rec_has_expl(LOCK_X | LOCK_REC_NOT_GAP, block,
5137
heap_no, impl_trx)) {
5139
lock_rec_add_to_queue(
5140
LOCK_REC | LOCK_X | LOCK_REC_NOT_GAP,
5141
block, heap_no, index, impl_trx);
5146
/*********************************************************************//**
5147
Checks if locks of other transactions prevent an immediate modify (update,
5148
delete mark, or delete unmark) of a clustered index record. If they do,
5149
first tests if the query thread should anyway be suspended for some
5150
reason; if not, then puts the transaction and the query thread to the
5151
lock wait state and inserts a waiting request for a record x-lock to the
5153
@return DB_SUCCESS, DB_LOCK_WAIT, DB_DEADLOCK, or DB_QUE_THR_SUSPENDED */
5156
lock_clust_rec_modify_check_and_lock(
5157
/*=================================*/
5158
ulint flags, /*!< in: if BTR_NO_LOCKING_FLAG
5159
bit is set, does nothing */
5160
const buf_block_t* block, /*!< in: buffer block of rec */
5161
const rec_t* rec, /*!< in: record which should be
5163
dict_index_t* index, /*!< in: clustered index */
5164
const ulint* offsets,/*!< in: rec_get_offsets(rec, index) */
5165
que_thr_t* thr) /*!< in: query thread */
5170
ut_ad(rec_offs_validate(rec, index, offsets));
5171
ut_ad(dict_index_is_clust(index));
5172
ut_ad(block->frame == page_align(rec));
5174
if (flags & BTR_NO_LOCKING_FLAG) {
5179
heap_no = rec_offs_comp(offsets)
5180
? rec_get_heap_no_new(rec)
5181
: rec_get_heap_no_old(rec);
5183
lock_mutex_enter_kernel();
5185
ut_ad(lock_table_has(thr_get_trx(thr), index->table, LOCK_IX));
5187
/* If a transaction has no explicit x-lock set on the record, set one
5190
lock_rec_convert_impl_to_expl(block, rec, index, offsets);
5192
err = lock_rec_lock(TRUE, LOCK_X | LOCK_REC_NOT_GAP,
5193
block, heap_no, index, thr);
5195
lock_mutex_exit_kernel();
5197
ut_ad(lock_rec_queue_validate(block, rec, index, offsets));
5199
if (UNIV_UNLIKELY(err == DB_SUCCESS_LOCKED_REC)) {
5206
/*********************************************************************//**
5207
Checks if locks of other transactions prevent an immediate modify (delete
5208
mark or delete unmark) of a secondary index record.
5209
@return DB_SUCCESS, DB_LOCK_WAIT, DB_DEADLOCK, or DB_QUE_THR_SUSPENDED */
5212
lock_sec_rec_modify_check_and_lock(
5213
/*===============================*/
5214
ulint flags, /*!< in: if BTR_NO_LOCKING_FLAG
5215
bit is set, does nothing */
5216
buf_block_t* block, /*!< in/out: buffer block of rec */
5217
const rec_t* rec, /*!< in: record which should be
5218
modified; NOTE: as this is a secondary
5219
index, we always have to modify the
5220
clustered index record first: see the
5222
dict_index_t* index, /*!< in: secondary index */
5223
que_thr_t* thr, /*!< in: query thread */
5224
mtr_t* mtr) /*!< in/out: mini-transaction */
5229
ut_ad(!dict_index_is_clust(index));
5230
ut_ad(block->frame == page_align(rec));
5232
if (flags & BTR_NO_LOCKING_FLAG) {
5237
heap_no = page_rec_get_heap_no(rec);
5239
/* Another transaction cannot have an implicit lock on the record,
5240
because when we come here, we already have modified the clustered
5241
index record, and this would not have been possible if another active
5242
transaction had modified this secondary index record. */
5244
lock_mutex_enter_kernel();
5246
ut_ad(lock_table_has(thr_get_trx(thr), index->table, LOCK_IX));
5248
err = lock_rec_lock(TRUE, LOCK_X | LOCK_REC_NOT_GAP,
5249
block, heap_no, index, thr);
5251
lock_mutex_exit_kernel();
5255
mem_heap_t* heap = NULL;
5256
ulint offsets_[REC_OFFS_NORMAL_SIZE];
5257
const ulint* offsets;
5258
rec_offs_init(offsets_);
5260
offsets = rec_get_offsets(rec, index, offsets_,
5261
ULINT_UNDEFINED, &heap);
5262
ut_ad(lock_rec_queue_validate(block, rec, index, offsets));
5263
if (UNIV_LIKELY_NULL(heap)) {
5264
mem_heap_free(heap);
5267
#endif /* UNIV_DEBUG */
5269
if (err == DB_SUCCESS || err == DB_SUCCESS_LOCKED_REC) {
5270
/* Update the page max trx id field */
5271
/* It might not be necessary to do this if
5272
err == DB_SUCCESS (no new lock created),
5273
but it should not cost too much performance. */
5274
page_update_max_trx_id(block,
5275
buf_block_get_page_zip(block),
5276
thr_get_trx(thr)->id, mtr);
5283
/*********************************************************************//**
5284
Like lock_clust_rec_read_check_and_lock(), but reads a
5285
secondary index record.
5286
@return DB_SUCCESS, DB_SUCCESS_LOCKED_REC, DB_LOCK_WAIT, DB_DEADLOCK,
5287
or DB_QUE_THR_SUSPENDED */
5290
lock_sec_rec_read_check_and_lock(
5291
/*=============================*/
5292
ulint flags, /*!< in: if BTR_NO_LOCKING_FLAG
5293
bit is set, does nothing */
5294
const buf_block_t* block, /*!< in: buffer block of rec */
5295
const rec_t* rec, /*!< in: user record or page
5296
supremum record which should
5297
be read or passed over by a
5299
dict_index_t* index, /*!< in: secondary index */
5300
const ulint* offsets,/*!< in: rec_get_offsets(rec, index) */
5301
enum lock_mode mode, /*!< in: mode of the lock which
5302
the read cursor should set on
5303
records: LOCK_S or LOCK_X; the
5304
latter is possible in
5305
SELECT FOR UPDATE */
5306
ulint gap_mode,/*!< in: LOCK_ORDINARY, LOCK_GAP, or
5308
que_thr_t* thr) /*!< in: query thread */
5313
ut_ad(!dict_index_is_clust(index));
5314
ut_ad(block->frame == page_align(rec));
5315
ut_ad(page_rec_is_user_rec(rec) || page_rec_is_supremum(rec));
5316
ut_ad(rec_offs_validate(rec, index, offsets));
5317
ut_ad(mode == LOCK_X || mode == LOCK_S);
5319
if (flags & BTR_NO_LOCKING_FLAG) {
5324
heap_no = page_rec_get_heap_no(rec);
5326
lock_mutex_enter_kernel();
5328
ut_ad(mode != LOCK_X
5329
|| lock_table_has(thr_get_trx(thr), index->table, LOCK_IX));
5330
ut_ad(mode != LOCK_S
5331
|| lock_table_has(thr_get_trx(thr), index->table, LOCK_IS));
5333
/* Some transaction may have an implicit x-lock on the record only
5334
if the max trx id for the page >= min trx id for the trx list or a
5335
database recovery is running. */
5337
if ((page_get_max_trx_id(block->frame) >= trx_list_get_min_trx_id()
5338
|| recv_recovery_is_on())
5339
&& !page_rec_is_supremum(rec)) {
5341
lock_rec_convert_impl_to_expl(block, rec, index, offsets);
5344
err = lock_rec_lock(FALSE, mode | gap_mode,
5345
block, heap_no, index, thr);
5347
lock_mutex_exit_kernel();
5349
ut_ad(lock_rec_queue_validate(block, rec, index, offsets));
5351
if (UNIV_UNLIKELY(err == DB_SUCCESS_LOCKED_REC)) {
5358
/*********************************************************************//**
5359
Checks if locks of other transactions prevent an immediate read, or passing
5360
over by a read cursor, of a clustered index record. If they do, first tests
5361
if the query thread should anyway be suspended for some reason; if not, then
5362
puts the transaction and the query thread to the lock wait state and inserts a
5363
waiting request for a record lock to the lock queue. Sets the requested mode
5365
@return DB_SUCCESS, DB_SUCCESS_LOCKED_REC, DB_LOCK_WAIT, DB_DEADLOCK,
5366
or DB_QUE_THR_SUSPENDED */
5369
lock_clust_rec_read_check_and_lock(
5370
/*===============================*/
5371
ulint flags, /*!< in: if BTR_NO_LOCKING_FLAG
5372
bit is set, does nothing */
5373
const buf_block_t* block, /*!< in: buffer block of rec */
5374
const rec_t* rec, /*!< in: user record or page
5375
supremum record which should
5376
be read or passed over by a
5378
dict_index_t* index, /*!< in: clustered index */
5379
const ulint* offsets,/*!< in: rec_get_offsets(rec, index) */
5380
enum lock_mode mode, /*!< in: mode of the lock which
5381
the read cursor should set on
5382
records: LOCK_S or LOCK_X; the
5383
latter is possible in
5384
SELECT FOR UPDATE */
5385
ulint gap_mode,/*!< in: LOCK_ORDINARY, LOCK_GAP, or
5387
que_thr_t* thr) /*!< in: query thread */
5392
ut_ad(dict_index_is_clust(index));
5393
ut_ad(block->frame == page_align(rec));
5394
ut_ad(page_rec_is_user_rec(rec) || page_rec_is_supremum(rec));
5395
ut_ad(gap_mode == LOCK_ORDINARY || gap_mode == LOCK_GAP
5396
|| gap_mode == LOCK_REC_NOT_GAP);
5397
ut_ad(rec_offs_validate(rec, index, offsets));
5399
if (flags & BTR_NO_LOCKING_FLAG) {
5404
heap_no = page_rec_get_heap_no(rec);
5406
lock_mutex_enter_kernel();
5408
ut_ad(mode != LOCK_X
5409
|| lock_table_has(thr_get_trx(thr), index->table, LOCK_IX));
5410
ut_ad(mode != LOCK_S
5411
|| lock_table_has(thr_get_trx(thr), index->table, LOCK_IS));
5413
if (UNIV_LIKELY(heap_no != PAGE_HEAP_NO_SUPREMUM)) {
5415
lock_rec_convert_impl_to_expl(block, rec, index, offsets);
5418
err = lock_rec_lock(FALSE, mode | gap_mode,
5419
block, heap_no, index, thr);
5421
lock_mutex_exit_kernel();
5423
ut_ad(lock_rec_queue_validate(block, rec, index, offsets));
5427
/*********************************************************************//**
5428
Checks if locks of other transactions prevent an immediate read, or passing
5429
over by a read cursor, of a clustered index record. If they do, first tests
5430
if the query thread should anyway be suspended for some reason; if not, then
5431
puts the transaction and the query thread to the lock wait state and inserts a
5432
waiting request for a record lock to the lock queue. Sets the requested mode
5433
lock on the record. This is an alternative version of
5434
lock_clust_rec_read_check_and_lock() that does not require the parameter
5436
@return DB_SUCCESS, DB_LOCK_WAIT, DB_DEADLOCK, or DB_QUE_THR_SUSPENDED */
5439
lock_clust_rec_read_check_and_lock_alt(
5440
/*===================================*/
5441
ulint flags, /*!< in: if BTR_NO_LOCKING_FLAG
5442
bit is set, does nothing */
5443
const buf_block_t* block, /*!< in: buffer block of rec */
5444
const rec_t* rec, /*!< in: user record or page
5445
supremum record which should
5446
be read or passed over by a
5448
dict_index_t* index, /*!< in: clustered index */
5449
enum lock_mode mode, /*!< in: mode of the lock which
5450
the read cursor should set on
5451
records: LOCK_S or LOCK_X; the
5452
latter is possible in
5453
SELECT FOR UPDATE */
5454
ulint gap_mode,/*!< in: LOCK_ORDINARY, LOCK_GAP, or
5456
que_thr_t* thr) /*!< in: query thread */
5458
mem_heap_t* tmp_heap = NULL;
5459
ulint offsets_[REC_OFFS_NORMAL_SIZE];
5460
ulint* offsets = offsets_;
5462
rec_offs_init(offsets_);
5464
offsets = rec_get_offsets(rec, index, offsets,
5465
ULINT_UNDEFINED, &tmp_heap);
5466
err = lock_clust_rec_read_check_and_lock(flags, block, rec, index,
5467
offsets, mode, gap_mode, thr);
5469
mem_heap_free(tmp_heap);
5472
if (UNIV_UNLIKELY(err == DB_SUCCESS_LOCKED_REC)) {
5479
/*******************************************************************//**
5480
Release the last lock from the transaction's autoinc locks. */
5483
lock_release_autoinc_last_lock(
5484
/*===========================*/
5485
ib_vector_t* autoinc_locks) /*!< in/out: vector of AUTOINC locks */
5490
ut_ad(mutex_own(&kernel_mutex));
5491
ut_a(!ib_vector_is_empty(autoinc_locks));
5493
/* The lock to be release must be the last lock acquired. */
5494
last = ib_vector_size(autoinc_locks) - 1;
5495
lock = static_cast<lock_t *>(ib_vector_get(autoinc_locks, last));
5497
/* Should have only AUTOINC locks in the vector. */
5498
ut_a(lock_get_mode(lock) == LOCK_AUTO_INC);
5499
ut_a(lock_get_type(lock) == LOCK_TABLE);
5501
ut_a(lock->un_member.tab_lock.table != NULL);
5503
/* This will remove the lock from the trx autoinc_locks too. */
5504
lock_table_dequeue(lock);
5507
/*******************************************************************//**
5508
Check if a transaction holds any autoinc locks.
5509
@return TRUE if the transaction holds any AUTOINC locks. */
5512
lock_trx_holds_autoinc_locks(
5513
/*=========================*/
5514
const trx_t* trx) /*!< in: transaction */
5516
ut_a(trx->autoinc_locks != NULL);
5518
return(!ib_vector_is_empty(trx->autoinc_locks));
5521
/*******************************************************************//**
5522
Release all the transaction's autoinc locks. */
5525
lock_release_autoinc_locks(
5526
/*=======================*/
5527
trx_t* trx) /*!< in/out: transaction */
5529
ut_ad(mutex_own(&kernel_mutex));
5531
ut_a(trx->autoinc_locks != NULL);
5533
/* We release the locks in the reverse order. This is to
5534
avoid searching the vector for the element to delete at
5535
the lower level. See (lock_table_remove_low()) for details. */
5536
while (!ib_vector_is_empty(trx->autoinc_locks)) {
5538
/* lock_table_remove_low() will also remove the lock from
5539
the transaction's autoinc_locks vector. */
5540
lock_release_autoinc_last_lock(trx->autoinc_locks);
5543
/* Should release all locks. */
5544
ut_a(ib_vector_is_empty(trx->autoinc_locks));
5547
/*******************************************************************//**
5548
Gets the type of a lock. Non-inline version for using outside of the
5550
@return LOCK_TABLE or LOCK_REC */
5555
const lock_t* lock) /*!< in: lock */
5557
return(lock_get_type_low(lock));
5560
/*******************************************************************//**
5561
Gets the id of the transaction owning a lock.
5562
@return transaction id */
5567
const lock_t* lock) /*!< in: lock */
5569
return(lock->trx->id);
5572
/*******************************************************************//**
5573
Gets the mode of a lock in a human readable string.
5574
The string should not be free()'d or modified.
5575
@return lock mode */
5580
const lock_t* lock) /*!< in: lock */
5584
is_gap_lock = lock_get_type_low(lock) == LOCK_REC
5585
&& lock_rec_get_gap(lock);
5587
switch (lock_get_mode(lock)) {
5619
/*******************************************************************//**
5620
Gets the type of a lock in a human readable string.
5621
The string should not be free()'d or modified.
5622
@return lock type */
5627
const lock_t* lock) /*!< in: lock */
5629
switch (lock_get_type_low(lock)) {
5639
/*******************************************************************//**
5640
Gets the table on which the lock is.
5646
const lock_t* lock) /*!< in: lock */
5648
switch (lock_get_type_low(lock)) {
5650
return(lock->index->table);
5652
return(lock->un_member.tab_lock.table);
5659
/*******************************************************************//**
5660
Gets the id of the table on which the lock is.
5661
@return id of the table */
5666
const lock_t* lock) /*!< in: lock */
5668
dict_table_t* table;
5670
table = lock_get_table(lock);
5675
/*******************************************************************//**
5676
Gets the name of the table on which the lock is.
5677
The string should not be free()'d or modified.
5678
@return name of the table */
5681
lock_get_table_name(
5682
/*================*/
5683
const lock_t* lock) /*!< in: lock */
5685
dict_table_t* table;
5687
table = lock_get_table(lock);
5689
return(table->name);
5692
/*******************************************************************//**
5693
For a record lock, gets the index on which the lock is.
5699
const lock_t* lock) /*!< in: lock */
5701
ut_a(lock_get_type_low(lock) == LOCK_REC);
5703
return(lock->index);
5706
/*******************************************************************//**
5707
For a record lock, gets the name of the index on which the lock is.
5708
The string should not be free()'d or modified.
5709
@return name of the index */
5712
lock_rec_get_index_name(
5713
/*====================*/
5714
const lock_t* lock) /*!< in: lock */
5716
ut_a(lock_get_type_low(lock) == LOCK_REC);
5718
return(lock->index->name);
5721
/*******************************************************************//**
5722
For a record lock, gets the tablespace number on which the lock is.
5723
@return tablespace number */
5726
lock_rec_get_space_id(
5727
/*==================*/
5728
const lock_t* lock) /*!< in: lock */
5730
ut_a(lock_get_type_low(lock) == LOCK_REC);
5732
return(lock->un_member.rec_lock.space);
5735
/*******************************************************************//**
5736
For a record lock, gets the page number on which the lock is.
5737
@return page number */
5740
lock_rec_get_page_no(
5741
/*=================*/
5742
const lock_t* lock) /*!< in: lock */
5744
ut_a(lock_get_type_low(lock) == LOCK_REC);
5746
return(lock->un_member.rec_lock.page_no);
added
removed
plugin/innobase/lock/lock0lock.cc
