1
/******************************************************
2
The transaction lock system
6
Created 5/7/1996 Heikki Tuuri
7
*******************************************************/
9
#define LOCK_MODULE_IMPLEMENTATION
11
#include "lock0lock.h"
12
#include "lock0priv.h"
15
#include "lock0lock.ic"
16
#include "lock0priv.ic"
19
#include "ha_prototypes.h"
21
#include "trx0purge.h"
25
/* Restricts the length of search we will do in the waits-for
26
graph of transactions */
27
#define LOCK_MAX_N_STEPS_IN_DEADLOCK_CHECK 1000000
29
/* Restricts the recursion depth of the search we will do in the waits-for
30
graph of transactions */
31
#define LOCK_MAX_DEPTH_IN_DEADLOCK_CHECK 200
33
/* When releasing transaction locks, this specifies how often we release
34
the kernel mutex for a moment to give also others access to it */
36
#define LOCK_RELEASE_KERNEL_INTERVAL 1000
38
/* Safety margin when creating a new record lock: this many extra records
39
can be inserted to the page without need to create a lock with a bigger
42
#define LOCK_PAGE_BITMAP_MARGIN 64
44
/* An explicit record lock affects both the record and the gap before it.
45
An implicit x-lock does not affect the gap, it only locks the index
46
record from read or update.
48
If a transaction has modified or inserted an index record, then
49
it owns an implicit x-lock on the record. On a secondary index record,
50
a transaction has an implicit x-lock also if it has modified the
51
clustered index record, the max trx id of the page where the secondary
52
index record resides is >= trx id of the transaction (or database recovery
53
is running), and there are no explicit non-gap lock requests on the
54
secondary index record.
56
This complicated definition for a secondary index comes from the
57
implementation: we want to be able to determine if a secondary index
58
record has an implicit x-lock, just by looking at the present clustered
59
index record, not at the historical versions of the record. The
60
complicated definition can be explained to the user so that there is
61
nondeterminism in the access path when a query is answered: we may,
62
or may not, access the clustered index record and thus may, or may not,
63
bump into an x-lock set there.
65
Different transaction can have conflicting locks set on the gap at the
66
same time. The locks on the gap are purely inhibitive: an insert cannot
67
be made, or a select cursor may have to wait if a different transaction
68
has a conflicting lock on the gap. An x-lock on the gap does not give
69
the right to insert into the gap.
71
An explicit lock can be placed on a user record or the supremum record of
72
a page. The locks on the supremum record are always thought to be of the gap
73
type, though the gap bit is not set. When we perform an update of a record
74
where the size of the record changes, we may temporarily store its explicit
75
locks on the infimum record of the page, though the infimum otherwise never
78
A waiting record lock can also be of the gap type. A waiting lock request
79
can be granted when there is no conflicting mode lock request by another
80
transaction ahead of it in the explicit lock queue.
82
In version 4.0.5 we added yet another explicit lock type: LOCK_REC_NOT_GAP.
83
It only locks the record it is placed on, not the gap before the record.
84
This lock type is necessary to emulate an Oracle-like READ COMMITTED isolation
87
-------------------------------------------------------------------------
88
RULE 1: If there is an implicit x-lock on a record, and there are non-gap
90
lock requests waiting in the queue, then the transaction holding the implicit
91
x-lock also has an explicit non-gap record x-lock. Therefore, as locks are
92
released, we can grant locks to waiting lock requests purely by looking at
93
the explicit lock requests in the queue.
95
RULE 3: Different transactions cannot have conflicting granted non-gap locks
97
on a record at the same time. However, they can have conflicting granted gap
99
RULE 4: If a there is a waiting lock request in a queue, no lock request,
101
gap or not, can be inserted ahead of it in the queue. In record deletes
102
and page splits new gap type locks can be created by the database manager
103
for a transaction, and without rule 4, the waits-for graph of transactions
104
might become cyclic without the database noticing it, as the deadlock check
105
is only performed when a transaction itself requests a lock!
106
-------------------------------------------------------------------------
108
An insert is allowed to a gap if there are no explicit lock requests by
109
other transactions on the next record. It does not matter if these lock
110
requests are granted or waiting, gap bit set or not, with the exception
111
that a gap type request set by another transaction to wait for
112
its turn to do an insert is ignored. On the other hand, an
113
implicit x-lock by another transaction does not prevent an insert, which
114
allows for more concurrency when using an Oracle-style sequence number
115
generator for the primary key with many transactions doing inserts
118
A modify of a record is allowed if the transaction has an x-lock on the
119
record, or if other transactions do not have any non-gap lock requests on the
122
A read of a single user record with a cursor is allowed if the transaction
123
has a non-gap explicit, or an implicit lock on the record, or if the other
124
transactions have no x-lock requests on the record. At a page supremum a
125
read is always allowed.
127
In summary, an implicit lock is seen as a granted x-lock only on the
128
record, not on the gap. An explicit lock with no gap bit set is a lock
129
both on the record and the gap. If the gap bit is set, the lock is only
130
on the gap. Different transaction cannot own conflicting locks on the
131
record at the same time, but they may own conflicting locks on the gap.
132
Granted locks on a record give an access right to the record, but gap type
133
locks just inhibit operations.
135
NOTE: Finding out if some transaction has an implicit x-lock on a secondary
136
index record can be cumbersome. We may have to look at previous versions of
137
the corresponding clustered index record to find out if a delete marked
138
secondary index record was delete marked by an active transaction, not by
141
FACT A: If a transaction has inserted a row, it can delete it any time
142
without need to wait for locks.
144
PROOF: The transaction has an implicit x-lock on every index record inserted
145
for the row, and can thus modify each record without the need to wait. Q.E.D.
147
FACT B: If a transaction has read some result set with a cursor, it can read
148
it again, and retrieves the same result set, if it has not modified the
149
result set in the meantime. Hence, there is no phantom problem. If the
150
biggest record, in the alphabetical order, touched by the cursor is removed,
151
a lock wait may occur, otherwise not.
153
PROOF: When a read cursor proceeds, it sets an s-lock on each user record
154
it passes, and a gap type s-lock on each page supremum. The cursor must
155
wait until it has these locks granted. Then no other transaction can
156
have a granted x-lock on any of the user records, and therefore cannot
157
modify the user records. Neither can any other transaction insert into
158
the gaps which were passed over by the cursor. Page splits and merges,
159
and removal of obsolete versions of records do not affect this, because
160
when a user record or a page supremum is removed, the next record inherits
161
its locks as gap type locks, and therefore blocks inserts to the same gap.
162
Also, if a page supremum is inserted, it inherits its locks from the successor
163
record. When the cursor is positioned again at the start of the result set,
164
the records it will touch on its course are either records it touched
165
during the last pass or new inserted page supremums. It can immediately
166
access all these records, and when it arrives at the biggest record, it
167
notices that the result set is complete. If the biggest record was removed,
168
lock wait can occur because the next record only inherits a gap type lock,
169
and a wait may be needed. Q.E.D. */
171
/* If an index record should be changed or a new inserted, we must check
172
the lock on the record or the next. When a read cursor starts reading,
173
we will set a record level s-lock on each record it passes, except on the
174
initial record on which the cursor is positioned before we start to fetch
175
records. Our index tree search has the convention that the B-tree
176
cursor is positioned BEFORE the first possibly matching record in
177
the search. Optimizations are possible here: if the record is searched
178
on an equality condition to a unique key, we could actually set a special
179
lock on the record, a lock which would not prevent any insert before
180
this record. In the next key locking an x-lock set on a record also
181
prevents inserts just before that record.
182
There are special infimum and supremum records on each page.
183
A supremum record can be locked by a read cursor. This records cannot be
184
updated but the lock prevents insert of a user record to the end of
186
Next key locks will prevent the phantom problem where new rows
187
could appear to SELECT result sets after the select operation has been
188
performed. Prevention of phantoms ensures the serilizability of
190
What should we check if an insert of a new record is wanted?
191
Only the lock on the next record on the same page, because also the
192
supremum record can carry a lock. An s-lock prevents insertion, but
193
what about an x-lock? If it was set by a searched update, then there
194
is implicitly an s-lock, too, and the insert should be prevented.
195
What if our transaction owns an x-lock to the next record, but there is
196
a waiting s-lock request on the next record? If this s-lock was placed
197
by a read cursor moving in the ascending order in the index, we cannot
198
do the insert immediately, because when we finally commit our transaction,
199
the read cursor should see also the new inserted record. So we should
200
move the read cursor backward from the the next record for it to pass over
201
the new inserted record. This move backward may be too cumbersome to
202
implement. If we in this situation just enqueue a second x-lock request
203
for our transaction on the next record, then the deadlock mechanism
204
notices a deadlock between our transaction and the s-lock request
205
transaction. This seems to be an ok solution.
206
We could have the convention that granted explicit record locks,
207
lock the corresponding records from changing, and also lock the gaps
208
before them from inserting. A waiting explicit lock request locks the gap
209
before from inserting. Implicit record x-locks, which we derive from the
210
transaction id in the clustered index record, only lock the record itself
211
from modification, not the gap before it from inserting.
212
How should we store update locks? If the search is done by a unique
213
key, we could just modify the record trx id. Otherwise, we could put a record
214
x-lock on the record. If the update changes ordering fields of the
215
clustered index record, the inserted new record needs no record lock in
216
lock table, the trx id is enough. The same holds for a secondary index
217
record. Searched delete is similar to update.
220
What about waiting lock requests? If a transaction is waiting to make an
221
update to a record which another modified, how does the other transaction
222
know to send the end-lock-wait signal to the waiting transaction? If we have
223
the convention that a transaction may wait for just one lock at a time, how
224
do we preserve it if lock wait ends?
227
Checking the trx id label of a secondary index record. In the case of a
228
modification, not an insert, is this necessary? A secondary index record
229
is modified only by setting or resetting its deleted flag. A secondary index
230
record contains fields to uniquely determine the corresponding clustered
231
index record. A secondary index record is therefore only modified if we
232
also modify the clustered index record, and the trx id checking is done
233
on the clustered index record, before we come to modify the secondary index
234
record. So, in the case of delete marking or unmarking a secondary index
235
record, we do not have to care about trx ids, only the locks in the lock
236
table must be checked. In the case of a select from a secondary index, the
237
trx id is relevant, and in this case we may have to search the clustered
240
PROBLEM: How to update record locks when page is split or merged, or
241
--------------------------------------------------------------------
242
a record is deleted or updated?
243
If the size of fields in a record changes, we perform the update by
244
a delete followed by an insert. How can we retain the locks set or
245
waiting on the record? Because a record lock is indexed in the bitmap
246
by the heap number of the record, when we remove the record from the
247
record list, it is possible still to keep the lock bits. If the page
248
is reorganized, we could make a table of old and new heap numbers,
249
and permute the bitmaps in the locks accordingly. We can add to the
250
table a row telling where the updated record ended. If the update does
251
not require a reorganization of the page, we can simply move the lock
252
bits for the updated record to the position determined by its new heap
253
number (we may have to allocate a new lock, if we run out of the bitmap
255
A more complicated case is the one where the reinsertion of the
256
updated record is done pessimistically, because the structure of the
259
PROBLEM: If a supremum record is removed in a page merge, or a record
260
---------------------------------------------------------------------
261
removed in a purge, what to do to the waiting lock requests? In a split to
262
the right, we just move the lock requests to the new supremum. If a record
263
is removed, we could move the waiting lock request to its inheritor, the
264
next record in the index. But, the next record may already have lock
265
requests on its own queue. A new deadlock check should be made then. Maybe
266
it is easier just to release the waiting transactions. They can then enqueue
267
new lock requests on appropriate records.
269
PROBLEM: When a record is inserted, what locks should it inherit from the
270
-------------------------------------------------------------------------
271
upper neighbor? An insert of a new supremum record in a page split is
272
always possible, but an insert of a new user record requires that the upper
273
neighbor does not have any lock requests by other transactions, granted or
274
waiting, in its lock queue. Solution: We can copy the locks as gap type
275
locks, so that also the waiting locks are transformed to granted gap type
276
locks on the inserted record. */
278
/* LOCK COMPATIBILITY MATRIX
286
* Note that for rows, InnoDB only acquires S or X locks.
287
* For tables, InnoDB normally acquires IS or IX locks.
288
* S or X table locks are only acquired for LOCK TABLES.
289
* Auto-increment (AI) locks are needed because of
290
* statement-level MySQL binlog.
291
* See also lock_mode_compatible().
293
#define LK(a,b) (1 << ((a) * LOCK_NUM + (b)))
294
#define LKS(a,b) LK(a,b) | LK(b,a)
296
/* Define the lock compatibility matrix in a ulint. The first line below
297
defines the diagonal entries. The following lines define the compatibility
298
for LOCK_IX, LOCK_S, and LOCK_AUTO_INC using LKS(), since the matrix
300
#define LOCK_MODE_COMPATIBILITY 0 \
301
| LK(LOCK_IS, LOCK_IS) | LK(LOCK_IX, LOCK_IX) | LK(LOCK_S, LOCK_S) \
302
| LKS(LOCK_IX, LOCK_IS) | LKS(LOCK_IS, LOCK_AUTO_INC) \
303
| LKS(LOCK_S, LOCK_IS) \
304
| LKS(LOCK_AUTO_INC, LOCK_IS) | LKS(LOCK_AUTO_INC, LOCK_IX)
306
/* STRONGER-OR-EQUAL RELATION (mode1=row, mode2=column)
313
* See lock_mode_stronger_or_eq().
316
/* Define the stronger-or-equal lock relation in a ulint. This relation
317
contains all pairs LK(mode1, mode2) where mode1 is stronger than or
319
#define LOCK_MODE_STRONGER_OR_EQ 0 \
320
| LK(LOCK_IS, LOCK_IS) \
321
| LK(LOCK_IX, LOCK_IS) | LK(LOCK_IX, LOCK_IX) \
322
| LK(LOCK_S, LOCK_IS) | LK(LOCK_S, LOCK_S) \
323
| LK(LOCK_AUTO_INC, LOCK_AUTO_INC) \
324
| LK(LOCK_X, LOCK_IS) | LK(LOCK_X, LOCK_IX) | LK(LOCK_X, LOCK_S) \
325
| LK(LOCK_X, LOCK_AUTO_INC) | LK(LOCK_X, LOCK_X)
328
UNIV_INTERN ibool lock_print_waits = FALSE;
330
/*************************************************************************
331
Validates the lock system. */
336
/* out: TRUE if ok */
338
/*************************************************************************
339
Validates the record lock queues on a page. */
342
lock_rec_validate_page(
343
/*===================*/
344
/* out: TRUE if ok */
345
ulint space, /* in: space id */
346
ulint page_no);/* in: page number */
348
/* Define the following in order to enable lock_rec_validate_page() checks. */
349
# undef UNIV_DEBUG_LOCK_VALIDATE
350
#endif /* UNIV_DEBUG */
352
/* The lock system */
353
UNIV_INTERN lock_sys_t* lock_sys = NULL;
355
/* We store info on the latest deadlock error to this buffer. InnoDB
356
Monitor will then fetch it and print */
357
UNIV_INTERN ibool lock_deadlock_found = FALSE;
358
UNIV_INTERN FILE* lock_latest_err_file;
360
/* Flags for recursive deadlock search */
361
#define LOCK_VICTIM_IS_START 1
362
#define LOCK_VICTIM_IS_OTHER 2
364
/************************************************************************
365
Checks if a lock request results in a deadlock. */
368
lock_deadlock_occurs(
369
/*=================*/
370
/* out: TRUE if a deadlock was detected and we
371
chose trx as a victim; FALSE if no deadlock, or
372
there was a deadlock, but we chose other
373
transaction(s) as victim(s) */
374
lock_t* lock, /* in: lock the transaction is requesting */
375
trx_t* trx); /* in: transaction */
376
/************************************************************************
377
Looks recursively for a deadlock. */
380
lock_deadlock_recursive(
381
/*====================*/
382
/* out: 0 if no deadlock found,
383
LOCK_VICTIM_IS_START if there was a deadlock
384
and we chose 'start' as the victim,
385
LOCK_VICTIM_IS_OTHER if a deadlock
386
was found and we chose some other trx as a
387
victim: we must do the search again in this
388
last case because there may be another
390
trx_t* start, /* in: recursion starting point */
391
trx_t* trx, /* in: a transaction waiting for a lock */
392
lock_t* wait_lock, /* in: the lock trx is waiting to be granted */
393
ulint* cost, /* in/out: number of calculation steps thus
394
far: if this exceeds LOCK_MAX_N_STEPS_...
395
we return LOCK_VICTIM_IS_START */
396
ulint depth); /* in: recursion depth: if this exceeds
397
LOCK_MAX_DEPTH_IN_DEADLOCK_CHECK, we
398
return LOCK_VICTIM_IS_START */
400
/*************************************************************************
401
Gets the nth bit of a record lock. */
404
lock_rec_get_nth_bit(
405
/*=================*/
406
/* out: TRUE if bit set */
407
const lock_t* lock, /* in: record lock */
408
ulint i) /* in: index of the bit */
414
ut_ad(lock_get_type_low(lock) == LOCK_REC);
416
if (i >= lock->un_member.rec_lock.n_bits) {
424
return(1 & ((const byte*) &lock[1])[byte_index] >> bit_index);
427
/*************************************************************************/
429
#define lock_mutex_enter_kernel() mutex_enter(&kernel_mutex)
430
#define lock_mutex_exit_kernel() mutex_exit(&kernel_mutex)
432
/*************************************************************************
433
Checks that a transaction id is sensible, i.e., not in the future. */
436
lock_check_trx_id_sanity(
437
/*=====================*/
438
/* out: TRUE if ok */
439
dulint trx_id, /* in: trx id */
440
const rec_t* rec, /* in: user record */
441
dict_index_t* index, /* in: index */
442
const ulint* offsets, /* in: rec_get_offsets(rec, index) */
443
ibool has_kernel_mutex)/* in: TRUE if the caller owns the
448
ut_ad(rec_offs_validate(rec, index, offsets));
450
if (!has_kernel_mutex) {
451
mutex_enter(&kernel_mutex);
454
/* A sanity check: the trx_id in rec must be smaller than the global
457
if (ut_dulint_cmp(trx_id, trx_sys->max_trx_id) >= 0) {
458
ut_print_timestamp(stderr);
459
fputs(" InnoDB: Error: transaction id associated"
462
rec_print_new(stderr, rec, offsets);
463
fputs("InnoDB: in ", stderr);
464
dict_index_name_print(stderr, NULL, index);
466
"InnoDB: is " TRX_ID_FMT " which is higher than the"
467
" global trx id counter " TRX_ID_FMT "!\n"
468
"InnoDB: The table is corrupt. You have to do"
469
" dump + drop + reimport.\n",
470
TRX_ID_PREP_PRINTF(trx_id),
471
TRX_ID_PREP_PRINTF(trx_sys->max_trx_id));
476
if (!has_kernel_mutex) {
477
mutex_exit(&kernel_mutex);
483
/*************************************************************************
484
Checks that a record is seen in a consistent read. */
487
lock_clust_rec_cons_read_sees(
488
/*==========================*/
489
/* out: TRUE if sees, or FALSE if an earlier
490
version of the record should be retrieved */
491
const rec_t* rec, /* in: user record which should be read or
492
passed over by a read cursor */
493
dict_index_t* index, /* in: clustered index */
494
const ulint* offsets,/* in: rec_get_offsets(rec, index) */
495
read_view_t* view) /* in: consistent read view */
499
ut_ad(dict_index_is_clust(index));
500
ut_ad(page_rec_is_user_rec(rec));
501
ut_ad(rec_offs_validate(rec, index, offsets));
503
/* NOTE that we call this function while holding the search
504
system latch. To obey the latching order we must NOT reserve the
505
kernel mutex here! */
507
trx_id = row_get_rec_trx_id(rec, index, offsets);
509
return(read_view_sees_trx_id(view, trx_id));
512
/*************************************************************************
513
Checks that a non-clustered index record is seen in a consistent read. */
516
lock_sec_rec_cons_read_sees(
517
/*========================*/
518
/* out: TRUE if certainly
519
sees, or FALSE if an earlier
520
version of the clustered index
521
record might be needed: NOTE
522
that a non-clustered index
523
page contains so little
525
modifications that also in the
526
case FALSE, the present
527
version of rec may be the
528
right, but we must check this
529
from the clustered index
531
const rec_t* rec, /* in: user record which
532
should be read or passed over
534
const read_view_t* view) /* in: consistent read view */
538
ut_ad(page_rec_is_user_rec(rec));
540
/* NOTE that we might call this function while holding the search
541
system latch. To obey the latching order we must NOT reserve the
542
kernel mutex here! */
544
if (recv_recovery_is_on()) {
549
max_trx_id = page_get_max_trx_id(page_align(rec));
551
return(ut_dulint_cmp(max_trx_id, view->up_limit_id) < 0);
554
/*************************************************************************
555
Creates the lock system at database start. */
560
ulint n_cells) /* in: number of slots in lock hash table */
562
lock_sys = mem_alloc(sizeof(lock_sys_t));
564
lock_sys->rec_hash = hash_create(n_cells);
566
/* hash_create_mutexes(lock_sys->rec_hash, 2, SYNC_REC_LOCK); */
568
lock_latest_err_file = os_file_create_tmpfile();
569
ut_a(lock_latest_err_file);
572
/*************************************************************************
573
Gets the size of a lock struct. */
578
/* out: size in bytes */
580
return((ulint)sizeof(lock_t));
583
/*************************************************************************
584
Gets the mode of a lock. */
590
const lock_t* lock) /* in: lock */
594
return(lock->type_mode & LOCK_MODE_MASK);
597
/*************************************************************************
598
Gets the wait flag of a lock. */
603
/* out: TRUE if waiting */
604
const lock_t* lock) /* in: lock */
608
if (UNIV_UNLIKELY(lock->type_mode & LOCK_WAIT)) {
616
/*************************************************************************
617
Gets the source table of an ALTER TABLE transaction. The table must be
618
covered by an IX or IS table lock. */
623
/* out: the source table of transaction,
624
if it is covered by an IX or IS table lock;
625
dest if there is no source table, and
626
NULL if the transaction is locking more than
627
two tables or an inconsistency is found */
628
trx_t* trx, /* in: transaction */
629
dict_table_t* dest, /* in: destination of ALTER TABLE */
630
enum lock_mode* mode) /* out: lock mode of the source table */
638
for (lock = UT_LIST_GET_FIRST(trx->trx_locks);
640
lock = UT_LIST_GET_NEXT(trx_locks, lock)) {
641
lock_table_t* tab_lock;
642
enum lock_mode lock_mode;
643
if (!(lock_get_type_low(lock) & LOCK_TABLE)) {
644
/* We are only interested in table locks. */
647
tab_lock = &lock->un_member.tab_lock;
648
if (dest == tab_lock->table) {
649
/* We are not interested in the destination table. */
652
/* This presumably is the source table. */
653
src = tab_lock->table;
654
if (UT_LIST_GET_LEN(src->locks) != 1
655
|| UT_LIST_GET_FIRST(src->locks) != lock) {
656
/* We only support the case when
657
there is only one lock on this table. */
660
} else if (src != tab_lock->table) {
661
/* The transaction is locking more than
662
two tables (src and dest): abort */
666
/* Check that the source table is locked by
667
LOCK_IX or LOCK_IS. */
668
lock_mode = lock_get_mode(lock);
669
if (lock_mode == LOCK_IX || lock_mode == LOCK_IS) {
670
if (*mode != LOCK_NONE && *mode != lock_mode) {
671
/* There are multiple locks on src. */
679
/* No source table lock found: flag the situation to caller */
686
/*************************************************************************
687
Determine if the given table is exclusively "owned" by the given
688
transaction, i.e., transaction holds LOCK_IX and possibly LOCK_AUTO_INC
692
lock_is_table_exclusive(
693
/*====================*/
694
/* out: TRUE if table is only locked by trx,
695
with LOCK_IX, and possibly LOCK_AUTO_INC */
696
dict_table_t* table, /* in: table */
697
trx_t* trx) /* in: transaction */
704
for (lock = UT_LIST_GET_FIRST(table->locks);
706
lock = UT_LIST_GET_NEXT(locks, &lock->un_member.tab_lock)) {
707
if (lock->trx != trx) {
708
/* A lock on the table is held
709
by some other transaction. */
713
if (!(lock_get_type_low(lock) & LOCK_TABLE)) {
714
/* We are interested in table locks only. */
718
switch (lock_get_mode(lock)) {
723
/* It is allowed for trx to hold an
724
auto_increment lock. */
727
/* Other table locks than LOCK_IX are not allowed. */
735
/*************************************************************************
736
Sets the wait flag of a lock and the back pointer in trx to lock. */
739
lock_set_lock_and_trx_wait(
740
/*=======================*/
741
lock_t* lock, /* in: lock */
742
trx_t* trx) /* in: trx */
745
ut_ad(trx->wait_lock == NULL);
747
trx->wait_lock = lock;
748
lock->type_mode |= LOCK_WAIT;
751
/**************************************************************************
752
The back pointer to a waiting lock request in the transaction is set to NULL
753
and the wait bit in lock type_mode is reset. */
756
lock_reset_lock_and_trx_wait(
757
/*=========================*/
758
lock_t* lock) /* in: record lock */
760
ut_ad((lock->trx)->wait_lock == lock);
761
ut_ad(lock_get_wait(lock));
763
/* Reset the back pointer in trx to this waiting lock request */
765
(lock->trx)->wait_lock = NULL;
766
lock->type_mode &= ~LOCK_WAIT;
769
/*************************************************************************
770
Gets the gap flag of a record lock. */
775
/* out: TRUE if gap flag set */
776
const lock_t* lock) /* in: record lock */
779
ut_ad(lock_get_type_low(lock) == LOCK_REC);
781
if (lock->type_mode & LOCK_GAP) {
789
/*************************************************************************
790
Gets the LOCK_REC_NOT_GAP flag of a record lock. */
793
lock_rec_get_rec_not_gap(
794
/*=====================*/
795
/* out: TRUE if LOCK_REC_NOT_GAP flag set */
796
const lock_t* lock) /* in: record lock */
799
ut_ad(lock_get_type_low(lock) == LOCK_REC);
801
if (lock->type_mode & LOCK_REC_NOT_GAP) {
809
/*************************************************************************
810
Gets the waiting insert flag of a record lock. */
813
lock_rec_get_insert_intention(
814
/*==========================*/
815
/* out: TRUE if gap flag set */
816
const lock_t* lock) /* in: record lock */
819
ut_ad(lock_get_type_low(lock) == LOCK_REC);
821
if (lock->type_mode & LOCK_INSERT_INTENTION) {
829
/*************************************************************************
830
Calculates if lock mode 1 is stronger or equal to lock mode 2. */
833
lock_mode_stronger_or_eq(
834
/*=====================*/
836
if mode1 stronger or equal to mode2 */
837
enum lock_mode mode1, /* in: lock mode */
838
enum lock_mode mode2) /* in: lock mode */
840
ut_ad(mode1 == LOCK_X || mode1 == LOCK_S || mode1 == LOCK_IX
841
|| mode1 == LOCK_IS || mode1 == LOCK_AUTO_INC);
842
ut_ad(mode2 == LOCK_X || mode2 == LOCK_S || mode2 == LOCK_IX
843
|| mode2 == LOCK_IS || mode2 == LOCK_AUTO_INC);
845
return((LOCK_MODE_STRONGER_OR_EQ) & LK(mode1, mode2));
848
/*************************************************************************
849
Calculates if lock mode 1 is compatible with lock mode 2. */
852
lock_mode_compatible(
853
/*=================*/
854
/* out: nonzero if mode1 compatible with mode2 */
855
enum lock_mode mode1, /* in: lock mode */
856
enum lock_mode mode2) /* in: lock mode */
858
ut_ad(mode1 == LOCK_X || mode1 == LOCK_S || mode1 == LOCK_IX
859
|| mode1 == LOCK_IS || mode1 == LOCK_AUTO_INC);
860
ut_ad(mode2 == LOCK_X || mode2 == LOCK_S || mode2 == LOCK_IX
861
|| mode2 == LOCK_IS || mode2 == LOCK_AUTO_INC);
863
return((LOCK_MODE_COMPATIBILITY) & LK(mode1, mode2));
866
/*************************************************************************
867
Checks if a lock request for a new lock has to wait for request lock2. */
870
lock_rec_has_to_wait(
871
/*=================*/
872
/* out: TRUE if new lock has to wait
873
for lock2 to be removed */
874
const trx_t* trx, /* in: trx of new lock */
875
ulint type_mode,/* in: precise mode of the new lock
876
to set: LOCK_S or LOCK_X, possibly
877
ORed to LOCK_GAP or LOCK_REC_NOT_GAP,
878
LOCK_INSERT_INTENTION */
879
const lock_t* lock2, /* in: another record lock; NOTE that
880
it is assumed that this has a lock bit
881
set on the same record as in the new
882
lock we are setting */
883
ibool lock_is_on_supremum) /* in: TRUE if we are setting the
884
lock on the 'supremum' record of an
885
index page: we know then that the lock
886
request is really for a 'gap' type lock */
889
ut_ad(lock_get_type_low(lock2) == LOCK_REC);
891
if (trx != lock2->trx
892
&& !lock_mode_compatible(LOCK_MODE_MASK & type_mode,
893
lock_get_mode(lock2))) {
895
/* We have somewhat complex rules when gap type record locks
898
if ((lock_is_on_supremum || (type_mode & LOCK_GAP))
899
&& !(type_mode & LOCK_INSERT_INTENTION)) {
901
/* Gap type locks without LOCK_INSERT_INTENTION flag
902
do not need to wait for anything. This is because
903
different users can have conflicting lock types
909
if (!(type_mode & LOCK_INSERT_INTENTION)
910
&& lock_rec_get_gap(lock2)) {
912
/* Record lock (LOCK_ORDINARY or LOCK_REC_NOT_GAP
913
does not need to wait for a gap type lock */
918
if ((type_mode & LOCK_GAP)
919
&& lock_rec_get_rec_not_gap(lock2)) {
921
/* Lock on gap does not need to wait for
922
a LOCK_REC_NOT_GAP type lock */
927
if (lock_rec_get_insert_intention(lock2)) {
929
/* No lock request needs to wait for an insert
930
intention lock to be removed. This is ok since our
931
rules allow conflicting locks on gaps. This eliminates
932
a spurious deadlock caused by a next-key lock waiting
933
for an insert intention lock; when the insert
934
intention lock was granted, the insert deadlocked on
935
the waiting next-key lock.
937
Also, insert intention locks do not disturb each
949
/*************************************************************************
950
Checks if a lock request lock1 has to wait for request lock2. */
955
/* out: TRUE if lock1 has to wait for
956
lock2 to be removed */
957
const lock_t* lock1, /* in: waiting lock */
958
const lock_t* lock2) /* in: another lock; NOTE that it is
959
assumed that this has a lock bit set
960
on the same record as in lock1 if the
961
locks are record locks */
963
ut_ad(lock1 && lock2);
965
if (lock1->trx != lock2->trx
966
&& !lock_mode_compatible(lock_get_mode(lock1),
967
lock_get_mode(lock2))) {
968
if (lock_get_type_low(lock1) == LOCK_REC) {
969
ut_ad(lock_get_type_low(lock2) == LOCK_REC);
971
/* If this lock request is for a supremum record
972
then the second bit on the lock bitmap is set */
974
return(lock_rec_has_to_wait(lock1->trx,
975
lock1->type_mode, lock2,
976
lock_rec_get_nth_bit(
986
/*============== RECORD LOCK BASIC FUNCTIONS ============================*/
988
/*************************************************************************
989
Gets the number of bits in a record lock bitmap. */
994
/* out: number of bits */
995
const lock_t* lock) /* in: record lock */
997
return(lock->un_member.rec_lock.n_bits);
1000
/**************************************************************************
1001
Sets the nth bit of a record lock to TRUE. */
1004
lock_rec_set_nth_bit(
1005
/*=================*/
1006
lock_t* lock, /* in: record lock */
1007
ulint i) /* in: index of the bit */
1013
ut_ad(lock_get_type_low(lock) == LOCK_REC);
1014
ut_ad(i < lock->un_member.rec_lock.n_bits);
1019
((byte*) &lock[1])[byte_index] |= 1 << bit_index;
1022
/**************************************************************************
1023
Looks for a set bit in a record lock bitmap. Returns ULINT_UNDEFINED,
1027
lock_rec_find_set_bit(
1028
/*==================*/
1029
/* out: bit index == heap number of
1030
the record, or ULINT_UNDEFINED if none found */
1031
const lock_t* lock) /* in: record lock with at least one bit set */
1035
for (i = 0; i < lock_rec_get_n_bits(lock); i++) {
1037
if (lock_rec_get_nth_bit(lock, i)) {
1043
return(ULINT_UNDEFINED);
1046
/**************************************************************************
1047
Resets the nth bit of a record lock. */
1050
lock_rec_reset_nth_bit(
1051
/*===================*/
1052
lock_t* lock, /* in: record lock */
1053
ulint i) /* in: index of the bit which must be set to TRUE
1054
when this function is called */
1060
ut_ad(lock_get_type_low(lock) == LOCK_REC);
1061
ut_ad(i < lock->un_member.rec_lock.n_bits);
1066
((byte*) &lock[1])[byte_index] &= ~(1 << bit_index);
1069
/*************************************************************************
1070
Gets the first or next record lock on a page. */
1073
lock_rec_get_next_on_page(
1074
/*======================*/
1075
/* out: next lock, NULL if none exists */
1076
lock_t* lock) /* in: a record lock */
1081
ut_ad(mutex_own(&kernel_mutex));
1082
ut_ad(lock_get_type_low(lock) == LOCK_REC);
1084
space = lock->un_member.rec_lock.space;
1085
page_no = lock->un_member.rec_lock.page_no;
1088
lock = HASH_GET_NEXT(hash, lock);
1095
if ((lock->un_member.rec_lock.space == space)
1096
&& (lock->un_member.rec_lock.page_no == page_no)) {
1105
/*************************************************************************
1106
Gets the first record lock on a page, where the page is identified by its
1110
lock_rec_get_first_on_page_addr(
1111
/*============================*/
1112
/* out: first lock, NULL if none exists */
1113
ulint space, /* in: space */
1114
ulint page_no)/* in: page number */
1118
ut_ad(mutex_own(&kernel_mutex));
1120
lock = HASH_GET_FIRST(lock_sys->rec_hash,
1121
lock_rec_hash(space, page_no));
1123
if ((lock->un_member.rec_lock.space == space)
1124
&& (lock->un_member.rec_lock.page_no == page_no)) {
1129
lock = HASH_GET_NEXT(hash, lock);
1135
/*************************************************************************
1136
Returns TRUE if there are explicit record locks on a page. */
1139
lock_rec_expl_exist_on_page(
1140
/*========================*/
1141
/* out: TRUE if there are explicit record locks on
1143
ulint space, /* in: space id */
1144
ulint page_no)/* in: page number */
1148
mutex_enter(&kernel_mutex);
1150
if (lock_rec_get_first_on_page_addr(space, page_no)) {
1156
mutex_exit(&kernel_mutex);
1161
/*************************************************************************
1162
Gets the first record lock on a page, where the page is identified by a
1166
lock_rec_get_first_on_page(
1167
/*=======================*/
1168
/* out: first lock, NULL if
1170
const buf_block_t* block) /* in: buffer block */
1174
ulint space = buf_block_get_space(block);
1175
ulint page_no = buf_block_get_page_no(block);
1177
ut_ad(mutex_own(&kernel_mutex));
1179
hash = buf_block_get_lock_hash_val(block);
1181
lock = HASH_GET_FIRST(lock_sys->rec_hash, hash);
1184
if ((lock->un_member.rec_lock.space == space)
1185
&& (lock->un_member.rec_lock.page_no == page_no)) {
1190
lock = HASH_GET_NEXT(hash, lock);
1196
/*************************************************************************
1197
Gets the next explicit lock request on a record. */
1202
/* out: next lock, NULL if none exists */
1203
ulint heap_no,/* in: heap number of the record */
1204
lock_t* lock) /* in: lock */
1206
ut_ad(mutex_own(&kernel_mutex));
1209
ut_ad(lock_get_type_low(lock) == LOCK_REC);
1210
lock = lock_rec_get_next_on_page(lock);
1211
} while (lock && !lock_rec_get_nth_bit(lock, heap_no));
1216
/*************************************************************************
1217
Gets the first explicit lock request on a record. */
1222
/* out: first lock, NULL if
1224
const buf_block_t* block, /* in: block containing the record */
1225
ulint heap_no)/* in: heap number of the record */
1229
ut_ad(mutex_own(&kernel_mutex));
1231
for (lock = lock_rec_get_first_on_page(block); lock;
1232
lock = lock_rec_get_next_on_page(lock)) {
1233
if (lock_rec_get_nth_bit(lock, heap_no)) {
1241
/*************************************************************************
1242
Resets the record lock bitmap to zero. NOTE: does not touch the wait_lock
1243
pointer in the transaction! This function is used in lock object creation
1247
lock_rec_bitmap_reset(
1248
/*==================*/
1249
lock_t* lock) /* in: record lock */
1253
ut_ad(lock_get_type_low(lock) == LOCK_REC);
1255
/* Reset to zero the bitmap which resides immediately after the lock
1258
n_bytes = lock_rec_get_n_bits(lock) / 8;
1260
ut_ad((lock_rec_get_n_bits(lock) % 8) == 0);
1262
memset(&lock[1], 0, n_bytes);
1265
/*************************************************************************
1266
Copies a record lock to heap. */
1271
/* out: copy of lock */
1272
const lock_t* lock, /* in: record lock */
1273
mem_heap_t* heap) /* in: memory heap */
1277
ut_ad(lock_get_type_low(lock) == LOCK_REC);
1279
size = sizeof(lock_t) + lock_rec_get_n_bits(lock) / 8;
1281
return(mem_heap_dup(heap, lock, size));
1284
/*************************************************************************
1285
Gets the previous record lock set on a record. */
1290
/* out: previous lock on the same
1291
record, NULL if none exists */
1292
const lock_t* in_lock,/* in: record lock */
1293
ulint heap_no)/* in: heap number of the record */
1298
lock_t* found_lock = NULL;
1300
ut_ad(mutex_own(&kernel_mutex));
1301
ut_ad(lock_get_type_low(in_lock) == LOCK_REC);
1303
space = in_lock->un_member.rec_lock.space;
1304
page_no = in_lock->un_member.rec_lock.page_no;
1306
lock = lock_rec_get_first_on_page_addr(space, page_no);
1311
if (lock == in_lock) {
1316
if (lock_rec_get_nth_bit(lock, heap_no)) {
1321
lock = lock_rec_get_next_on_page(lock);
1325
/*============= FUNCTIONS FOR ANALYZING TABLE LOCK QUEUE ================*/
1327
/*************************************************************************
1328
Checks if a transaction has the specified table lock, or stronger. */
1333
/* out: lock or NULL */
1334
trx_t* trx, /* in: transaction */
1335
dict_table_t* table, /* in: table */
1336
enum lock_mode mode) /* in: lock mode */
1340
ut_ad(mutex_own(&kernel_mutex));
1342
/* Look for stronger locks the same trx already has on the table */
1344
lock = UT_LIST_GET_LAST(table->locks);
1346
while (lock != NULL) {
1348
if (lock->trx == trx
1349
&& lock_mode_stronger_or_eq(lock_get_mode(lock), mode)) {
1351
/* The same trx already has locked the table in
1352
a mode stronger or equal to the mode given */
1354
ut_ad(!lock_get_wait(lock));
1359
lock = UT_LIST_GET_PREV(un_member.tab_lock.locks, lock);
1365
/*============= FUNCTIONS FOR ANALYZING RECORD LOCK QUEUE ================*/
1367
/*************************************************************************
1368
Checks if a transaction has a GRANTED explicit lock on rec stronger or equal
1374
/* out: lock or NULL */
1375
ulint precise_mode,/* in: LOCK_S or LOCK_X
1376
possibly ORed to LOCK_GAP or
1377
LOCK_REC_NOT_GAP, for a
1378
supremum record we regard this
1379
always a gap type request */
1380
const buf_block_t* block, /* in: buffer block containing
1382
ulint heap_no,/* in: heap number of the record */
1383
trx_t* trx) /* in: transaction */
1387
ut_ad(mutex_own(&kernel_mutex));
1388
ut_ad((precise_mode & LOCK_MODE_MASK) == LOCK_S
1389
|| (precise_mode & LOCK_MODE_MASK) == LOCK_X);
1390
ut_ad(!(precise_mode & LOCK_INSERT_INTENTION));
1392
lock = lock_rec_get_first(block, heap_no);
1395
if (lock->trx == trx
1396
&& lock_mode_stronger_or_eq(lock_get_mode(lock),
1397
precise_mode & LOCK_MODE_MASK)
1398
&& !lock_get_wait(lock)
1399
&& (!lock_rec_get_rec_not_gap(lock)
1400
|| (precise_mode & LOCK_REC_NOT_GAP)
1401
|| heap_no == PAGE_HEAP_NO_SUPREMUM)
1402
&& (!lock_rec_get_gap(lock)
1403
|| (precise_mode & LOCK_GAP)
1404
|| heap_no == PAGE_HEAP_NO_SUPREMUM)
1405
&& (!lock_rec_get_insert_intention(lock))) {
1410
lock = lock_rec_get_next(heap_no, lock);
1417
# ifndef UNIV_HOTBACKUP
1418
/*************************************************************************
1419
Checks if some other transaction has a lock request in the queue. */
1422
lock_rec_other_has_expl_req(
1423
/*========================*/
1424
/* out: lock or NULL */
1425
enum lock_mode mode, /* in: LOCK_S or LOCK_X */
1426
ulint gap, /* in: LOCK_GAP if also gap
1427
locks are taken into account,
1429
ulint wait, /* in: LOCK_WAIT if also
1430
waiting locks are taken into
1431
account, or 0 if not */
1432
const buf_block_t* block, /* in: buffer block containing
1434
ulint heap_no,/* in: heap number of the record */
1435
const trx_t* trx) /* in: transaction, or NULL if
1436
requests by all transactions
1437
are taken into account */
1441
ut_ad(mutex_own(&kernel_mutex));
1442
ut_ad(mode == LOCK_X || mode == LOCK_S);
1443
ut_ad(gap == 0 || gap == LOCK_GAP);
1444
ut_ad(wait == 0 || wait == LOCK_WAIT);
1446
lock = lock_rec_get_first(block, heap_no);
1449
if (lock->trx != trx
1451
|| !(lock_rec_get_gap(lock)
1452
|| heap_no == PAGE_HEAP_NO_SUPREMUM))
1453
&& (wait || !lock_get_wait(lock))
1454
&& lock_mode_stronger_or_eq(lock_get_mode(lock), mode)) {
1459
lock = lock_rec_get_next(heap_no, lock);
1464
# endif /* !UNIV_HOTBACKUP */
1465
#endif /* UNIV_DEBUG */
1467
/*************************************************************************
1468
Checks if some other transaction has a conflicting explicit lock request
1469
in the queue, so that we have to wait. */
1472
lock_rec_other_has_conflicting(
1473
/*===========================*/
1474
/* out: lock or NULL */
1475
enum lock_mode mode, /* in: LOCK_S or LOCK_X,
1476
possibly ORed to LOCK_GAP or
1478
LOCK_INSERT_INTENTION */
1479
const buf_block_t* block, /* in: buffer block containing
1481
ulint heap_no,/* in: heap number of the record */
1482
trx_t* trx) /* in: our transaction */
1486
ut_ad(mutex_own(&kernel_mutex));
1488
lock = lock_rec_get_first(block, heap_no);
1490
if (UNIV_LIKELY_NULL(lock)) {
1491
if (UNIV_UNLIKELY(heap_no == PAGE_HEAP_NO_SUPREMUM)) {
1494
if (lock_rec_has_to_wait(trx, mode, lock,
1499
lock = lock_rec_get_next(heap_no, lock);
1504
if (lock_rec_has_to_wait(trx, mode, lock,
1509
lock = lock_rec_get_next(heap_no, lock);
1517
/*************************************************************************
1518
Looks for a suitable type record lock struct by the same trx on the same page.
1519
This can be used to save space when a new record lock should be set on a page:
1520
no new struct is needed, if a suitable old is found. */
1523
lock_rec_find_similar_on_page(
1524
/*==========================*/
1525
/* out: lock or NULL */
1526
ulint type_mode, /* in: lock type_mode field */
1527
ulint heap_no, /* in: heap number of the record */
1528
lock_t* lock, /* in: lock_rec_get_first_on_page() */
1529
const trx_t* trx) /* in: transaction */
1531
ut_ad(mutex_own(&kernel_mutex));
1533
while (lock != NULL) {
1534
if (lock->trx == trx
1535
&& lock->type_mode == type_mode
1536
&& lock_rec_get_n_bits(lock) > heap_no) {
1541
lock = lock_rec_get_next_on_page(lock);
1547
/*************************************************************************
1548
Checks if some transaction has an implicit x-lock on a record in a secondary
1552
lock_sec_rec_some_has_impl_off_kernel(
1553
/*==================================*/
1554
/* out: transaction which has the x-lock, or
1556
const rec_t* rec, /* in: user record */
1557
dict_index_t* index, /* in: secondary index */
1558
const ulint* offsets)/* in: rec_get_offsets(rec, index) */
1560
const page_t* page = page_align(rec);
1562
ut_ad(mutex_own(&kernel_mutex));
1563
ut_ad(!dict_index_is_clust(index));
1564
ut_ad(page_rec_is_user_rec(rec));
1565
ut_ad(rec_offs_validate(rec, index, offsets));
1567
/* Some transaction may have an implicit x-lock on the record only
1568
if the max trx id for the page >= min trx id for the trx list, or
1569
database recovery is running. We do not write the changes of a page
1570
max trx id to the log, and therefore during recovery, this value
1571
for a page may be incorrect. */
1573
if (!(ut_dulint_cmp(page_get_max_trx_id(page),
1574
trx_list_get_min_trx_id()) >= 0)
1575
&& !recv_recovery_is_on()) {
1580
/* Ok, in this case it is possible that some transaction has an
1581
implicit x-lock. We have to look in the clustered index. */
1583
if (!lock_check_trx_id_sanity(page_get_max_trx_id(page),
1584
rec, index, offsets, TRUE)) {
1585
buf_page_print(page, 0);
1587
/* The page is corrupt: try to avoid a crash by returning
1592
return(row_vers_impl_x_locked_off_kernel(rec, index, offsets));
1595
/*************************************************************************
1596
Return approximate number or record locks (bits set in the bitmap) for
1597
this transaction. Since delete-marked records may be removed, the
1598
record count will not be precise. */
1601
lock_number_of_rows_locked(
1602
/*=======================*/
1603
trx_t* trx) /* in: transaction */
1606
ulint n_records = 0;
1610
lock = UT_LIST_GET_FIRST(trx->trx_locks);
1613
if (lock_get_type_low(lock) == LOCK_REC) {
1614
n_bits = lock_rec_get_n_bits(lock);
1616
for (n_bit = 0; n_bit < n_bits; n_bit++) {
1617
if (lock_rec_get_nth_bit(lock, n_bit)) {
1623
lock = UT_LIST_GET_NEXT(trx_locks, lock);
1629
/*============== RECORD LOCK CREATION AND QUEUE MANAGEMENT =============*/
1631
/*************************************************************************
1632
Creates a new record lock and inserts it to the lock queue. Does NOT check
1633
for deadlocks or lock compatibility! */
1638
/* out: created lock */
1639
ulint type_mode,/* in: lock mode and wait
1640
flag, type is ignored and
1641
replaced by LOCK_REC */
1642
const buf_block_t* block, /* in: buffer block containing
1644
ulint heap_no,/* in: heap number of the record */
1645
dict_index_t* index, /* in: index of record */
1646
trx_t* trx) /* in: transaction */
1655
ut_ad(mutex_own(&kernel_mutex));
1657
space = buf_block_get_space(block);
1658
page_no = buf_block_get_page_no(block);
1659
page = block->frame;
1661
ut_ad(!!page_is_comp(page) == dict_table_is_comp(index->table));
1663
/* If rec is the supremum record, then we reset the gap and
1664
LOCK_REC_NOT_GAP bits, as all locks on the supremum are
1665
automatically of the gap type */
1667
if (UNIV_UNLIKELY(heap_no == PAGE_HEAP_NO_SUPREMUM)) {
1668
ut_ad(!(type_mode & LOCK_REC_NOT_GAP));
1670
type_mode = type_mode & ~(LOCK_GAP | LOCK_REC_NOT_GAP);
1673
/* Make lock bitmap bigger by a safety margin */
1674
n_bits = page_dir_get_n_heap(page) + LOCK_PAGE_BITMAP_MARGIN;
1675
n_bytes = 1 + n_bits / 8;
1677
lock = mem_heap_alloc(trx->lock_heap, sizeof(lock_t) + n_bytes);
1679
UT_LIST_ADD_LAST(trx_locks, trx->trx_locks, lock);
1683
lock->type_mode = (type_mode & ~LOCK_TYPE_MASK) | LOCK_REC;
1684
lock->index = index;
1686
lock->un_member.rec_lock.space = space;
1687
lock->un_member.rec_lock.page_no = page_no;
1688
lock->un_member.rec_lock.n_bits = n_bytes * 8;
1690
/* Reset to zero the bitmap which resides immediately after the
1693
lock_rec_bitmap_reset(lock);
1695
/* Set the bit corresponding to rec */
1696
lock_rec_set_nth_bit(lock, heap_no);
1698
HASH_INSERT(lock_t, hash, lock_sys->rec_hash,
1699
lock_rec_fold(space, page_no), lock);
1700
if (UNIV_UNLIKELY(type_mode & LOCK_WAIT)) {
1702
lock_set_lock_and_trx_wait(lock, trx);
1708
/*************************************************************************
1709
Enqueues a waiting request for a lock which cannot be granted immediately.
1710
Checks for deadlocks. */
1713
lock_rec_enqueue_waiting(
1714
/*=====================*/
1715
/* out: DB_LOCK_WAIT,
1717
DB_QUE_THR_SUSPENDED, or
1718
DB_SUCCESS; DB_SUCCESS means
1719
that there was a deadlock, but
1720
another transaction was chosen
1721
as a victim, and we got the
1722
lock immediately: no need to
1724
ulint type_mode,/* in: lock mode this
1725
transaction is requesting:
1726
LOCK_S or LOCK_X, possibly
1727
ORed with LOCK_GAP or
1728
LOCK_REC_NOT_GAP, ORed with
1729
LOCK_INSERT_INTENTION if this
1730
waiting lock request is set
1731
when performing an insert of
1733
const buf_block_t* block, /* in: buffer block containing
1735
ulint heap_no,/* in: heap number of the record */
1736
dict_index_t* index, /* in: index of record */
1737
que_thr_t* thr) /* in: query thread */
1742
ut_ad(mutex_own(&kernel_mutex));
1744
/* Test if there already is some other reason to suspend thread:
1745
we do not enqueue a lock request if the query thread should be
1748
if (UNIV_UNLIKELY(que_thr_stop(thr))) {
1752
return(DB_QUE_THR_SUSPENDED);
1755
trx = thr_get_trx(thr);
1757
switch (trx_get_dict_operation(trx)) {
1758
case TRX_DICT_OP_NONE:
1760
case TRX_DICT_OP_TABLE:
1761
case TRX_DICT_OP_INDEX:
1762
ut_print_timestamp(stderr);
1763
fputs(" InnoDB: Error: a record lock wait happens"
1764
" in a dictionary operation!\n"
1765
"InnoDB: ", stderr);
1766
dict_index_name_print(stderr, trx, index);
1768
"InnoDB: Submit a detailed bug report"
1769
" to http://bugs.mysql.com\n",
1773
/* Enqueue the lock request that will wait to be granted */
1774
lock = lock_rec_create(type_mode | LOCK_WAIT,
1775
block, heap_no, index, trx);
1777
/* Check if a deadlock occurs: if yes, remove the lock request and
1778
return an error code */
1780
if (UNIV_UNLIKELY(lock_deadlock_occurs(lock, trx))) {
1782
lock_reset_lock_and_trx_wait(lock);
1783
lock_rec_reset_nth_bit(lock, heap_no);
1785
return(DB_DEADLOCK);
1788
/* If there was a deadlock but we chose another transaction as a
1789
victim, it is possible that we already have the lock now granted! */
1791
if (trx->wait_lock == NULL) {
1796
trx->que_state = TRX_QUE_LOCK_WAIT;
1797
trx->was_chosen_as_deadlock_victim = FALSE;
1798
trx->wait_started = time(NULL);
1800
ut_a(que_thr_stop(thr));
1803
if (lock_print_waits) {
1804
fprintf(stderr, "Lock wait for trx %lu in index ",
1805
(ulong) ut_dulint_get_low(trx->id));
1806
ut_print_name(stderr, trx, FALSE, index->name);
1808
#endif /* UNIV_DEBUG */
1810
return(DB_LOCK_WAIT);
1813
/*************************************************************************
1814
Adds a record lock request in the record queue. The request is normally
1815
added as the last in the queue, but if there are no waiting lock requests
1816
on the record, and the request to be added is not a waiting request, we
1817
can reuse a suitable record lock object already existing on the same page,
1818
just setting the appropriate bit in its bitmap. This is a low-level function
1819
which does NOT check for deadlocks or lock compatibility! */
1822
lock_rec_add_to_queue(
1823
/*==================*/
1824
/* out: lock where the bit was set */
1825
ulint type_mode,/* in: lock mode, wait, gap
1826
etc. flags; type is ignored
1827
and replaced by LOCK_REC */
1828
const buf_block_t* block, /* in: buffer block containing
1830
ulint heap_no,/* in: heap number of the record */
1831
dict_index_t* index, /* in: index of record */
1832
trx_t* trx) /* in: transaction */
1836
ut_ad(mutex_own(&kernel_mutex));
1838
switch (type_mode & LOCK_MODE_MASK) {
1846
if (!(type_mode & (LOCK_WAIT | LOCK_GAP))) {
1847
enum lock_mode mode = (type_mode & LOCK_MODE_MASK) == LOCK_S
1851
= lock_rec_other_has_expl_req(mode, 0, LOCK_WAIT,
1852
block, heap_no, trx);
1855
#endif /* UNIV_DEBUG */
1857
type_mode |= LOCK_REC;
1859
/* If rec is the supremum record, then we can reset the gap bit, as
1860
all locks on the supremum are automatically of the gap type, and we
1861
try to avoid unnecessary memory consumption of a new record lock
1862
struct for a gap type lock */
1864
if (UNIV_UNLIKELY(heap_no == PAGE_HEAP_NO_SUPREMUM)) {
1865
ut_ad(!(type_mode & LOCK_REC_NOT_GAP));
1867
/* There should never be LOCK_REC_NOT_GAP on a supremum
1868
record, but let us play safe */
1870
type_mode = type_mode & ~(LOCK_GAP | LOCK_REC_NOT_GAP);
1873
/* Look for a waiting lock request on the same record or on a gap */
1875
lock = lock_rec_get_first_on_page(block);
1877
while (lock != NULL) {
1878
if (lock_get_wait(lock)
1879
&& (lock_rec_get_nth_bit(lock, heap_no))) {
1881
goto somebody_waits;
1884
lock = lock_rec_get_next_on_page(lock);
1887
if (UNIV_LIKELY(!(type_mode & LOCK_WAIT))) {
1889
/* Look for a similar record lock on the same page:
1890
if one is found and there are no waiting lock requests,
1891
we can just set the bit */
1893
lock = lock_rec_find_similar_on_page(
1895
lock_rec_get_first_on_page(block), trx);
1899
lock_rec_set_nth_bit(lock, heap_no);
1906
return(lock_rec_create(type_mode, block, heap_no, index, trx));
1909
/*************************************************************************
1910
This is a fast routine for locking a record in the most common cases:
1911
there are no explicit locks on the page, or there is just one lock, owned
1912
by this transaction, and of the right type_mode. This is a low-level function
1913
which does NOT look at implicit locks! Checks lock compatibility within
1914
explicit locks. This function sets a normal next-key lock, or in the case of
1915
a page supremum record, a gap type lock. */
1920
/* out: TRUE if locking succeeded */
1921
ibool impl, /* in: if TRUE, no lock is set
1922
if no wait is necessary: we
1923
assume that the caller will
1924
set an implicit lock */
1925
ulint mode, /* in: lock mode: LOCK_X or
1926
LOCK_S possibly ORed to either
1927
LOCK_GAP or LOCK_REC_NOT_GAP */
1928
const buf_block_t* block, /* in: buffer block containing
1930
ulint heap_no,/* in: heap number of record */
1931
dict_index_t* index, /* in: index of record */
1932
que_thr_t* thr) /* in: query thread */
1937
ut_ad(mutex_own(&kernel_mutex));
1938
ut_ad((LOCK_MODE_MASK & mode) != LOCK_S
1939
|| lock_table_has(thr_get_trx(thr), index->table, LOCK_IS));
1940
ut_ad((LOCK_MODE_MASK & mode) != LOCK_X
1941
|| lock_table_has(thr_get_trx(thr), index->table, LOCK_IX));
1942
ut_ad((LOCK_MODE_MASK & mode) == LOCK_S
1943
|| (LOCK_MODE_MASK & mode) == LOCK_X);
1944
ut_ad(mode - (LOCK_MODE_MASK & mode) == LOCK_GAP
1945
|| mode - (LOCK_MODE_MASK & mode) == 0
1946
|| mode - (LOCK_MODE_MASK & mode) == LOCK_REC_NOT_GAP);
1948
lock = lock_rec_get_first_on_page(block);
1950
trx = thr_get_trx(thr);
1954
lock_rec_create(mode, block, heap_no, index, trx);
1956
if (srv_locks_unsafe_for_binlog
1957
|| trx->isolation_level
1958
== TRX_ISO_READ_COMMITTED) {
1959
trx_register_new_rec_lock(trx, index);
1966
if (lock_rec_get_next_on_page(lock)) {
1971
if (lock->trx != trx
1972
|| lock->type_mode != (mode | LOCK_REC)
1973
|| lock_rec_get_n_bits(lock) <= heap_no) {
1979
/* If the nth bit of the record lock is already set then we
1980
do not set a new lock bit, otherwise we do set */
1982
if (!lock_rec_get_nth_bit(lock, heap_no)) {
1983
lock_rec_set_nth_bit(lock, heap_no);
1984
if (srv_locks_unsafe_for_binlog
1985
|| trx->isolation_level
1986
== TRX_ISO_READ_COMMITTED) {
1987
trx_register_new_rec_lock(trx, index);
1995
/*************************************************************************
1996
This is the general, and slower, routine for locking a record. This is a
1997
low-level function which does NOT look at implicit locks! Checks lock
1998
compatibility within explicit locks. This function sets a normal next-key
1999
lock, or in the case of a page supremum record, a gap type lock. */
2005
DB_LOCK_WAIT, or error code */
2006
ibool impl, /* in: if TRUE, no lock is set
2007
if no wait is necessary: we
2008
assume that the caller will
2009
set an implicit lock */
2010
ulint mode, /* in: lock mode: LOCK_X or
2011
LOCK_S possibly ORed to either
2012
LOCK_GAP or LOCK_REC_NOT_GAP */
2013
const buf_block_t* block, /* in: buffer block containing
2015
ulint heap_no,/* in: heap number of record */
2016
dict_index_t* index, /* in: index of record */
2017
que_thr_t* thr) /* in: query thread */
2022
ut_ad(mutex_own(&kernel_mutex));
2023
ut_ad((LOCK_MODE_MASK & mode) != LOCK_S
2024
|| lock_table_has(thr_get_trx(thr), index->table, LOCK_IS));
2025
ut_ad((LOCK_MODE_MASK & mode) != LOCK_X
2026
|| lock_table_has(thr_get_trx(thr), index->table, LOCK_IX));
2027
ut_ad((LOCK_MODE_MASK & mode) == LOCK_S
2028
|| (LOCK_MODE_MASK & mode) == LOCK_X);
2029
ut_ad(mode - (LOCK_MODE_MASK & mode) == LOCK_GAP
2030
|| mode - (LOCK_MODE_MASK & mode) == 0
2031
|| mode - (LOCK_MODE_MASK & mode) == LOCK_REC_NOT_GAP);
2033
trx = thr_get_trx(thr);
2035
if (lock_rec_has_expl(mode, block, heap_no, trx)) {
2036
/* The trx already has a strong enough lock on rec: do
2040
} else if (lock_rec_other_has_conflicting(mode, block, heap_no, trx)) {
2042
/* If another transaction has a non-gap conflicting request in
2043
the queue, as this transaction does not have a lock strong
2044
enough already granted on the record, we have to wait. */
2046
err = lock_rec_enqueue_waiting(mode, block, heap_no,
2049
if (srv_locks_unsafe_for_binlog
2050
|| trx->isolation_level == TRX_ISO_READ_COMMITTED) {
2051
trx_register_new_rec_lock(trx, index);
2055
/* Set the requested lock on the record */
2057
lock_rec_add_to_queue(LOCK_REC | mode, block,
2058
heap_no, index, trx);
2059
if (srv_locks_unsafe_for_binlog
2060
|| trx->isolation_level
2061
== TRX_ISO_READ_COMMITTED) {
2062
trx_register_new_rec_lock(trx, index);
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. */
2083
DB_LOCK_WAIT, or error code */
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 */
2099
ut_ad(mutex_own(&kernel_mutex));
2100
ut_ad((LOCK_MODE_MASK & mode) != LOCK_S
2101
|| lock_table_has(thr_get_trx(thr), index->table, LOCK_IS));
2102
ut_ad((LOCK_MODE_MASK & mode) != LOCK_X
2103
|| lock_table_has(thr_get_trx(thr), index->table, LOCK_IX));
2104
ut_ad((LOCK_MODE_MASK & mode) == LOCK_S
2105
|| (LOCK_MODE_MASK & mode) == LOCK_X);
2106
ut_ad(mode - (LOCK_MODE_MASK & mode) == LOCK_GAP
2107
|| mode - (LOCK_MODE_MASK & mode) == LOCK_REC_NOT_GAP
2108
|| mode - (LOCK_MODE_MASK & mode) == 0);
2110
if (lock_rec_lock_fast(impl, mode, block, heap_no, index, thr)) {
2112
/* We try a simplified and faster subroutine for the most
2117
err = lock_rec_lock_slow(impl, mode, block,
2118
heap_no, index, thr);
2124
/*************************************************************************
2125
Checks if a waiting record lock request still has to wait in a queue. */
2128
lock_rec_has_to_wait_in_queue(
2129
/*==========================*/
2130
/* out: TRUE if still has to wait */
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: 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) {
2177
if (lock->trx->auto_inc_lock != NULL) {
2179
"InnoDB: Error: trx already had"
2180
" an AUTO-INC lock!\n");
2183
/* Store pointer to lock to trx so that we know to
2184
release it at the end of the SQL statement */
2186
lock->trx->auto_inc_lock = lock;
2190
if (lock_print_waits) {
2191
fprintf(stderr, "Lock wait for trx %lu ends\n",
2192
(ulong) ut_dulint_get_low(lock->trx->id));
2194
#endif /* UNIV_DEBUG */
2196
/* If we are resolving a deadlock by choosing another transaction
2197
as a victim, then our original transaction may not be in the
2198
TRX_QUE_LOCK_WAIT state, and there is no need to end the lock wait
2201
if (lock->trx->que_state == TRX_QUE_LOCK_WAIT) {
2202
trx_end_lock_wait(lock->trx);
2206
/*****************************************************************
2207
Cancels a waiting record lock request and releases the waiting transaction
2208
that requested it. NOTE: does NOT check if waiting lock requests behind this
2209
one can now be granted! */
2214
lock_t* lock) /* in: waiting record lock request */
2216
ut_ad(mutex_own(&kernel_mutex));
2217
ut_ad(lock_get_type_low(lock) == LOCK_REC);
2219
/* Reset the bit (there can be only one set bit) in the lock bitmap */
2220
lock_rec_reset_nth_bit(lock, lock_rec_find_set_bit(lock));
2222
/* Reset the wait flag and the back pointer to lock in trx */
2224
lock_reset_lock_and_trx_wait(lock);
2226
/* The following function releases the trx from lock wait */
2228
trx_end_lock_wait(lock->trx);
2231
/*****************************************************************
2232
Removes a record lock request, waiting or granted, from the queue and
2233
grants locks to other transactions in the queue if they now are entitled
2234
to a lock. NOTE: all record locks contained in in_lock are removed. */
2237
lock_rec_dequeue_from_page(
2238
/*=======================*/
2239
lock_t* in_lock)/* in: record lock object: all record locks which
2240
are contained in this lock object are removed;
2241
transactions waiting behind will get their lock
2242
requests granted, if they are now qualified to it */
2249
ut_ad(mutex_own(&kernel_mutex));
2250
ut_ad(lock_get_type_low(in_lock) == LOCK_REC);
2254
space = in_lock->un_member.rec_lock.space;
2255
page_no = in_lock->un_member.rec_lock.page_no;
2257
HASH_DELETE(lock_t, hash, lock_sys->rec_hash,
2258
lock_rec_fold(space, page_no), in_lock);
2260
UT_LIST_REMOVE(trx_locks, trx->trx_locks, in_lock);
2262
/* Check if waiting locks in the queue can now be granted: grant
2263
locks if there are no conflicting locks ahead. */
2265
lock = lock_rec_get_first_on_page_addr(space, page_no);
2267
while (lock != NULL) {
2268
if (lock_get_wait(lock)
2269
&& !lock_rec_has_to_wait_in_queue(lock)) {
2271
/* Grant the lock */
2275
lock = lock_rec_get_next_on_page(lock);
2279
/*****************************************************************
2280
Removes a record lock request, waiting or granted, from the queue. */
2285
lock_t* in_lock)/* in: record lock object: all record locks which
2286
are contained in this lock object are removed */
2292
ut_ad(mutex_own(&kernel_mutex));
2293
ut_ad(lock_get_type_low(in_lock) == LOCK_REC);
2297
space = in_lock->un_member.rec_lock.space;
2298
page_no = in_lock->un_member.rec_lock.page_no;
2300
HASH_DELETE(lock_t, hash, lock_sys->rec_hash,
2301
lock_rec_fold(space, page_no), in_lock);
2303
UT_LIST_REMOVE(trx_locks, trx->trx_locks, in_lock);
2306
/*****************************************************************
2307
Removes record lock objects set on an index page which is discarded. This
2308
function does not move locks, or check for waiting locks, therefore the
2309
lock bitmaps must already be reset when this function is called. */
2312
lock_rec_free_all_from_discard_page(
2313
/*================================*/
2314
const buf_block_t* block) /* in: page to be discarded */
2321
ut_ad(mutex_own(&kernel_mutex));
2323
space = buf_block_get_space(block);
2324
page_no = buf_block_get_page_no(block);
2326
lock = lock_rec_get_first_on_page_addr(space, page_no);
2328
while (lock != NULL) {
2329
ut_ad(lock_rec_find_set_bit(lock) == ULINT_UNDEFINED);
2330
ut_ad(!lock_get_wait(lock));
2332
next_lock = lock_rec_get_next_on_page(lock);
2334
lock_rec_discard(lock);
2340
/*============= RECORD LOCK MOVING AND INHERITING ===================*/
2342
/*****************************************************************
2343
Resets the lock bits for a single record. Releases transactions waiting for
2344
lock requests here. */
2347
lock_rec_reset_and_release_wait(
2348
/*============================*/
2349
const buf_block_t* block, /* in: buffer block containing
2351
ulint heap_no)/* in: heap number of record */
2355
ut_ad(mutex_own(&kernel_mutex));
2357
lock = lock_rec_get_first(block, heap_no);
2359
while (lock != NULL) {
2360
if (lock_get_wait(lock)) {
2361
lock_rec_cancel(lock);
2363
lock_rec_reset_nth_bit(lock, heap_no);
2366
lock = lock_rec_get_next(heap_no, lock);
2370
/*****************************************************************
2371
Makes a record to inherit the locks (except LOCK_INSERT_INTENTION type)
2372
of another record as gap type locks, but does not reset the lock bits of
2373
the other record. Also waiting lock requests on rec are inherited as
2374
GRANTED gap locks. */
2377
lock_rec_inherit_to_gap(
2378
/*====================*/
2379
const buf_block_t* heir_block, /* in: block containing the
2380
record which inherits */
2381
const buf_block_t* block, /* in: block containing the
2382
record from which inherited;
2383
does NOT reset the locks on
2385
ulint heir_heap_no, /* in: heap_no of the
2386
inheriting record */
2387
ulint heap_no) /* in: heap_no of the
2392
ut_ad(mutex_own(&kernel_mutex));
2394
lock = lock_rec_get_first(block, heap_no);
2396
/* If srv_locks_unsafe_for_binlog is TRUE or session is using
2397
READ COMMITTED isolation level, we do not want locks set
2398
by an UPDATE or a DELETE to be inherited as gap type locks. But we
2399
DO want S-locks set by a consistency constraint to be inherited also
2402
while (lock != NULL) {
2403
if (!lock_rec_get_insert_intention(lock)
2404
&& !((srv_locks_unsafe_for_binlog
2405
|| lock->trx->isolation_level
2406
== TRX_ISO_READ_COMMITTED)
2407
&& lock_get_mode(lock) == LOCK_X)) {
2409
lock_rec_add_to_queue(LOCK_REC | LOCK_GAP
2410
| lock_get_mode(lock),
2411
heir_block, heir_heap_no,
2412
lock->index, lock->trx);
2415
lock = lock_rec_get_next(heap_no, lock);
2419
/*****************************************************************
2420
Makes a record to inherit the gap locks (except LOCK_INSERT_INTENTION type)
2421
of another record as gap type locks, but does not reset the lock bits of the
2422
other record. Also waiting lock requests are inherited as GRANTED gap locks. */
2425
lock_rec_inherit_to_gap_if_gap_lock(
2426
/*================================*/
2427
const buf_block_t* block, /* in: buffer block */
2428
ulint heir_heap_no, /* in: heap_no of
2429
record which inherits */
2430
ulint heap_no) /* in: heap_no of record
2431
from which inherited;
2432
does NOT reset the locks
2437
ut_ad(mutex_own(&kernel_mutex));
2439
lock = lock_rec_get_first(block, heap_no);
2441
while (lock != NULL) {
2442
if (!lock_rec_get_insert_intention(lock)
2443
&& (heap_no == PAGE_HEAP_NO_SUPREMUM
2444
|| !lock_rec_get_rec_not_gap(lock))) {
2446
lock_rec_add_to_queue(LOCK_REC | LOCK_GAP
2447
| lock_get_mode(lock),
2448
block, heir_heap_no,
2449
lock->index, lock->trx);
2452
lock = lock_rec_get_next(heap_no, lock);
2456
/*****************************************************************
2457
Moves the locks of a record to another record and resets the lock bits of
2458
the donating record. */
2463
const buf_block_t* receiver, /* in: buffer block containing
2464
the receiving record */
2465
const buf_block_t* donator, /* in: buffer block containing
2466
the donating record */
2467
ulint receiver_heap_no,/* in: heap_no of the record
2468
which gets the locks; there
2469
must be no lock requests
2471
ulint donator_heap_no)/* in: heap_no of the record
2472
which gives the locks */
2476
ut_ad(mutex_own(&kernel_mutex));
2478
lock = lock_rec_get_first(donator, donator_heap_no);
2480
ut_ad(lock_rec_get_first(receiver, receiver_heap_no) == NULL);
2482
while (lock != NULL) {
2483
const ulint type_mode = lock->type_mode;
2485
lock_rec_reset_nth_bit(lock, donator_heap_no);
2487
if (UNIV_UNLIKELY(type_mode & LOCK_WAIT)) {
2488
lock_reset_lock_and_trx_wait(lock);
2491
/* Note that we FIRST reset the bit, and then set the lock:
2492
the function works also if donator == receiver */
2494
lock_rec_add_to_queue(type_mode, receiver, receiver_heap_no,
2495
lock->index, lock->trx);
2496
lock = lock_rec_get_next(donator_heap_no, lock);
2499
ut_ad(lock_rec_get_first(donator, donator_heap_no) == NULL);
2502
/*****************************************************************
2503
Updates the lock table when we have reorganized a page. NOTE: we copy
2504
also the locks set on the infimum of the page; the infimum may carry
2505
locks if an update of a record is occurring on the page, and its locks
2506
were temporarily stored on the infimum. */
2509
lock_move_reorganize_page(
2510
/*======================*/
2511
const buf_block_t* block, /* in: old index page, now
2513
const buf_block_t* oblock) /* in: copy of the old, not
2517
UT_LIST_BASE_NODE_T(lock_t) old_locks;
2518
mem_heap_t* heap = NULL;
2521
lock_mutex_enter_kernel();
2523
lock = lock_rec_get_first_on_page(block);
2526
lock_mutex_exit_kernel();
2531
heap = mem_heap_create(256);
2533
/* Copy first all the locks on the page to heap and reset the
2534
bitmaps in the original locks; chain the copies of the locks
2535
using the trx_locks field in them. */
2537
UT_LIST_INIT(old_locks);
2540
/* Make a copy of the lock */
2541
lock_t* old_lock = lock_rec_copy(lock, heap);
2543
UT_LIST_ADD_LAST(trx_locks, old_locks, old_lock);
2545
/* Reset bitmap of lock */
2546
lock_rec_bitmap_reset(lock);
2548
if (lock_get_wait(lock)) {
2549
lock_reset_lock_and_trx_wait(lock);
2552
lock = lock_rec_get_next_on_page(lock);
2553
} while (lock != NULL);
2555
comp = page_is_comp(block->frame);
2556
ut_ad(comp == page_is_comp(oblock->frame));
2558
for (lock = UT_LIST_GET_FIRST(old_locks); lock;
2559
lock = UT_LIST_GET_NEXT(trx_locks, lock)) {
2560
/* NOTE: we copy also the locks set on the infimum and
2561
supremum of the page; the infimum may carry locks if an
2562
update of a record is occurring on the page, and its locks
2563
were temporarily stored on the infimum */
2567
page_cur_set_before_first(block, &cur1);
2568
page_cur_set_before_first(oblock, &cur2);
2570
/* Set locks according to old locks */
2575
ut_ad(comp || !memcmp(page_cur_get_rec(&cur1),
2576
page_cur_get_rec(&cur2),
2577
rec_get_data_size_old(
2580
if (UNIV_LIKELY(comp)) {
2581
old_heap_no = rec_get_heap_no_new(
2582
page_cur_get_rec(&cur2));
2583
new_heap_no = rec_get_heap_no_new(
2584
page_cur_get_rec(&cur1));
2586
old_heap_no = rec_get_heap_no_old(
2587
page_cur_get_rec(&cur2));
2588
new_heap_no = rec_get_heap_no_old(
2589
page_cur_get_rec(&cur1));
2592
if (lock_rec_get_nth_bit(lock, old_heap_no)) {
2594
/* Clear the bit in old_lock. */
2595
ut_d(lock_rec_reset_nth_bit(lock,
2598
/* NOTE that the old lock bitmap could be too
2599
small for the new heap number! */
2601
lock_rec_add_to_queue(lock->type_mode, block,
2603
lock->index, lock->trx);
2605
/* if (new_heap_no == PAGE_HEAP_NO_SUPREMUM
2606
&& lock_get_wait(lock)) {
2608
"---\n--\n!!!Lock reorg: supr type %lu\n",
2614
(new_heap_no == PAGE_HEAP_NO_SUPREMUM)) {
2616
ut_ad(old_heap_no == PAGE_HEAP_NO_SUPREMUM);
2620
page_cur_move_to_next(&cur1);
2621
page_cur_move_to_next(&cur2);
2626
ulint i = lock_rec_find_set_bit(lock);
2628
/* Check that all locks were moved. */
2629
if (UNIV_UNLIKELY(i != ULINT_UNDEFINED)) {
2631
"lock_move_reorganize_page():"
2632
" %lu not moved in %p\n",
2633
(ulong) i, (void*) lock);
2637
#endif /* UNIV_DEBUG */
2640
lock_mutex_exit_kernel();
2642
mem_heap_free(heap);
2644
#ifdef UNIV_DEBUG_LOCK_VALIDATE
2645
ut_ad(lock_rec_validate_page(buf_block_get_space(block),
2646
buf_block_get_page_no(block)));
2650
/*****************************************************************
2651
Moves the explicit locks on user records to another page if a record
2652
list end is moved to another page. */
2655
lock_move_rec_list_end(
2656
/*===================*/
2657
const buf_block_t* new_block, /* in: index page to move to */
2658
const buf_block_t* block, /* in: index page */
2659
const rec_t* rec) /* in: record on page: this
2660
is the first record moved */
2663
const ulint comp = page_rec_is_comp(rec);
2665
lock_mutex_enter_kernel();
2667
/* Note: when we move locks from record to record, waiting locks
2668
and possible granted gap type locks behind them are enqueued in
2669
the original order, because new elements are inserted to a hash
2670
table to the end of the hash chain, and lock_rec_add_to_queue
2671
does not reuse locks if there are waiters in the queue. */
2673
for (lock = lock_rec_get_first_on_page(block); lock;
2674
lock = lock_rec_get_next_on_page(lock)) {
2677
const ulint type_mode = lock->type_mode;
2679
page_cur_position(rec, block, &cur1);
2681
if (page_cur_is_before_first(&cur1)) {
2682
page_cur_move_to_next(&cur1);
2685
page_cur_set_before_first(new_block, &cur2);
2686
page_cur_move_to_next(&cur2);
2688
/* Copy lock requests on user records to new page and
2689
reset the lock bits on the old */
2691
while (!page_cur_is_after_last(&cur1)) {
2695
heap_no = rec_get_heap_no_new(
2696
page_cur_get_rec(&cur1));
2698
heap_no = rec_get_heap_no_old(
2699
page_cur_get_rec(&cur1));
2700
ut_ad(!memcmp(page_cur_get_rec(&cur1),
2701
page_cur_get_rec(&cur2),
2702
rec_get_data_size_old(
2703
page_cur_get_rec(&cur2))));
2706
if (lock_rec_get_nth_bit(lock, heap_no)) {
2707
lock_rec_reset_nth_bit(lock, heap_no);
2709
if (UNIV_UNLIKELY(type_mode & LOCK_WAIT)) {
2710
lock_reset_lock_and_trx_wait(lock);
2714
heap_no = rec_get_heap_no_new(
2715
page_cur_get_rec(&cur2));
2717
heap_no = rec_get_heap_no_old(
2718
page_cur_get_rec(&cur2));
2721
lock_rec_add_to_queue(type_mode,
2723
lock->index, lock->trx);
2726
page_cur_move_to_next(&cur1);
2727
page_cur_move_to_next(&cur2);
2731
lock_mutex_exit_kernel();
2733
#ifdef UNIV_DEBUG_LOCK_VALIDATE
2734
ut_ad(lock_rec_validate_page(buf_block_get_space(block),
2735
buf_block_get_page_no(block)));
2736
ut_ad(lock_rec_validate_page(buf_block_get_space(new_block),
2737
buf_block_get_page_no(new_block)));
2741
/*****************************************************************
2742
Moves the explicit locks on user records to another page if a record
2743
list start is moved to another page. */
2746
lock_move_rec_list_start(
2747
/*=====================*/
2748
const buf_block_t* new_block, /* in: index page to move to */
2749
const buf_block_t* block, /* in: index page */
2750
const rec_t* rec, /* in: record on page:
2752
record NOT copied */
2753
const rec_t* old_end) /* in: old
2760
const ulint comp = page_rec_is_comp(rec);
2762
ut_ad(block->frame == page_align(rec));
2763
ut_ad(new_block->frame == page_align(old_end));
2765
lock_mutex_enter_kernel();
2767
for (lock = lock_rec_get_first_on_page(block); lock;
2768
lock = lock_rec_get_next_on_page(lock)) {
2771
const ulint type_mode = lock->type_mode;
2773
page_cur_set_before_first(block, &cur1);
2774
page_cur_move_to_next(&cur1);
2776
page_cur_position(old_end, new_block, &cur2);
2777
page_cur_move_to_next(&cur2);
2779
/* Copy lock requests on user records to new page and
2780
reset the lock bits on the old */
2782
while (page_cur_get_rec(&cur1) != rec) {
2786
heap_no = rec_get_heap_no_new(
2787
page_cur_get_rec(&cur1));
2789
heap_no = rec_get_heap_no_old(
2790
page_cur_get_rec(&cur1));
2791
ut_ad(!memcmp(page_cur_get_rec(&cur1),
2792
page_cur_get_rec(&cur2),
2793
rec_get_data_size_old(
2798
if (lock_rec_get_nth_bit(lock, heap_no)) {
2799
lock_rec_reset_nth_bit(lock, heap_no);
2801
if (UNIV_UNLIKELY(type_mode & LOCK_WAIT)) {
2802
lock_reset_lock_and_trx_wait(lock);
2806
heap_no = rec_get_heap_no_new(
2807
page_cur_get_rec(&cur2));
2809
heap_no = rec_get_heap_no_old(
2810
page_cur_get_rec(&cur2));
2813
lock_rec_add_to_queue(type_mode,
2815
lock->index, lock->trx);
2818
page_cur_move_to_next(&cur1);
2819
page_cur_move_to_next(&cur2);
2823
if (page_rec_is_supremum(rec)) {
2826
for (i = PAGE_HEAP_NO_USER_LOW;
2827
i < lock_rec_get_n_bits(lock); i++) {
2829
(lock_rec_get_nth_bit(lock, i))) {
2832
"lock_move_rec_list_start():"
2833
" %lu not moved in %p\n",
2834
(ulong) i, (void*) lock);
2839
#endif /* UNIV_DEBUG */
2842
lock_mutex_exit_kernel();
2844
#ifdef UNIV_DEBUG_LOCK_VALIDATE
2845
ut_ad(lock_rec_validate_page(buf_block_get_space(block),
2846
buf_block_get_page_no(block)));
2850
/*****************************************************************
2851
Updates the lock table when a page is split to the right. */
2854
lock_update_split_right(
2855
/*====================*/
2856
const buf_block_t* right_block, /* in: right page */
2857
const buf_block_t* left_block) /* in: left page */
2859
ulint heap_no = lock_get_min_heap_no(right_block);
2861
lock_mutex_enter_kernel();
2863
/* Move the locks on the supremum of the left page to the supremum
2864
of the right page */
2866
lock_rec_move(right_block, left_block,
2867
PAGE_HEAP_NO_SUPREMUM, PAGE_HEAP_NO_SUPREMUM);
2869
/* Inherit the locks to the supremum of left page from the successor
2870
of the infimum on right page */
2872
lock_rec_inherit_to_gap(left_block, right_block,
2873
PAGE_HEAP_NO_SUPREMUM, heap_no);
2875
lock_mutex_exit_kernel();
2878
/*****************************************************************
2879
Updates the lock table when a page is merged to the right. */
2882
lock_update_merge_right(
2883
/*====================*/
2884
const buf_block_t* right_block, /* in: right page to
2886
const rec_t* orig_succ, /* in: original
2887
successor of infimum
2890
const buf_block_t* left_block) /* in: merged index
2894
lock_mutex_enter_kernel();
2896
/* Inherit the locks from the supremum of the left page to the
2897
original successor of infimum on the right page, to which the left
2900
lock_rec_inherit_to_gap(right_block, left_block,
2901
page_rec_get_heap_no(orig_succ),
2902
PAGE_HEAP_NO_SUPREMUM);
2904
/* Reset the locks on the supremum of the left page, releasing
2905
waiting transactions */
2907
lock_rec_reset_and_release_wait(left_block,
2908
PAGE_HEAP_NO_SUPREMUM);
2910
lock_rec_free_all_from_discard_page(left_block);
2912
lock_mutex_exit_kernel();
2915
/*****************************************************************
2916
Updates the lock table when the root page is copied to another in
2917
btr_root_raise_and_insert. Note that we leave lock structs on the
2918
root page, even though they do not make sense on other than leaf
2919
pages: the reason is that in a pessimistic update the infimum record
2920
of the root page will act as a dummy carrier of the locks of the record
2924
lock_update_root_raise(
2925
/*===================*/
2926
const buf_block_t* block, /* in: index page to which copied */
2927
const buf_block_t* root) /* in: root page */
2929
lock_mutex_enter_kernel();
2931
/* Move the locks on the supremum of the root to the supremum
2934
lock_rec_move(block, root,
2935
PAGE_HEAP_NO_SUPREMUM, PAGE_HEAP_NO_SUPREMUM);
2936
lock_mutex_exit_kernel();
2939
/*****************************************************************
2940
Updates the lock table when a page is copied to another and the original page
2941
is removed from the chain of leaf pages, except if page is the root! */
2944
lock_update_copy_and_discard(
2945
/*=========================*/
2946
const buf_block_t* new_block, /* in: index page to
2948
const buf_block_t* block) /* in: index page;
2951
lock_mutex_enter_kernel();
2953
/* Move the locks on the supremum of the old page to the supremum
2956
lock_rec_move(new_block, block,
2957
PAGE_HEAP_NO_SUPREMUM, PAGE_HEAP_NO_SUPREMUM);
2958
lock_rec_free_all_from_discard_page(block);
2960
lock_mutex_exit_kernel();
2963
/*****************************************************************
2964
Updates the lock table when a page is split to the left. */
2967
lock_update_split_left(
2968
/*===================*/
2969
const buf_block_t* right_block, /* in: right page */
2970
const buf_block_t* left_block) /* in: left page */
2972
ulint heap_no = lock_get_min_heap_no(right_block);
2974
lock_mutex_enter_kernel();
2976
/* Inherit the locks to the supremum of the left page from the
2977
successor of the infimum on the right page */
2979
lock_rec_inherit_to_gap(left_block, right_block,
2980
PAGE_HEAP_NO_SUPREMUM, heap_no);
2982
lock_mutex_exit_kernel();
2985
/*****************************************************************
2986
Updates the lock table when a page is merged to the left. */
2989
lock_update_merge_left(
2990
/*===================*/
2991
const buf_block_t* left_block, /* in: left page to
2993
const rec_t* orig_pred, /* in: original predecessor
2994
of supremum on the left page
2996
const buf_block_t* right_block) /* in: merged index page
2997
which will be discarded */
2999
const rec_t* left_next_rec;
3001
ut_ad(left_block->frame == page_align(orig_pred));
3003
lock_mutex_enter_kernel();
3005
left_next_rec = page_rec_get_next_const(orig_pred);
3007
if (!page_rec_is_supremum(left_next_rec)) {
3009
/* Inherit the locks on the supremum of the left page to the
3010
first record which was moved from the right page */
3012
lock_rec_inherit_to_gap(left_block, left_block,
3013
page_rec_get_heap_no(left_next_rec),
3014
PAGE_HEAP_NO_SUPREMUM);
3016
/* Reset the locks on the supremum of the left page,
3017
releasing waiting transactions */
3019
lock_rec_reset_and_release_wait(left_block,
3020
PAGE_HEAP_NO_SUPREMUM);
3023
/* Move the locks from the supremum of right page to the supremum
3026
lock_rec_move(left_block, right_block,
3027
PAGE_HEAP_NO_SUPREMUM, PAGE_HEAP_NO_SUPREMUM);
3029
lock_rec_free_all_from_discard_page(right_block);
3031
lock_mutex_exit_kernel();
3034
/*****************************************************************
3035
Resets the original locks on heir and replaces them with gap type locks
3036
inherited from rec. */
3039
lock_rec_reset_and_inherit_gap_locks(
3040
/*=================================*/
3041
const buf_block_t* heir_block, /* in: block containing the
3042
record which inherits */
3043
const buf_block_t* block, /* in: block containing the
3044
record from which inherited;
3045
does NOT reset the locks on
3047
ulint heir_heap_no, /* in: heap_no of the
3048
inheriting record */
3049
ulint heap_no) /* in: heap_no of the
3052
mutex_enter(&kernel_mutex);
3054
lock_rec_reset_and_release_wait(heir_block, heir_heap_no);
3056
lock_rec_inherit_to_gap(heir_block, block, heir_heap_no, heap_no);
3058
mutex_exit(&kernel_mutex);
3061
/*****************************************************************
3062
Updates the lock table when a page is discarded. */
3065
lock_update_discard(
3066
/*================*/
3067
const buf_block_t* heir_block, /* in: index page
3068
which will inherit the locks */
3069
ulint heir_heap_no, /* in: heap_no of the record
3070
which will inherit the locks */
3071
const buf_block_t* block) /* in: index page
3072
which will be discarded */
3074
const page_t* page = block->frame;
3078
lock_mutex_enter_kernel();
3080
if (!lock_rec_get_first_on_page(block)) {
3081
/* No locks exist on page, nothing to do */
3083
lock_mutex_exit_kernel();
3088
/* Inherit all the locks on the page to the record and reset all
3089
the locks on the page */
3091
if (page_is_comp(page)) {
3092
rec = page + PAGE_NEW_INFIMUM;
3095
heap_no = rec_get_heap_no_new(rec);
3097
lock_rec_inherit_to_gap(heir_block, block,
3098
heir_heap_no, heap_no);
3100
lock_rec_reset_and_release_wait(block, heap_no);
3102
rec = page + rec_get_next_offs(rec, TRUE);
3103
} while (heap_no != PAGE_HEAP_NO_SUPREMUM);
3105
rec = page + PAGE_OLD_INFIMUM;
3108
heap_no = rec_get_heap_no_old(rec);
3110
lock_rec_inherit_to_gap(heir_block, block,
3111
heir_heap_no, heap_no);
3113
lock_rec_reset_and_release_wait(block, heap_no);
3115
rec = page + rec_get_next_offs(rec, FALSE);
3116
} while (heap_no != PAGE_HEAP_NO_SUPREMUM);
3119
lock_rec_free_all_from_discard_page(block);
3121
lock_mutex_exit_kernel();
3124
/*****************************************************************
3125
Updates the lock table when a new user record is inserted. */
3130
const buf_block_t* block, /* in: buffer block containing rec */
3131
const rec_t* rec) /* in: the inserted record */
3133
ulint receiver_heap_no;
3134
ulint donator_heap_no;
3136
ut_ad(block->frame == page_align(rec));
3138
/* Inherit the gap-locking locks for rec, in gap mode, from the next
3141
if (page_rec_is_comp(rec)) {
3142
receiver_heap_no = rec_get_heap_no_new(rec);
3143
donator_heap_no = rec_get_heap_no_new(
3144
page_rec_get_next_low(rec, TRUE));
3146
receiver_heap_no = rec_get_heap_no_old(rec);
3147
donator_heap_no = rec_get_heap_no_old(
3148
page_rec_get_next_low(rec, FALSE));
3151
lock_mutex_enter_kernel();
3152
lock_rec_inherit_to_gap_if_gap_lock(block,
3153
receiver_heap_no, donator_heap_no);
3154
lock_mutex_exit_kernel();
3157
/*****************************************************************
3158
Updates the lock table when a record is removed. */
3163
const buf_block_t* block, /* in: buffer block containing rec */
3164
const rec_t* rec) /* in: the record to be removed */
3166
const page_t* page = block->frame;
3170
ut_ad(page == page_align(rec));
3172
if (page_is_comp(page)) {
3173
heap_no = rec_get_heap_no_new(rec);
3174
next_heap_no = rec_get_heap_no_new(page
3175
+ rec_get_next_offs(rec,
3178
heap_no = rec_get_heap_no_old(rec);
3179
next_heap_no = rec_get_heap_no_old(page
3180
+ rec_get_next_offs(rec,
3184
lock_mutex_enter_kernel();
3186
/* Let the next record inherit the locks from rec, in gap mode */
3188
lock_rec_inherit_to_gap(block, block, next_heap_no, heap_no);
3190
/* Reset the lock bits on rec and release waiting transactions */
3192
lock_rec_reset_and_release_wait(block, heap_no);
3194
lock_mutex_exit_kernel();
3197
/*************************************************************************
3198
Stores on the page infimum record the explicit locks of another record.
3199
This function is used to store the lock state of a record when it is
3200
updated and the size of the record changes in the update. The record
3201
is moved in such an update, perhaps to another page. The infimum record
3202
acts as a dummy carrier record, taking care of lock releases while the
3203
actual record is being moved. */
3206
lock_rec_store_on_page_infimum(
3207
/*===========================*/
3208
const buf_block_t* block, /* in: buffer block containing rec */
3209
const rec_t* rec) /* in: record whose lock state
3210
is stored on the infimum
3211
record of the same page; lock
3212
bits are reset on the
3215
ulint heap_no = page_rec_get_heap_no(rec);
3217
ut_ad(block->frame == page_align(rec));
3219
lock_mutex_enter_kernel();
3221
lock_rec_move(block, block, PAGE_HEAP_NO_INFIMUM, heap_no);
3223
lock_mutex_exit_kernel();
3226
/*************************************************************************
3227
Restores the state of explicit lock requests on a single record, where the
3228
state was stored on the infimum of the page. */
3231
lock_rec_restore_from_page_infimum(
3232
/*===============================*/
3233
const buf_block_t* block, /* in: buffer block containing rec */
3234
const rec_t* rec, /* in: record whose lock state
3236
const buf_block_t* donator)/* in: page (rec is not
3237
necessarily on this page)
3238
whose infimum stored the lock
3239
state; lock bits are reset on
3242
ulint heap_no = page_rec_get_heap_no(rec);
3244
lock_mutex_enter_kernel();
3246
lock_rec_move(block, donator, heap_no, PAGE_HEAP_NO_INFIMUM);
3248
lock_mutex_exit_kernel();
3251
/*=========== DEADLOCK CHECKING ======================================*/
3253
/************************************************************************
3254
Checks if a lock request results in a deadlock. */
3257
lock_deadlock_occurs(
3258
/*=================*/
3259
/* out: TRUE if a deadlock was detected and we
3260
chose trx as a victim; FALSE if no deadlock, or
3261
there was a deadlock, but we chose other
3262
transaction(s) as victim(s) */
3263
lock_t* lock, /* in: lock the transaction is requesting */
3264
trx_t* trx) /* in: transaction */
3266
dict_table_t* table;
3267
dict_index_t* index;
3274
ut_ad(mutex_own(&kernel_mutex));
3276
/* We check that adding this trx to the waits-for graph
3277
does not produce a cycle. First mark all active transactions
3280
mark_trx = UT_LIST_GET_FIRST(trx_sys->trx_list);
3283
mark_trx->deadlock_mark = 0;
3284
mark_trx = UT_LIST_GET_NEXT(trx_list, mark_trx);
3287
ret = lock_deadlock_recursive(trx, trx, lock, &cost, 0);
3289
if (ret == LOCK_VICTIM_IS_OTHER) {
3290
/* We chose some other trx as a victim: retry if there still
3296
if (UNIV_UNLIKELY(ret == LOCK_VICTIM_IS_START)) {
3297
if (lock_get_type_low(lock) & LOCK_TABLE) {
3298
table = lock->un_member.tab_lock.table;
3301
index = lock->index;
3302
table = index->table;
3305
lock_deadlock_found = TRUE;
3307
fputs("*** WE ROLL BACK TRANSACTION (2)\n",
3308
lock_latest_err_file);
3316
/************************************************************************
3317
Looks recursively for a deadlock. */
3320
lock_deadlock_recursive(
3321
/*====================*/
3322
/* out: 0 if no deadlock found,
3323
LOCK_VICTIM_IS_START if there was a deadlock
3324
and we chose 'start' as the victim,
3325
LOCK_VICTIM_IS_OTHER if a deadlock
3326
was found and we chose some other trx as a
3327
victim: we must do the search again in this
3328
last case because there may be another
3330
trx_t* start, /* in: recursion starting point */
3331
trx_t* trx, /* in: a transaction waiting for a lock */
3332
lock_t* wait_lock, /* in: the lock trx is waiting to be granted */
3333
ulint* cost, /* in/out: number of calculation steps thus
3334
far: if this exceeds LOCK_MAX_N_STEPS_...
3335
we return LOCK_VICTIM_IS_START */
3336
ulint depth) /* in: recursion depth: if this exceeds
3337
LOCK_MAX_DEPTH_IN_DEADLOCK_CHECK, we
3338
return LOCK_VICTIM_IS_START */
3341
ulint bit_no = ULINT_UNDEFINED;
3348
ut_ad(mutex_own(&kernel_mutex));
3350
if (trx->deadlock_mark == 1) {
3351
/* We have already exhaustively searched the subtree starting
3361
if (lock_get_type_low(wait_lock) == LOCK_REC) {
3363
bit_no = lock_rec_find_set_bit(wait_lock);
3365
ut_a(bit_no != ULINT_UNDEFINED);
3368
/* Look at the locks ahead of wait_lock in the lock queue */
3371
if (lock_get_type_low(lock) & LOCK_TABLE) {
3373
lock = UT_LIST_GET_PREV(un_member.tab_lock.locks,
3376
ut_ad(lock_get_type_low(lock) == LOCK_REC);
3377
ut_a(bit_no != ULINT_UNDEFINED);
3379
lock = (lock_t*) lock_rec_get_prev(lock, bit_no);
3383
/* We can mark this subtree as searched */
3384
trx->deadlock_mark = 1;
3389
if (lock_has_to_wait(wait_lock, lock)) {
3392
= depth > LOCK_MAX_DEPTH_IN_DEADLOCK_CHECK
3393
|| *cost > LOCK_MAX_N_STEPS_IN_DEADLOCK_CHECK;
3395
lock_trx = lock->trx;
3397
if (lock_trx == start || too_far) {
3399
/* We came back to the recursion starting
3400
point: a deadlock detected; or we have
3401
searched the waits-for graph too long */
3403
FILE* ef = lock_latest_err_file;
3406
ut_print_timestamp(ef);
3408
fputs("\n*** (1) TRANSACTION:\n", ef);
3410
trx_print(ef, wait_lock->trx, 3000);
3412
fputs("*** (1) WAITING FOR THIS LOCK"
3413
" TO BE GRANTED:\n", ef);
3415
if (lock_get_type_low(wait_lock) == LOCK_REC) {
3416
lock_rec_print(ef, wait_lock);
3418
lock_table_print(ef, wait_lock);
3421
fputs("*** (2) TRANSACTION:\n", ef);
3423
trx_print(ef, lock->trx, 3000);
3425
fputs("*** (2) HOLDS THE LOCK(S):\n", ef);
3427
if (lock_get_type_low(lock) == LOCK_REC) {
3428
lock_rec_print(ef, lock);
3430
lock_table_print(ef, lock);
3433
fputs("*** (2) WAITING FOR THIS LOCK"
3434
" TO BE GRANTED:\n", ef);
3436
if (lock_get_type_low(start->wait_lock)
3438
lock_rec_print(ef, start->wait_lock);
3440
lock_table_print(ef, start->wait_lock);
3443
if (lock_print_waits) {
3444
fputs("Deadlock detected"
3445
" or too long search\n",
3448
#endif /* UNIV_DEBUG */
3451
fputs("TOO DEEP OR LONG SEARCH"
3452
" IN THE LOCK TABLE"
3453
" WAITS-FOR GRAPH\n", ef);
3455
return(LOCK_VICTIM_IS_START);
3458
if (trx_weight_cmp(wait_lock->trx,
3460
/* Our recursion starting point
3461
transaction is 'smaller', let us
3462
choose 'start' as the victim and roll
3465
return(LOCK_VICTIM_IS_START);
3468
lock_deadlock_found = TRUE;
3470
/* Let us choose the transaction of wait_lock
3471
as a victim to try to avoid deadlocking our
3472
recursion starting point transaction */
3474
fputs("*** WE ROLL BACK TRANSACTION (1)\n",
3477
wait_lock->trx->was_chosen_as_deadlock_victim
3480
lock_cancel_waiting_and_release(wait_lock);
3482
/* Since trx and wait_lock are no longer
3483
in the waits-for graph, we can return FALSE;
3484
note that our selective algorithm can choose
3485
several transactions as victims, but still
3486
we may end up rolling back also the recursion
3487
starting point transaction! */
3489
return(LOCK_VICTIM_IS_OTHER);
3492
if (lock_trx->que_state == TRX_QUE_LOCK_WAIT) {
3494
/* Another trx ahead has requested lock in an
3495
incompatible mode, and is itself waiting for
3498
ret = lock_deadlock_recursive(
3500
lock_trx->wait_lock, cost, depth + 1);
3507
}/* end of the 'for (;;)'-loop */
3510
/*========================= TABLE LOCKS ==============================*/
3512
/*************************************************************************
3513
Creates a table lock object and adds it as the last in the lock queue
3514
of the table. Does NOT check for deadlocks or lock compatibility. */
3519
/* out, own: new lock object */
3520
dict_table_t* table, /* in: database table in dictionary cache */
3521
ulint type_mode,/* in: lock mode possibly ORed with
3523
trx_t* trx) /* in: trx */
3527
ut_ad(table && trx);
3528
ut_ad(mutex_own(&kernel_mutex));
3530
if ((type_mode & LOCK_MODE_MASK) == LOCK_AUTO_INC) {
3531
++table->n_waiting_or_granted_auto_inc_locks;
3534
if (type_mode == LOCK_AUTO_INC) {
3535
/* Only one trx can have the lock on the table
3536
at a time: we may use the memory preallocated
3537
to the table object */
3539
lock = table->auto_inc_lock;
3541
ut_a(trx->auto_inc_lock == NULL);
3542
trx->auto_inc_lock = lock;
3544
lock = mem_heap_alloc(trx->lock_heap, sizeof(lock_t));
3547
UT_LIST_ADD_LAST(trx_locks, trx->trx_locks, lock);
3549
lock->type_mode = type_mode | LOCK_TABLE;
3552
lock->un_member.tab_lock.table = table;
3554
UT_LIST_ADD_LAST(un_member.tab_lock.locks, table->locks, lock);
3556
if (UNIV_UNLIKELY(type_mode & LOCK_WAIT)) {
3558
lock_set_lock_and_trx_wait(lock, trx);
3564
/*****************************************************************
3565
Removes a table lock request from the queue and the trx list of locks;
3566
this is a low-level function which does NOT check if waiting requests
3567
can now be granted. */
3570
lock_table_remove_low(
3571
/*==================*/
3572
lock_t* lock) /* in: table lock */
3574
dict_table_t* table;
3577
ut_ad(mutex_own(&kernel_mutex));
3579
table = lock->un_member.tab_lock.table;
3582
if (lock == trx->auto_inc_lock) {
3583
trx->auto_inc_lock = NULL;
3585
ut_a(table->n_waiting_or_granted_auto_inc_locks > 0);
3586
--table->n_waiting_or_granted_auto_inc_locks;
3589
UT_LIST_REMOVE(trx_locks, trx->trx_locks, lock);
3590
UT_LIST_REMOVE(un_member.tab_lock.locks, table->locks, lock);
3593
/*************************************************************************
3594
Enqueues a waiting request for a table lock which cannot be granted
3595
immediately. Checks for deadlocks. */
3598
lock_table_enqueue_waiting(
3599
/*=======================*/
3600
/* out: DB_LOCK_WAIT, DB_DEADLOCK, or
3601
DB_QUE_THR_SUSPENDED, or DB_SUCCESS;
3602
DB_SUCCESS means that there was a deadlock,
3603
but another transaction was chosen as a
3604
victim, and we got the lock immediately:
3605
no need to wait then */
3606
ulint mode, /* in: lock mode this transaction is
3608
dict_table_t* table, /* in: table */
3609
que_thr_t* thr) /* in: query thread */
3614
ut_ad(mutex_own(&kernel_mutex));
3616
/* Test if there already is some other reason to suspend thread:
3617
we do not enqueue a lock request if the query thread should be
3620
if (que_thr_stop(thr)) {
3623
return(DB_QUE_THR_SUSPENDED);
3626
trx = thr_get_trx(thr);
3628
switch (trx_get_dict_operation(trx)) {
3629
case TRX_DICT_OP_NONE:
3631
case TRX_DICT_OP_TABLE:
3632
case TRX_DICT_OP_INDEX:
3633
ut_print_timestamp(stderr);
3634
fputs(" InnoDB: Error: a table lock wait happens"
3635
" in a dictionary operation!\n"
3636
"InnoDB: Table name ", stderr);
3637
ut_print_name(stderr, trx, TRUE, table->name);
3639
"InnoDB: Submit a detailed bug report"
3640
" to http://bugs.mysql.com\n",
3644
/* Enqueue the lock request that will wait to be granted */
3646
lock = lock_table_create(table, mode | LOCK_WAIT, trx);
3648
/* Check if a deadlock occurs: if yes, remove the lock request and
3649
return an error code */
3651
if (lock_deadlock_occurs(lock, trx)) {
3653
lock_reset_lock_and_trx_wait(lock);
3654
lock_table_remove_low(lock);
3656
return(DB_DEADLOCK);
3659
if (trx->wait_lock == NULL) {
3660
/* Deadlock resolution chose another transaction as a victim,
3661
and we accidentally got our lock granted! */
3666
trx->que_state = TRX_QUE_LOCK_WAIT;
3667
trx->was_chosen_as_deadlock_victim = FALSE;
3668
trx->wait_started = time(NULL);
3670
ut_a(que_thr_stop(thr));
3672
return(DB_LOCK_WAIT);
3675
/*************************************************************************
3676
Checks if other transactions have an incompatible mode lock request in
3680
lock_table_other_has_incompatible(
3681
/*==============================*/
3682
trx_t* trx, /* in: transaction, or NULL if all
3683
transactions should be included */
3684
ulint wait, /* in: LOCK_WAIT if also waiting locks are
3685
taken into account, or 0 if not */
3686
dict_table_t* table, /* in: table */
3687
enum lock_mode mode) /* in: lock mode */
3691
ut_ad(mutex_own(&kernel_mutex));
3693
lock = UT_LIST_GET_LAST(table->locks);
3695
while (lock != NULL) {
3697
if ((lock->trx != trx)
3698
&& (!lock_mode_compatible(lock_get_mode(lock), mode))
3699
&& (wait || !(lock_get_wait(lock)))) {
3704
lock = UT_LIST_GET_PREV(un_member.tab_lock.locks, lock);
3710
/*************************************************************************
3711
Locks the specified database table in the mode given. If the lock cannot
3712
be granted immediately, the query thread is put to wait. */
3717
/* out: DB_SUCCESS, DB_LOCK_WAIT,
3718
DB_DEADLOCK, or DB_QUE_THR_SUSPENDED */
3719
ulint flags, /* in: if BTR_NO_LOCKING_FLAG bit is set,
3721
dict_table_t* table, /* in: database table in dictionary cache */
3722
enum lock_mode mode, /* in: lock mode */
3723
que_thr_t* thr) /* in: query thread */
3728
ut_ad(table && thr);
3730
if (flags & BTR_NO_LOCKING_FLAG) {
3737
trx = thr_get_trx(thr);
3739
lock_mutex_enter_kernel();
3741
/* Look for stronger locks the same trx already has on the table */
3743
if (lock_table_has(trx, table, mode)) {
3745
lock_mutex_exit_kernel();
3750
/* We have to check if the new lock is compatible with any locks
3751
other transactions have in the table lock queue. */
3753
if (lock_table_other_has_incompatible(trx, LOCK_WAIT, table, mode)) {
3755
/* Another trx has a request on the table in an incompatible
3756
mode: this trx may have to wait */
3758
err = lock_table_enqueue_waiting(mode | flags, table, thr);
3760
lock_mutex_exit_kernel();
3765
lock_table_create(table, mode | flags, trx);
3767
ut_a(!flags || mode == LOCK_S || mode == LOCK_X);
3769
lock_mutex_exit_kernel();
3774
/*************************************************************************
3775
Checks if there are any locks set on the table. */
3780
/* out: TRUE if there are lock(s) */
3781
dict_table_t* table) /* in: database table in dictionary cache */
3787
lock_mutex_enter_kernel();
3789
if (UT_LIST_GET_LAST(table->locks)) {
3795
lock_mutex_exit_kernel();
3800
/*************************************************************************
3801
Checks if a waiting table lock request still has to wait in a queue. */
3804
lock_table_has_to_wait_in_queue(
3805
/*============================*/
3806
/* out: TRUE if still has to wait */
3807
lock_t* wait_lock) /* in: waiting table lock */
3809
dict_table_t* table;
3812
ut_ad(lock_get_wait(wait_lock));
3814
table = wait_lock->un_member.tab_lock.table;
3816
lock = UT_LIST_GET_FIRST(table->locks);
3818
while (lock != wait_lock) {
3820
if (lock_has_to_wait(wait_lock, lock)) {
3825
lock = UT_LIST_GET_NEXT(un_member.tab_lock.locks, lock);
3831
/*****************************************************************
3832
Removes a table lock request, waiting or granted, from the queue and grants
3833
locks to other transactions in the queue, if they now are entitled to a
3839
lock_t* in_lock)/* in: table lock object; transactions waiting
3840
behind will get their lock requests granted, if
3841
they are now qualified to it */
3845
ut_ad(mutex_own(&kernel_mutex));
3846
ut_a(lock_get_type_low(in_lock) == LOCK_TABLE);
3848
lock = UT_LIST_GET_NEXT(un_member.tab_lock.locks, in_lock);
3850
lock_table_remove_low(in_lock);
3852
/* Check if waiting locks in the queue can now be granted: grant
3853
locks if there are no conflicting locks ahead. */
3855
while (lock != NULL) {
3857
if (lock_get_wait(lock)
3858
&& !lock_table_has_to_wait_in_queue(lock)) {
3860
/* Grant the lock */
3864
lock = UT_LIST_GET_NEXT(un_member.tab_lock.locks, lock);
3868
/*=========================== LOCK RELEASE ==============================*/
3870
/*****************************************************************
3871
Removes a granted record lock of a transaction from the queue and grants
3872
locks to other transactions waiting in the queue if they now are entitled
3878
trx_t* trx, /* in: transaction that has
3879
set a record lock */
3880
const buf_block_t* block, /* in: buffer block containing rec */
3881
const rec_t* rec, /* in: record */
3882
enum lock_mode lock_mode)/* in: LOCK_S or LOCK_X */
3885
lock_t* release_lock = NULL;
3889
ut_ad(block->frame == page_align(rec));
3891
heap_no = page_rec_get_heap_no(rec);
3893
mutex_enter(&kernel_mutex);
3895
lock = lock_rec_get_first(block, heap_no);
3897
/* Find the last lock with the same lock_mode and transaction
3900
while (lock != NULL) {
3901
if (lock->trx == trx && lock_get_mode(lock) == lock_mode) {
3902
release_lock = lock;
3903
ut_a(!lock_get_wait(lock));
3906
lock = lock_rec_get_next(heap_no, lock);
3909
/* If a record lock is found, release the record lock */
3911
if (UNIV_LIKELY(release_lock != NULL)) {
3912
lock_rec_reset_nth_bit(release_lock, heap_no);
3914
mutex_exit(&kernel_mutex);
3915
ut_print_timestamp(stderr);
3917
" InnoDB: Error: unlock row could not"
3918
" find a %lu mode lock on the record\n",
3924
/* Check if we can now grant waiting lock requests */
3926
lock = lock_rec_get_first(block, heap_no);
3928
while (lock != NULL) {
3929
if (lock_get_wait(lock)
3930
&& !lock_rec_has_to_wait_in_queue(lock)) {
3932
/* Grant the lock */
3936
lock = lock_rec_get_next(heap_no, lock);
3939
mutex_exit(&kernel_mutex);
3942
/*************************************************************************
3943
Releases a table lock.
3944
Releases possible other transactions waiting for this lock. */
3949
lock_t* lock) /* in: lock */
3951
mutex_enter(&kernel_mutex);
3953
lock_table_dequeue(lock);
3955
mutex_exit(&kernel_mutex);
3958
/*************************************************************************
3959
Releases an auto-inc lock a transaction possibly has on a table.
3960
Releases possible other transactions waiting for this lock. */
3963
lock_table_unlock_auto_inc(
3964
/*=======================*/
3965
trx_t* trx) /* in: transaction */
3967
if (trx->auto_inc_lock) {
3968
mutex_enter(&kernel_mutex);
3970
lock_table_dequeue(trx->auto_inc_lock);
3972
mutex_exit(&kernel_mutex);
3976
/*************************************************************************
3977
Releases transaction locks, and releases possible other transactions waiting
3978
because of these locks. */
3981
lock_release_off_kernel(
3982
/*====================*/
3983
trx_t* trx) /* in: transaction */
3985
dict_table_t* table;
3989
ut_ad(mutex_own(&kernel_mutex));
3991
lock = UT_LIST_GET_LAST(trx->trx_locks);
3995
while (lock != NULL) {
3999
if (lock_get_type_low(lock) == LOCK_REC) {
4001
lock_rec_dequeue_from_page(lock);
4003
ut_ad(lock_get_type_low(lock) & LOCK_TABLE);
4005
if (lock_get_mode(lock) != LOCK_IS
4006
&& !ut_dulint_is_zero(trx->undo_no)) {
4008
/* The trx may have modified the table. We
4009
block the use of the MySQL query cache for
4010
all currently active transactions. */
4012
table = lock->un_member.tab_lock.table;
4014
table->query_cache_inv_trx_id
4015
= trx_sys->max_trx_id;
4018
lock_table_dequeue(lock);
4021
if (count == LOCK_RELEASE_KERNEL_INTERVAL) {
4022
/* Release the kernel mutex for a while, so that we
4023
do not monopolize it */
4025
lock_mutex_exit_kernel();
4027
lock_mutex_enter_kernel();
4032
lock = UT_LIST_GET_LAST(trx->trx_locks);
4035
mem_heap_empty(trx->lock_heap);
4037
ut_a(trx->auto_inc_lock == NULL);
4040
/*************************************************************************
4041
Cancels a waiting lock request and releases possible other transactions
4042
waiting behind it. */
4045
lock_cancel_waiting_and_release(
4046
/*============================*/
4047
lock_t* lock) /* in: waiting lock request */
4049
ut_ad(mutex_own(&kernel_mutex));
4051
if (lock_get_type_low(lock) == LOCK_REC) {
4053
lock_rec_dequeue_from_page(lock);
4055
ut_ad(lock_get_type_low(lock) & LOCK_TABLE);
4057
lock_table_dequeue(lock);
4060
/* Reset the wait flag and the back pointer to lock in trx */
4062
lock_reset_lock_and_trx_wait(lock);
4064
/* The following function releases the trx from lock wait */
4066
trx_end_lock_wait(lock->trx);
4069
/*************************************************************************
4070
Resets all record and table locks of a transaction on a table to be dropped.
4071
No lock is allowed to be a wait lock. */
4074
lock_reset_all_on_table_for_trx(
4075
/*============================*/
4076
dict_table_t* table, /* in: table to be dropped */
4077
trx_t* trx) /* in: a transaction */
4082
ut_ad(mutex_own(&kernel_mutex));
4084
lock = UT_LIST_GET_LAST(trx->trx_locks);
4086
while (lock != NULL) {
4087
prev_lock = UT_LIST_GET_PREV(trx_locks, lock);
4089
if (lock_get_type_low(lock) == LOCK_REC
4090
&& lock->index->table == table) {
4091
ut_a(!lock_get_wait(lock));
4093
lock_rec_discard(lock);
4094
} else if (lock_get_type_low(lock) & LOCK_TABLE
4095
&& lock->un_member.tab_lock.table == table) {
4097
ut_a(!lock_get_wait(lock));
4099
lock_table_remove_low(lock);
4106
/*************************************************************************
4107
Resets all locks, both table and record locks, on a table to be dropped.
4108
No lock is allowed to be a wait lock. */
4111
lock_reset_all_on_table(
4112
/*====================*/
4113
dict_table_t* table) /* in: table to be dropped */
4117
mutex_enter(&kernel_mutex);
4119
lock = UT_LIST_GET_FIRST(table->locks);
4122
ut_a(!lock_get_wait(lock));
4124
lock_reset_all_on_table_for_trx(table, lock->trx);
4126
lock = UT_LIST_GET_FIRST(table->locks);
4129
mutex_exit(&kernel_mutex);
4132
/*===================== VALIDATION AND DEBUGGING ====================*/
4134
/*************************************************************************
4135
Prints info of a table lock. */
4140
FILE* file, /* in: file where to print */
4141
const lock_t* lock) /* in: table type lock */
4143
ut_ad(mutex_own(&kernel_mutex));
4144
ut_a(lock_get_type_low(lock) == LOCK_TABLE);
4146
fputs("TABLE LOCK table ", file);
4147
ut_print_name(file, lock->trx, TRUE,
4148
lock->un_member.tab_lock.table->name);
4149
fprintf(file, " trx id " TRX_ID_FMT,
4150
TRX_ID_PREP_PRINTF(lock->trx->id));
4152
if (lock_get_mode(lock) == LOCK_S) {
4153
fputs(" lock mode S", file);
4154
} else if (lock_get_mode(lock) == LOCK_X) {
4155
fputs(" lock mode X", file);
4156
} else if (lock_get_mode(lock) == LOCK_IS) {
4157
fputs(" lock mode IS", file);
4158
} else if (lock_get_mode(lock) == LOCK_IX) {
4159
fputs(" lock mode IX", file);
4160
} else if (lock_get_mode(lock) == LOCK_AUTO_INC) {
4161
fputs(" lock mode AUTO-INC", file);
4163
fprintf(file, " unknown lock mode %lu",
4164
(ulong) lock_get_mode(lock));
4167
if (lock_get_wait(lock)) {
4168
fputs(" waiting", file);
4174
/*************************************************************************
4175
Prints info of a record lock. */
4180
FILE* file, /* in: file where to print */
4181
const lock_t* lock) /* in: record type lock */
4183
const buf_block_t* block;
4188
mem_heap_t* heap = NULL;
4189
ulint offsets_[REC_OFFS_NORMAL_SIZE];
4190
ulint* offsets = offsets_;
4191
rec_offs_init(offsets_);
4193
ut_ad(mutex_own(&kernel_mutex));
4194
ut_a(lock_get_type_low(lock) == LOCK_REC);
4196
space = lock->un_member.rec_lock.space;
4197
page_no = lock->un_member.rec_lock.page_no;
4199
fprintf(file, "RECORD LOCKS space id %lu page no %lu n bits %lu ",
4200
(ulong) space, (ulong) page_no,
4201
(ulong) lock_rec_get_n_bits(lock));
4202
dict_index_name_print(file, lock->trx, lock->index);
4203
fprintf(file, " trx id " TRX_ID_FMT,
4204
TRX_ID_PREP_PRINTF(lock->trx->id));
4206
if (lock_get_mode(lock) == LOCK_S) {
4207
fputs(" lock mode S", file);
4208
} else if (lock_get_mode(lock) == LOCK_X) {
4209
fputs(" lock_mode X", file);
4214
if (lock_rec_get_gap(lock)) {
4215
fputs(" locks gap before rec", file);
4218
if (lock_rec_get_rec_not_gap(lock)) {
4219
fputs(" locks rec but not gap", file);
4222
if (lock_rec_get_insert_intention(lock)) {
4223
fputs(" insert intention", file);
4226
if (lock_get_wait(lock)) {
4227
fputs(" waiting", file);
4234
block = buf_page_try_get(space, page_no, &mtr);
4237
for (i = 0; i < lock_rec_get_n_bits(lock); i++) {
4239
if (lock_rec_get_nth_bit(lock, i)) {
4242
= page_find_rec_with_heap_no(
4243
buf_block_get_frame(block), i);
4244
offsets = rec_get_offsets(
4245
rec, lock->index, offsets,
4246
ULINT_UNDEFINED, &heap);
4248
fprintf(file, "Record lock, heap no %lu ",
4250
rec_print_new(file, rec, offsets);
4255
for (i = 0; i < lock_rec_get_n_bits(lock); i++) {
4256
fprintf(file, "Record lock, heap no %lu\n", (ulong) i);
4261
if (UNIV_LIKELY_NULL(heap)) {
4262
mem_heap_free(heap);
4266
#ifndef UNIV_HOTBACKUP
4267
/*************************************************************************
4268
Calculates the number of record lock structs in the record lock hash table. */
4271
lock_get_n_rec_locks(void)
4272
/*======================*/
4278
ut_ad(mutex_own(&kernel_mutex));
4280
for (i = 0; i < hash_get_n_cells(lock_sys->rec_hash); i++) {
4282
lock = HASH_GET_FIRST(lock_sys->rec_hash, i);
4287
lock = HASH_GET_NEXT(hash, lock);
4294
/*************************************************************************
4295
Prints info of locks for all transactions. */
4298
lock_print_info_summary(
4299
/*====================*/
4300
FILE* file) /* in: file where to print */
4302
/* We must protect the MySQL thd->query field with a MySQL mutex, and
4303
because the MySQL mutex must be reserved before the kernel_mutex of
4304
InnoDB, we call innobase_mysql_prepare_print_arbitrary_thd() here. */
4306
innobase_mysql_prepare_print_arbitrary_thd();
4307
lock_mutex_enter_kernel();
4309
if (lock_deadlock_found) {
4310
fputs("------------------------\n"
4311
"LATEST DETECTED DEADLOCK\n"
4312
"------------------------\n", file);
4314
ut_copy_file(file, lock_latest_err_file);
4317
fputs("------------\n"
4319
"------------\n", file);
4321
fprintf(file, "Trx id counter " TRX_ID_FMT "\n",
4322
TRX_ID_PREP_PRINTF(trx_sys->max_trx_id));
4325
"Purge done for trx's n:o < " TRX_ID_FMT
4326
" undo n:o < " TRX_ID_FMT "\n",
4327
TRX_ID_PREP_PRINTF(purge_sys->purge_trx_no),
4328
TRX_ID_PREP_PRINTF(purge_sys->purge_undo_no));
4331
"History list length %lu\n",
4332
(ulong) trx_sys->rseg_history_len);
4335
"Total number of lock structs in row lock hash table %lu\n",
4336
(ulong) lock_get_n_rec_locks());
4339
/*************************************************************************
4340
Prints info of locks for each transaction. */
4343
lock_print_info_all_transactions(
4344
/*=============================*/
4345
FILE* file) /* in: file where to print */
4348
ibool load_page_first = TRUE;
4355
fprintf(file, "LIST OF TRANSACTIONS FOR EACH SESSION:\n");
4357
/* First print info on non-active transactions */
4359
trx = UT_LIST_GET_FIRST(trx_sys->mysql_trx_list);
4362
if (trx->conc_state == TRX_NOT_STARTED) {
4364
trx_print(file, trx, 600);
4367
trx = UT_LIST_GET_NEXT(mysql_trx_list, trx);
4371
trx = UT_LIST_GET_FIRST(trx_sys->trx_list);
4375
/* Since we temporarily release the kernel mutex when
4376
reading a database page in below, variable trx may be
4377
obsolete now and we must loop through the trx list to
4378
get probably the same trx, or some other trx. */
4380
while (trx && (i < nth_trx)) {
4381
trx = UT_LIST_GET_NEXT(trx_list, trx);
4386
lock_mutex_exit_kernel();
4387
innobase_mysql_end_print_arbitrary_thd();
4389
ut_ad(lock_validate());
4394
if (nth_lock == 0) {
4396
trx_print(file, trx, 600);
4398
if (trx->read_view) {
4400
"Trx read view will not see trx with"
4401
" id >= " TRX_ID_FMT
4402
", sees < " TRX_ID_FMT "\n",
4404
trx->read_view->low_limit_id),
4406
trx->read_view->up_limit_id));
4409
if (trx->que_state == TRX_QUE_LOCK_WAIT) {
4411
"------- TRX HAS BEEN WAITING %lu SEC"
4412
" FOR THIS LOCK TO BE GRANTED:\n",
4413
(ulong) difftime(time(NULL),
4414
trx->wait_started));
4416
if (lock_get_type_low(trx->wait_lock) == LOCK_REC) {
4417
lock_rec_print(file, trx->wait_lock);
4419
lock_table_print(file, trx->wait_lock);
4422
fputs("------------------\n", file);
4426
if (!srv_print_innodb_lock_monitor) {
4433
/* Look at the note about the trx loop above why we loop here:
4434
lock may be an obsolete pointer now. */
4436
lock = UT_LIST_GET_FIRST(trx->trx_locks);
4438
while (lock && (i < nth_lock)) {
4439
lock = UT_LIST_GET_NEXT(trx_locks, lock);
4450
if (lock_get_type_low(lock) == LOCK_REC) {
4451
if (load_page_first) {
4452
ulint space = lock->un_member.rec_lock.space;
4453
ulint zip_size= fil_space_get_zip_size(space);
4454
ulint page_no = lock->un_member.rec_lock.page_no;
4456
lock_mutex_exit_kernel();
4457
innobase_mysql_end_print_arbitrary_thd();
4461
buf_page_get_with_no_latch(space, zip_size,
4466
load_page_first = FALSE;
4468
innobase_mysql_prepare_print_arbitrary_thd();
4469
lock_mutex_enter_kernel();
4474
lock_rec_print(file, lock);
4476
ut_ad(lock_get_type_low(lock) & LOCK_TABLE);
4478
lock_table_print(file, lock);
4481
load_page_first = TRUE;
4485
if (nth_lock >= 10) {
4486
fputs("10 LOCKS PRINTED FOR THIS TRX:"
4487
" SUPPRESSING FURTHER PRINTS\n",
4500
/*************************************************************************
4501
Validates the lock queue on a table. */
4504
lock_table_queue_validate(
4505
/*======================*/
4506
/* out: TRUE if ok */
4507
dict_table_t* table) /* in: table */
4511
ut_ad(mutex_own(&kernel_mutex));
4513
lock = UT_LIST_GET_FIRST(table->locks);
4516
ut_a(((lock->trx)->conc_state == TRX_ACTIVE)
4517
|| ((lock->trx)->conc_state == TRX_PREPARED)
4518
|| ((lock->trx)->conc_state == TRX_COMMITTED_IN_MEMORY));
4520
if (!lock_get_wait(lock)) {
4522
ut_a(!lock_table_other_has_incompatible(
4523
lock->trx, 0, table,
4524
lock_get_mode(lock)));
4527
ut_a(lock_table_has_to_wait_in_queue(lock));
4530
lock = UT_LIST_GET_NEXT(un_member.tab_lock.locks, lock);
4536
/*************************************************************************
4537
Validates the lock queue on a single record. */
4540
lock_rec_queue_validate(
4541
/*====================*/
4542
/* out: TRUE if ok */
4543
const buf_block_t* block, /* in: buffer block containing rec */
4544
const rec_t* rec, /* in: record to look at */
4545
dict_index_t* index, /* in: index, or NULL if not known */
4546
const ulint* offsets)/* in: rec_get_offsets(rec, index) */
4553
ut_a(block->frame == page_align(rec));
4554
ut_ad(rec_offs_validate(rec, index, offsets));
4555
ut_ad(!page_rec_is_comp(rec) == !rec_offs_comp(offsets));
4557
heap_no = page_rec_get_heap_no(rec);
4559
lock_mutex_enter_kernel();
4561
if (!page_rec_is_user_rec(rec)) {
4563
lock = lock_rec_get_first(block, heap_no);
4566
switch(lock->trx->conc_state) {
4569
case TRX_COMMITTED_IN_MEMORY:
4575
ut_a(trx_in_trx_list(lock->trx));
4577
if (lock_get_wait(lock)) {
4578
ut_a(lock_rec_has_to_wait_in_queue(lock));
4582
ut_a(lock->index == index);
4585
lock = lock_rec_get_next(heap_no, lock);
4588
lock_mutex_exit_kernel();
4594
else if (dict_index_is_clust(index)) {
4596
impl_trx = lock_clust_rec_some_has_impl(rec, index, offsets);
4599
&& lock_rec_other_has_expl_req(LOCK_S, 0, LOCK_WAIT,
4600
block, heap_no, impl_trx)) {
4602
ut_a(lock_rec_has_expl(LOCK_X | LOCK_REC_NOT_GAP,
4603
block, heap_no, impl_trx));
4607
/* The kernel mutex may get released temporarily in the
4608
next function call: we have to release lock table mutex
4609
to obey the latching order */
4611
impl_trx = lock_sec_rec_some_has_impl_off_kernel(
4612
rec, index, offsets);
4615
&& lock_rec_other_has_expl_req(LOCK_S, 0, LOCK_WAIT,
4616
block, heap_no, impl_trx)) {
4618
ut_a(lock_rec_has_expl(LOCK_X | LOCK_REC_NOT_GAP,
4619
block, heap_no, impl_trx));
4623
lock = lock_rec_get_first(block, heap_no);
4626
ut_a(lock->trx->conc_state == TRX_ACTIVE
4627
|| lock->trx->conc_state == TRX_PREPARED
4628
|| lock->trx->conc_state == TRX_COMMITTED_IN_MEMORY);
4629
ut_a(trx_in_trx_list(lock->trx));
4632
ut_a(lock->index == index);
4635
if (!lock_rec_get_gap(lock) && !lock_get_wait(lock)) {
4637
enum lock_mode mode;
4639
if (lock_get_mode(lock) == LOCK_S) {
4644
ut_a(!lock_rec_other_has_expl_req(
4645
mode, 0, 0, block, heap_no, lock->trx));
4647
} else if (lock_get_wait(lock) && !lock_rec_get_gap(lock)) {
4649
ut_a(lock_rec_has_to_wait_in_queue(lock));
4652
lock = lock_rec_get_next(heap_no, lock);
4655
lock_mutex_exit_kernel();
4660
/*************************************************************************
4661
Validates the record lock queues on a page. */
4664
lock_rec_validate_page(
4665
/*===================*/
4666
/* out: TRUE if ok */
4667
ulint space, /* in: space id */
4668
ulint page_no)/* in: page number */
4670
dict_index_t* index;
4679
mem_heap_t* heap = NULL;
4680
ulint offsets_[REC_OFFS_NORMAL_SIZE];
4681
ulint* offsets = offsets_;
4682
rec_offs_init(offsets_);
4684
ut_ad(!mutex_own(&kernel_mutex));
4688
block = buf_page_get(space, fil_space_get_zip_size(space),
4689
page_no, RW_X_LATCH, &mtr);
4690
#ifdef UNIV_SYNC_DEBUG
4691
buf_block_dbg_add_level(block, SYNC_NO_ORDER_CHECK);
4692
#endif /* UNIV_SYNC_DEBUG */
4693
page = block->frame;
4695
lock_mutex_enter_kernel();
4697
lock = lock_rec_get_first_on_page_addr(space, page_no);
4703
for (i = 0; i < nth_lock; i++) {
4705
lock = lock_rec_get_next_on_page(lock);
4712
ut_a(trx_in_trx_list(lock->trx));
4713
ut_a(lock->trx->conc_state == TRX_ACTIVE
4714
|| lock->trx->conc_state == TRX_PREPARED
4715
|| lock->trx->conc_state == TRX_COMMITTED_IN_MEMORY);
4717
for (i = nth_bit; i < lock_rec_get_n_bits(lock); i++) {
4719
if (i == 1 || lock_rec_get_nth_bit(lock, i)) {
4721
index = lock->index;
4722
rec = page_find_rec_with_heap_no(page, i);
4724
offsets = rec_get_offsets(rec, index, offsets,
4725
ULINT_UNDEFINED, &heap);
4728
"Validating %lu %lu\n",
4729
(ulong) space, (ulong) page_no);
4731
lock_mutex_exit_kernel();
4733
lock_rec_queue_validate(block, rec, index, offsets);
4735
lock_mutex_enter_kernel();
4749
lock_mutex_exit_kernel();
4753
if (UNIV_LIKELY_NULL(heap)) {
4754
mem_heap_free(heap);
4759
/*************************************************************************
4760
Validates the lock system. */
4765
/* out: TRUE if ok */
4774
lock_mutex_enter_kernel();
4776
trx = UT_LIST_GET_FIRST(trx_sys->trx_list);
4779
lock = UT_LIST_GET_FIRST(trx->trx_locks);
4782
if (lock_get_type_low(lock) & LOCK_TABLE) {
4784
lock_table_queue_validate(
4785
lock->un_member.tab_lock.table);
4788
lock = UT_LIST_GET_NEXT(trx_locks, lock);
4791
trx = UT_LIST_GET_NEXT(trx_list, trx);
4794
for (i = 0; i < hash_get_n_cells(lock_sys->rec_hash); i++) {
4796
limit = ut_dulint_zero;
4799
lock = HASH_GET_FIRST(lock_sys->rec_hash, i);
4802
ut_a(trx_in_trx_list(lock->trx));
4804
space = lock->un_member.rec_lock.space;
4805
page_no = lock->un_member.rec_lock.page_no;
4808
ut_dulint_create(space, page_no),
4813
lock = HASH_GET_NEXT(hash, lock);
4821
lock_mutex_exit_kernel();
4823
lock_rec_validate_page(space, page_no);
4825
lock_mutex_enter_kernel();
4827
limit = ut_dulint_create(space, page_no + 1);
4831
lock_mutex_exit_kernel();
4835
# endif /* UNIV_DEBUG */
4836
#endif /* !UNIV_HOTBACKUP */
4837
/*============ RECORD LOCK CHECKS FOR ROW OPERATIONS ====================*/
4839
/*************************************************************************
4840
Checks if locks of other transactions prevent an immediate insert of
4841
a record. If they do, first tests if the query thread should anyway
4842
be suspended for some reason; if not, then puts the transaction and
4843
the query thread to the lock wait state and inserts a waiting request
4844
for a gap x-lock to the lock queue. */
4847
lock_rec_insert_check_and_lock(
4848
/*===========================*/
4849
/* out: DB_SUCCESS, DB_LOCK_WAIT,
4850
DB_DEADLOCK, or DB_QUE_THR_SUSPENDED */
4851
ulint flags, /* in: if BTR_NO_LOCKING_FLAG bit is
4852
set, does nothing */
4853
rec_t* rec, /* in: record after which to insert */
4854
buf_block_t* block, /* in/out: buffer block of rec */
4855
dict_index_t* index, /* in: index */
4856
que_thr_t* thr, /* in: query thread */
4857
ibool* inherit)/* out: set to TRUE if the new
4858
inserted record maybe should inherit
4859
LOCK_GAP type locks from the successor
4862
const rec_t* next_rec;
4866
ulint next_rec_heap_no;
4868
ut_ad(block->frame == page_align(rec));
4870
if (flags & BTR_NO_LOCKING_FLAG) {
4875
trx = thr_get_trx(thr);
4876
next_rec = page_rec_get_next(rec);
4877
next_rec_heap_no = page_rec_get_heap_no(next_rec);
4879
lock_mutex_enter_kernel();
4881
/* When inserting a record into an index, the table must be at
4882
least IX-locked or we must be building an index, in which case
4883
the table must be at least S-locked. */
4884
ut_ad(lock_table_has(trx, index->table, LOCK_IX)
4885
|| (*index->name == TEMP_INDEX_PREFIX
4886
&& lock_table_has(trx, index->table, LOCK_S)));
4888
lock = lock_rec_get_first(block, next_rec_heap_no);
4890
if (UNIV_LIKELY(lock == NULL)) {
4891
/* We optimize CPU time usage in the simplest case */
4893
lock_mutex_exit_kernel();
4895
if (!dict_index_is_clust(index)) {
4896
/* Update the page max trx id field */
4897
page_update_max_trx_id(block,
4898
buf_block_get_page_zip(block),
4909
/* If another transaction has an explicit lock request which locks
4910
the gap, waiting or granted, on the successor, the insert has to wait.
4912
An exception is the case where the lock by the another transaction
4913
is a gap type lock which it placed to wait for its turn to insert. We
4914
do not consider that kind of a lock conflicting with our insert. This
4915
eliminates an unnecessary deadlock which resulted when 2 transactions
4916
had to wait for their insert. Both had waiting gap type lock requests
4917
on the successor, which produced an unnecessary deadlock. */
4919
if (lock_rec_other_has_conflicting(
4920
LOCK_X | LOCK_GAP | LOCK_INSERT_INTENTION,
4921
block, next_rec_heap_no, trx)) {
4923
/* Note that we may get DB_SUCCESS also here! */
4924
err = lock_rec_enqueue_waiting(LOCK_X | LOCK_GAP
4925
| LOCK_INSERT_INTENTION,
4926
block, next_rec_heap_no,
4932
lock_mutex_exit_kernel();
4934
if ((err == DB_SUCCESS) && !dict_index_is_clust(index)) {
4935
/* Update the page max trx id field */
4936
page_update_max_trx_id(block,
4937
buf_block_get_page_zip(block),
4943
mem_heap_t* heap = NULL;
4944
ulint offsets_[REC_OFFS_NORMAL_SIZE];
4945
const ulint* offsets;
4946
rec_offs_init(offsets_);
4948
offsets = rec_get_offsets(next_rec, index, offsets_,
4949
ULINT_UNDEFINED, &heap);
4950
ut_ad(lock_rec_queue_validate(block,
4951
next_rec, index, offsets));
4952
if (UNIV_LIKELY_NULL(heap)) {
4953
mem_heap_free(heap);
4956
#endif /* UNIV_DEBUG */
4961
/*************************************************************************
4962
If a transaction has an implicit x-lock on a record, but no explicit x-lock
4963
set on the record, sets one for it. NOTE that in the case of a secondary
4964
index, the kernel mutex may get temporarily released. */
4967
lock_rec_convert_impl_to_expl(
4968
/*==========================*/
4969
const buf_block_t* block, /* in: buffer block of rec */
4970
const rec_t* rec, /* in: user record on page */
4971
dict_index_t* index, /* in: index of record */
4972
const ulint* offsets)/* in: rec_get_offsets(rec, index) */
4976
ut_ad(mutex_own(&kernel_mutex));
4977
ut_ad(page_rec_is_user_rec(rec));
4978
ut_ad(rec_offs_validate(rec, index, offsets));
4979
ut_ad(!page_rec_is_comp(rec) == !rec_offs_comp(offsets));
4981
if (dict_index_is_clust(index)) {
4982
impl_trx = lock_clust_rec_some_has_impl(rec, index, offsets);
4984
impl_trx = lock_sec_rec_some_has_impl_off_kernel(
4985
rec, index, offsets);
4989
ulint heap_no = page_rec_get_heap_no(rec);
4991
/* If the transaction has no explicit x-lock set on the
4992
record, set one for it */
4994
if (!lock_rec_has_expl(LOCK_X | LOCK_REC_NOT_GAP, block,
4995
heap_no, impl_trx)) {
4997
lock_rec_add_to_queue(
4998
LOCK_REC | LOCK_X | LOCK_REC_NOT_GAP,
4999
block, heap_no, index, impl_trx);
5004
/*************************************************************************
5005
Checks if locks of other transactions prevent an immediate modify (update,
5006
delete mark, or delete unmark) of a clustered index record. If they do,
5007
first tests if the query thread should anyway be suspended for some
5008
reason; if not, then puts the transaction and the query thread to the
5009
lock wait state and inserts a waiting request for a record x-lock to the
5013
lock_clust_rec_modify_check_and_lock(
5014
/*=================================*/
5016
DB_LOCK_WAIT, DB_DEADLOCK, or
5017
DB_QUE_THR_SUSPENDED */
5018
ulint flags, /* in: if BTR_NO_LOCKING_FLAG
5019
bit is set, does nothing */
5020
const buf_block_t* block, /* in: buffer block of rec */
5021
const rec_t* rec, /* in: record which should be
5023
dict_index_t* index, /* in: clustered index */
5024
const ulint* offsets,/* in: rec_get_offsets(rec, index) */
5025
que_thr_t* thr) /* in: query thread */
5030
ut_ad(rec_offs_validate(rec, index, offsets));
5031
ut_ad(dict_index_is_clust(index));
5032
ut_ad(block->frame == page_align(rec));
5034
if (flags & BTR_NO_LOCKING_FLAG) {
5039
heap_no = rec_offs_comp(offsets)
5040
? rec_get_heap_no_new(rec)
5041
: rec_get_heap_no_old(rec);
5043
lock_mutex_enter_kernel();
5045
ut_ad(lock_table_has(thr_get_trx(thr), index->table, LOCK_IX));
5047
/* If a transaction has no explicit x-lock set on the record, set one
5050
lock_rec_convert_impl_to_expl(block, rec, index, offsets);
5052
err = lock_rec_lock(TRUE, LOCK_X | LOCK_REC_NOT_GAP,
5053
block, heap_no, index, thr);
5055
lock_mutex_exit_kernel();
5057
ut_ad(lock_rec_queue_validate(block, rec, index, offsets));
5062
/*************************************************************************
5063
Checks if locks of other transactions prevent an immediate modify (delete
5064
mark or delete unmark) of a secondary index record. */
5067
lock_sec_rec_modify_check_and_lock(
5068
/*===============================*/
5069
/* out: DB_SUCCESS, DB_LOCK_WAIT,
5070
DB_DEADLOCK, or DB_QUE_THR_SUSPENDED */
5071
ulint flags, /* in: if BTR_NO_LOCKING_FLAG
5072
bit is set, does nothing */
5073
buf_block_t* block, /* in/out: buffer block of rec */
5074
rec_t* rec, /* in: record which should be
5075
modified; NOTE: as this is a secondary
5076
index, we always have to modify the
5077
clustered index record first: see the
5079
dict_index_t* index, /* in: secondary index */
5080
que_thr_t* thr) /* in: query thread */
5085
ut_ad(!dict_index_is_clust(index));
5086
ut_ad(block->frame == page_align(rec));
5088
if (flags & BTR_NO_LOCKING_FLAG) {
5093
heap_no = page_rec_get_heap_no(rec);
5095
/* Another transaction cannot have an implicit lock on the record,
5096
because when we come here, we already have modified the clustered
5097
index record, and this would not have been possible if another active
5098
transaction had modified this secondary index record. */
5100
lock_mutex_enter_kernel();
5102
ut_ad(lock_table_has(thr_get_trx(thr), index->table, LOCK_IX));
5104
err = lock_rec_lock(TRUE, LOCK_X | LOCK_REC_NOT_GAP,
5105
block, heap_no, index, thr);
5107
lock_mutex_exit_kernel();
5111
mem_heap_t* heap = NULL;
5112
ulint offsets_[REC_OFFS_NORMAL_SIZE];
5113
const ulint* offsets;
5114
rec_offs_init(offsets_);
5116
offsets = rec_get_offsets(rec, index, offsets_,
5117
ULINT_UNDEFINED, &heap);
5118
ut_ad(lock_rec_queue_validate(block, rec, index, offsets));
5119
if (UNIV_LIKELY_NULL(heap)) {
5120
mem_heap_free(heap);
5123
#endif /* UNIV_DEBUG */
5125
if (err == DB_SUCCESS) {
5126
/* Update the page max trx id field */
5127
page_update_max_trx_id(block,
5128
buf_block_get_page_zip(block),
5129
thr_get_trx(thr)->id);
5135
/*************************************************************************
5136
Like the counterpart for a clustered index below, but now we read a
5137
secondary index record. */
5140
lock_sec_rec_read_check_and_lock(
5141
/*=============================*/
5143
DB_LOCK_WAIT, DB_DEADLOCK, or
5144
DB_QUE_THR_SUSPENDED */
5145
ulint flags, /* in: if BTR_NO_LOCKING_FLAG
5146
bit is set, does nothing */
5147
const buf_block_t* block, /* in: buffer block of rec */
5148
const rec_t* rec, /* in: user record or page
5149
supremum record which should
5150
be read or passed over by a
5152
dict_index_t* index, /* in: secondary index */
5153
const ulint* offsets,/* in: rec_get_offsets(rec, index) */
5154
enum lock_mode mode, /* in: mode of the lock which
5155
the read cursor should set on
5156
records: LOCK_S or LOCK_X; the
5157
latter is possible in
5158
SELECT FOR UPDATE */
5159
ulint gap_mode,/* in: LOCK_ORDINARY, LOCK_GAP, or
5161
que_thr_t* thr) /* in: query thread */
5166
ut_ad(!dict_index_is_clust(index));
5167
ut_ad(block->frame == page_align(rec));
5168
ut_ad(page_rec_is_user_rec(rec) || page_rec_is_supremum(rec));
5169
ut_ad(rec_offs_validate(rec, index, offsets));
5170
ut_ad(mode == LOCK_X || mode == LOCK_S);
5172
if (flags & BTR_NO_LOCKING_FLAG) {
5177
heap_no = page_rec_get_heap_no(rec);
5179
lock_mutex_enter_kernel();
5181
ut_ad(mode != LOCK_X
5182
|| lock_table_has(thr_get_trx(thr), index->table, LOCK_IX));
5183
ut_ad(mode != LOCK_S
5184
|| lock_table_has(thr_get_trx(thr), index->table, LOCK_IS));
5186
/* Some transaction may have an implicit x-lock on the record only
5187
if the max trx id for the page >= min trx id for the trx list or a
5188
database recovery is running. */
5190
if (((ut_dulint_cmp(page_get_max_trx_id(block->frame),
5191
trx_list_get_min_trx_id()) >= 0)
5192
|| recv_recovery_is_on())
5193
&& !page_rec_is_supremum(rec)) {
5195
lock_rec_convert_impl_to_expl(block, rec, index, offsets);
5198
err = lock_rec_lock(FALSE, mode | gap_mode,
5199
block, heap_no, index, thr);
5201
lock_mutex_exit_kernel();
5203
ut_ad(lock_rec_queue_validate(block, rec, index, offsets));
5208
/*************************************************************************
5209
Checks if locks of other transactions prevent an immediate read, or passing
5210
over by a read cursor, of a clustered index record. If they do, first tests
5211
if the query thread should anyway be suspended for some reason; if not, then
5212
puts the transaction and the query thread to the lock wait state and inserts a
5213
waiting request for a record lock to the lock queue. Sets the requested mode
5214
lock on the record. */
5217
lock_clust_rec_read_check_and_lock(
5218
/*===============================*/
5220
DB_LOCK_WAIT, DB_DEADLOCK, or
5221
DB_QUE_THR_SUSPENDED */
5222
ulint flags, /* in: if BTR_NO_LOCKING_FLAG
5223
bit is set, does nothing */
5224
const buf_block_t* block, /* in: buffer block of rec */
5225
const rec_t* rec, /* in: user record or page
5226
supremum record which should
5227
be read or passed over by a
5229
dict_index_t* index, /* in: clustered index */
5230
const ulint* offsets,/* in: rec_get_offsets(rec, index) */
5231
enum lock_mode mode, /* in: mode of the lock which
5232
the read cursor should set on
5233
records: LOCK_S or LOCK_X; the
5234
latter is possible in
5235
SELECT FOR UPDATE */
5236
ulint gap_mode,/* in: LOCK_ORDINARY, LOCK_GAP, or
5238
que_thr_t* thr) /* in: query thread */
5243
ut_ad(dict_index_is_clust(index));
5244
ut_ad(block->frame == page_align(rec));
5245
ut_ad(page_rec_is_user_rec(rec) || page_rec_is_supremum(rec));
5246
ut_ad(gap_mode == LOCK_ORDINARY || gap_mode == LOCK_GAP
5247
|| gap_mode == LOCK_REC_NOT_GAP);
5248
ut_ad(rec_offs_validate(rec, index, offsets));
5250
if (flags & BTR_NO_LOCKING_FLAG) {
5255
heap_no = page_rec_get_heap_no(rec);
5257
lock_mutex_enter_kernel();
5259
ut_ad(mode != LOCK_X
5260
|| lock_table_has(thr_get_trx(thr), index->table, LOCK_IX));
5261
ut_ad(mode != LOCK_S
5262
|| lock_table_has(thr_get_trx(thr), index->table, LOCK_IS));
5264
if (UNIV_LIKELY(heap_no != PAGE_HEAP_NO_SUPREMUM)) {
5266
lock_rec_convert_impl_to_expl(block, rec, index, offsets);
5269
err = lock_rec_lock(FALSE, mode | gap_mode,
5270
block, heap_no, index, thr);
5272
lock_mutex_exit_kernel();
5274
ut_ad(lock_rec_queue_validate(block, rec, index, offsets));
5278
/*************************************************************************
5279
Checks if locks of other transactions prevent an immediate read, or passing
5280
over by a read cursor, of a clustered index record. If they do, first tests
5281
if the query thread should anyway be suspended for some reason; if not, then
5282
puts the transaction and the query thread to the lock wait state and inserts a
5283
waiting request for a record lock to the lock queue. Sets the requested mode
5284
lock on the record. This is an alternative version of
5285
lock_clust_rec_read_check_and_lock() that does not require the parameter
5289
lock_clust_rec_read_check_and_lock_alt(
5290
/*===================================*/
5292
DB_LOCK_WAIT, DB_DEADLOCK, or
5293
DB_QUE_THR_SUSPENDED */
5294
ulint flags, /* in: if BTR_NO_LOCKING_FLAG
5295
bit is set, does nothing */
5296
const buf_block_t* block, /* in: buffer block of rec */
5297
const rec_t* rec, /* in: user record or page
5298
supremum record which should
5299
be read or passed over by a
5301
dict_index_t* index, /* in: clustered index */
5302
enum lock_mode mode, /* in: mode of the lock which
5303
the read cursor should set on
5304
records: LOCK_S or LOCK_X; the
5305
latter is possible in
5306
SELECT FOR UPDATE */
5307
ulint gap_mode,/* in: LOCK_ORDINARY, LOCK_GAP, or
5309
que_thr_t* thr) /* in: query thread */
5311
mem_heap_t* tmp_heap = NULL;
5312
ulint offsets_[REC_OFFS_NORMAL_SIZE];
5313
ulint* offsets = offsets_;
5315
rec_offs_init(offsets_);
5317
offsets = rec_get_offsets(rec, index, offsets,
5318
ULINT_UNDEFINED, &tmp_heap);
5319
ret = lock_clust_rec_read_check_and_lock(flags, block, rec, index,
5320
offsets, mode, gap_mode, thr);
5322
mem_heap_free(tmp_heap);
5327
/***********************************************************************
5328
Gets the type of a lock. Non-inline version for using outside of the
5334
/* out: LOCK_TABLE or LOCK_REC */
5335
const lock_t* lock) /* in: lock */
5337
return(lock_get_type_low(lock));
5340
/***********************************************************************
5341
Gets the id of the transaction owning a lock. */
5346
/* out: transaction id */
5347
const lock_t* lock) /* in: lock */
5349
return(trx_get_id(lock->trx));
5352
/***********************************************************************
5353
Gets the mode of a lock in a human readable string.
5354
The string should not be free()'d or modified. */
5359
/* out: lock mode */
5360
const lock_t* lock) /* in: lock */
5364
is_gap_lock = lock_get_type_low(lock) == LOCK_REC
5365
&& lock_rec_get_gap(lock);
5367
switch (lock_get_mode(lock)) {
5399
/***********************************************************************
5400
Gets the type of a lock in a human readable string.
5401
The string should not be free()'d or modified. */
5406
/* out: lock type */
5407
const lock_t* lock) /* in: lock */
5409
switch (lock_get_type_low(lock)) {
5419
/***********************************************************************
5420
Gets the table on which the lock is. */
5426
const lock_t* lock) /* in: lock */
5428
switch (lock_get_type_low(lock)) {
5430
return(lock->index->table);
5432
return(lock->un_member.tab_lock.table);
5439
/***********************************************************************
5440
Gets the id of the table on which the lock is. */
5445
/* out: id of the table */
5446
const lock_t* lock) /* in: lock */
5448
dict_table_t* table;
5450
table = lock_get_table(lock);
5452
return((ullint)ut_conv_dulint_to_longlong(table->id));
5455
/***********************************************************************
5456
Gets the name of the table on which the lock is.
5457
The string should not be free()'d or modified. */
5460
lock_get_table_name(
5461
/*================*/
5462
/* out: name of the table */
5463
const lock_t* lock) /* in: lock */
5465
dict_table_t* table;
5467
table = lock_get_table(lock);
5469
return(table->name);
5472
/***********************************************************************
5473
For a record lock, gets the index on which the lock is. */
5479
const lock_t* lock) /* in: lock */
5481
ut_a(lock_get_type_low(lock) == LOCK_REC);
5483
return(lock->index);
5486
/***********************************************************************
5487
For a record lock, gets the name of the index on which the lock is.
5488
The string should not be free()'d or modified. */
5491
lock_rec_get_index_name(
5492
/*====================*/
5493
/* out: name of the index */
5494
const lock_t* lock) /* in: lock */
5496
ut_a(lock_get_type_low(lock) == LOCK_REC);
5498
return(lock->index->name);
5501
/***********************************************************************
5502
For a record lock, gets the tablespace number on which the lock is. */
5505
lock_rec_get_space_id(
5506
/*==================*/
5507
/* out: tablespace number */
5508
const lock_t* lock) /* in: lock */
5510
ut_a(lock_get_type_low(lock) == LOCK_REC);
5512
return(lock->un_member.rec_lock.space);
5515
/***********************************************************************
5516
For a record lock, gets the page number on which the lock is. */
5519
lock_rec_get_page_no(
5520
/*=================*/
5521
/* out: page number */
5522
const lock_t* lock) /* in: lock */
5524
ut_a(lock_get_type_low(lock) == LOCK_REC);
5526
return(lock->un_member.rec_lock.page_no);
added
removed
storage/innobase/lock/lock0lock.c
