Now we base on some unreleased state of libunwind. This is by itself not
a good practice. Yet the main motivation is that in the current version of
libunwind fast path for backtrace detection on x86_64 does not work.
I guess this is because of libunwind/libunwind@400b3f819ad4 (" x86_64: Stop
aliasing RSP and CFA"). See libunwind/libunwind#440. Fortunately this
commit is not present it the latest release.

Using fast or slow path has a great impact on performance of debug build
where collecting fiber gc allocation backtrace is turned on by default.
It surely depends on frequency and pattern of allocation. Test
sql/delete3 depends on backtrace performance most dramatically. On some
installations collecting backtraces slowed down the test up to 10 times.

If fast path is available then collecting backtrace does not affect
performance in a noticeable way.

I propose not to keep autotools products in the libunwind fork repo as
it is done previously. LOG_CONFIGURE is removed because it somehow
incompatible with using && in CONFIGURE_COMMAND command and not critical
to the build.

Also add autotools build dependencies for packpack package specs.
Currently not all packpack images have autotools preinstalled so this is
required for build to success. Anyway we'b better have precise build
requirements in build specs.

Follow-up #5665

NO_DOC=internal
NO_TEST=internal
NO_CHANGELOG=internal

This patch removes an old CMake kludge, which sets CMAKE_SYSTEM_PROCESSOR
to "x86_64" on all 64-bit architectures, even on ARM (on Darwin).

Closes #7495

NO_DOC=bugfix

backtrace_collect() is suffering from the same issue as coro_transfer(),
see commit 215630e6 ("coro: update sp before saving registers to a
stack frame").

It stores x19-x30 and d8-d15 registers to the stack, but only after that
it updates the stack pointer. If a SIGALRM signal is delivered during
the execution of backtrace_collect, the signal handler will use the
stack starting from current sp, thus corrupting the saved registers.

Fix this by updating the stack pointer at the beginning of
backtrace_collect. The constraint of the input operand `bt` is changed
from "m" to "r" to force `bt` always be passed to the inline assembly
via the register. Passing on stack will not work after this fix.

Closes #7985

NO_DOC=bugfix
NO_TEST=Hard to create a stable reproducer

During rollback read trackers are rebound to newer or older story, if
present. The problem with the current logic is that read trackers are
basically rebound in the first available index: all information about key
parts read from other indexes gets lost — rebind read trackers in all
indexes.

Closes #7828

NO_DOC=bugfix

We assumed that the successor tuple's story could not get garbage collected
on clarify of result tuple in `tree_iterator_start`, since they coincide in
case of regular iterators. But this is not the case for reverse iterators:
the result tuple is of-by-one from the successor, which means the
successor's story can get garbage collected along with the tuple itself
getting deleted, leading to use-after-free of successor: remove garbage
collection from `memtx_tx_tuple_clarify` and call it manually.

The crash in #7756 revealed that the `put` in transaction manager's story
hash table was performed incorrectly: fix it and add an assertion that
nothing was replaced.

Closes #7755
Closes #7756

NO_DOC=bugfix

This patch converts existing SQL foreign key constraints and check
constraints into core foreign key constraints and check constraints.

Closes #6986

@TarantoolBot document
Title: SQL constraints

SQL constraints will now use the tuple constraint mechanism instead of
the original SQL mechanism. This allows to set constraints that are
independent of the language used for creation. However, this disables
some SQL constraint features that are not supported by tuple
constraints.

This patch forces SQL to create core CHECK constraint instead of SQL
CHECK constraint.

Part of #6986

NO_DOC=will be added later
NO_CHANGELOG=will be added later

After this patch, it will be possible to use the SQL_EXPR functions not
only for tuple constraints, but also for field constraints.

Needed for #6986

@TarantoolBot document
Title: SQL_EXPR functions

Now it is possible to create functions with `SQL_EXPR` language. The
`body` field of the function definition is the SQL expression.
Currently, these functions can only be used as constraints on tuples and
fields, as there is no interface to define argument names and types
otherwise.

If the SQL_EXPR function is set as a constraint on a field, the function
will throw a validation error if more than one variable is used in the
function. However, the variable name of the only variable will only be
checked if the SQL_EXPR function was created as a field constraint from
SQL.

SQL_EXPR functions use the mechanics of prepared statements, so they can
expire after a schema change. However, since subselects are prohibited
in these functions, there is no point in expiring them. This patch makes
it so that SQL_EXPR functions no longer expire.

Part of #6986

NO_DOC=Bug
NO_CHANGELOG=Bug in new functionality

Prior to this patch, if the last fields were nullable in tuple format,
they were discarded in SQL_EXPR functions. Now they are counted
correctly.

Part of #6986

NO_DOC=New feature
NO_CHANGELOG=New feature

This patch forces SQL to create core foreign keys instead of SQL foreign
keys in SQL.

Part of #6986

NO_DOC=will be added later
NO_CHANGELOG=will be added later

This patch removes sql_defer_foreign_keys from the _session_setting
system space, since foreign keys can no longer be deferred.

Part of #6986

@TarantoolBot document
Title: Deletion of "sql_defer_foreign_keys" session setting.

Because "constraint check time" is no longer supported by foreign keys,
the session setting "sql_defer_foreign_keys" has no meaning and is
discarded.

This patch removes three rules in the parser.

NO_CHANGELOG=will be added later

@TarantoolBot document
Title: Changes in parsing rules.

Three rules related to foreign keys have been removed.

The first is the "reference trigger action" rule, which determines the
behavior when a referenced tuple is deleted. This rule has been dropped
because the new foreign keys only support RESTRICT.

The second is "constraint check time" rule, which determines when a
foreign key constraint should be validated. This rule has been dropped
because the new foreign keys only support INITIALLY IMMEDIATELY.

The third is "match type" rule, which determines how inserted values are
validated. This rule has been dropped because the new foreign keys only
support FULL.

This patch removes some foreign key tests due to changes in foreign key
mechanics. Since the SQL foreign key will be replaced by the BOX foreign
key, some functionality will be removed or changed, so most of these
tests become meaningless. Also, most foreign key features now will be
tested in BOX rather than SQL.

Part of #6986

NO_DOC=drop tests
NO_TEST=drop tests
NO_CHANGELOG=drop tests

Introduce triggers which are run during various stages of box.cfg{}.
See the docbot request below for more info.

Part-of #5272
Part-of #3159

@TarantoolBot document
Title: new triggers -- `box.ctl.on_recovery_state`

`box.ctl.on_recovery_state` is a handle to register triggers that will
be executed on different stages of recovery/initial configuration.
A trigger registered this way is run on each of the supported recovery
stages, and receives the stage name as a parameter. The possible stages
are:
 - "snapshot_recovered": the node has recovered the snapshot file.
 - "wal_recovered": the node has recovered all the .xlog files.
 - "indexes_built": all the secondary indexes are usable. This event
   might come even before any actual data is recovered, meaning that the
   indexes will be available right with the first recovered tuple.
 - "synced": the node has synced with enough remote peers and has left
   orphan state.

All these stages are passed during initial `box.cfg` call when recovering
from .snap and .xlog files.

When bootstrapping a fresh cluster with no data, all the instances in it
will still execute triggers on the same stages for consistency.
For example, "snapshot_recovered" and "wal_recovered" will
be run once the node finishes cluster bootstrap or finishes joining to an
existing cluster.

Anyway, by the time the initial `box.cfg` call finishes, regardless of
recovery or bootstrap, the triggers will be called with parameters
"snapshot_recovery", "wal_recovered" and "indexes_built". The triggers
on "synced" state might execute later, when the node leaves the orphan
mode.

Note, that you must set `box.ctl.on_recovery_state` triggers before the
initial `box.cfg` call for them to take effect.
Example:

NO_WRAP
```
Tarantool 2.11.0
type 'help' for interactive help
tarantool> log = require('log')
---
...

tarantool> trigger_f = function(state) log.info('State "' .. state .. '" reached') end
---
...

tarantool> box.ctl.on_recovery_state(trigger_f)
---
- 'function: 0x0104662788'
...

tarantool> box.cfg{}
<stripped some messages>
2022-11-15 13:21:43.149 [98398] main/103/interactive I> recovering from `./00000000000000000004.snap'
2022-11-15 13:21:43.166 [98398] main/103/interactive I> cluster uuid 75c5c40e-c795-4c6f-b602-25fe5b1c9f3b
2022-11-15 13:21:43.187 [98398] main/103/interactive I> assigned id 1 to replica 1fbcb1d7-f600-4cc6-83b4-8d409d2937a9
2022-11-15 13:21:43.187 [98398] main/103/interactive I> update replication_synchro_quorum = 1
2022-11-15 13:21:43.187 [98398] main/103/interactive I> State "snapshot_recovered" reached
                                                               ^^^^^^^^^^^^^^^^^^
2022-11-15 13:21:43.187 [98398] main/103/interactive I> recover from `./00000000000000000004.xlog'
2022-11-15 13:21:43.188 [98398] main/103/interactive I> done `./00000000000000000004.xlog'
2022-11-15 13:21:43.188 [98398] main/103/interactive I> recover from `./00000000000000000006.xlog'
2022-11-15 13:21:43.188 [98398] main/103/interactive I> done `./00000000000000000006.xlog'
2022-11-15 13:21:43.188 [98398] main/103/interactive I> Building secondary indexes in space 'test'...
2022-11-15 13:21:43.188 [98398] main/103/interactive I> Adding 2 keys to TREE index 'sk' ...
2022-11-15 13:21:43.188 [98398] main/103/interactive I> Space 'test': done
2022-11-15 13:21:43.188 [98398] main/103/interactive I> State "indexes_built" reached
                                                               ^^^^^^^^^^^^^
2022-11-15 13:21:43.189 [98398] main/103/interactive I> State "wal_recovered" reached
                                                               ^^^^^^^^^^^^^
2022-11-15 13:21:43.189 [98398] main/103/interactive I> ready to accept requests
2022-11-15 13:21:43.189 [98398] main/103/interactive I> State "synced" reached
                                                               ^^^^^^
2022-11-15 13:21:43.189 [98398] main/103/interactive I> leaving orphan mode
<stripped some messages>
---
...

tarantool>

```
NO_WRAP

grep_log() was ported from test_run.lua and relied on string "Starting
instance" being shown on instance restart. Luatest doesn't leave such
messages in instance logs, so better rely on tarantool version output to
detect instance restarts.

In-scope-of #5272

NO_DOC=testing
NO_TEST=testing
NO_CHANGELOG=testing

Sometimes there's a need in creating a custom testing instance, with
test-specific code, which doesn't fit in box.cfg.

Our usual approach is to duplicate the instance file (default.lua) and make
the necessary changes there. This leads to a lot of code duplication and
lots of instance files with unclear use cases.

Let's better make it possible to pass code to the default instance via
an env variable TARANTOOL_RUN_BEFORE_CFG.

This will be used in box.ctl.on_recovery_state() triggers test.

In-scope-of #5272

NO_DOC=testing
NO_TEST=testing
NO_CHANGELOG=testing

Firstly, there is an assertion that checks if replica_id haven't been
changed after it's registration. Let's replace this assertion with warning
message about id being altered - new id will be used for affected replica.

Secondly, if before_replace trigger, set on space _cluster, returns nil,
tarantool will crash with segmentation fault. This patch handles the case.

Closes #7846

NO_DOC=bugfix

Export IPROTO constants and features to Lua: for now, simply copy-paste all
constants from `src/box/iproto_{constants, features}.h` — it would be nice
to generate them in the future (#7103).

Closes #7894

@TarantoolBot document
Title: export IPROTO constants and features to Lua
or the API description and usage exmaples, see:
* [design document](https://www.notion.so/tarantool/box-iproto-override-44935a6ac7e04fb5a2c81ca713ed1bce#dcaf854d2a9f4743ae25661c16528523);
* tarantool/tarantool#7894.

Closes #7639

@TarantoolBot document
Title: Pagination

Introduce pagination to memtx and vinyl trees. It allows to start iteration
after last previously selected tuple. Since tuples can be huge in size,
there is a new entity called `position` - opaque object that represents
position of tuple in index. It is encoded to base64 format and can be
transferred and stored without any issues with non-printable characters.

Lua API of pagination:
- `select`
Select is provided with two new options: `fetch_pos` and `after`.
Option `after` can take tuple (or table, representing it) or
`position`. If it is passed, iteration will begin after tuple which
is described by the option. If there is no tuple described by `after` in
index, iteration starts with a tuple that would have been preceded by a
described one. Empty string ("") or `box.NULL` can be passed as a start
position. Here is an example:
```lua
last_tuple = box.NULL
while true do
    tuples = s:select(key, {limit=1000, after=last_tuple})
    if #tuples == 0 then
        break
    end
    last_tuple = tuples[#tuples]
    process_data(tuples)
end
```

The second option is `fetch_pos` - one can fetch a `position` of last
selected tuple, it will be returned as the second value. If no tuples
were fetched, `position` will be `nil`.
The snippet can be simplified by using `fetch_pos` option:
```lua
pos = ""
while true do
    tuples, pos = s:select(key, {limit=1000, after=pos, fetch_pos=true})
    if pos == nil then
        break
    end
    process_data(tuples)
end
```
However, the benefits of using position are not only lower memory
consumption and easier syntax - position is the only way to paginate
over multikey and functional indexes - an error will be thrown when you
use option `after` with tuple because tuple has not enough information
to describe its position in such indexes.

-`tuple_pos`
Index has a new method `index:tuple_pos(tuple)`, it returns `position`
of passed tuple (or a table, representing a tuple) in this index, even
if there is no such tuple. Passed tuple must match format of the space.
Does not work with multikey and functional indexes - an error will be
thrown.
```lua
pos = ""
while true do
    tuples = s:select(key, {limit=1000, after=pos})
    if #tuples == 0 then
        break
    end
    last_tuple = tuples[#tuples]
    pos = s.index.pk:tuple_pos(last_tuple)
    process_data(tuples)
end
```

-`pairs`
Pairs is provided only with `after` option with the same semantics.

```lua
for _, tuple in s:pairs(10, {after={10, 5}} do
    process_tuple(tuple)
end
```

-IPROTO
IPROTO is provided with new keys:

0x2e - IPROTO_AFTER_POSITION - start iteration after passed
`position`. It has type MP_STR.

0x2f - IPROTO_AFTER_TUPLE - start iteration after passed tuple.
It has type MP_ARRAY.

0x1f - IPROTO_FETCH_POSITION - send position of last fetched tuple
in response. It has type MP_BOOL.

0x35 - IPROTO_POSITION - `position`, sent in response if
IPROTO_FETCH_POSITION is true. It has type MP_STR.

To start iteration from the beginning, one can send empty MP_STR as
IPROTO_AFTER_POSITION or send no `position` at all.

IPROTO_VERSION is bumped, new feature `pagination` is added.

-`net.box`
Net box select is provided with the same options `after` and
`fetch_pos`. It has the same behavior as in index select. The only
difference is format of returned values:
If option `buffer` is passed, the whole response is written to buffer,
only number of written bytes is returned.
If option `skip_header` is passed (if `skip_header` is passed, then
`buffer` is necessarily passed too), only IPROTO_DATA (without header)
is written in buffer, select returns number of bytes written as the
first value and `position` of last selected tuple as the second one.
If request is async and without buffer, then table with tuples is
returned if `fetch_pos` is false or nil (old behavior) and table with
table of tuples and `position` of last selected tuples is returned if
`fetch_pos` is true.
If no options, described above, are passed, then table with tuples is
returned as the first value and new `position` as the second one if
`fetch_pos` option is true.

Synchronous API:
```lua
pos = ""
while true do
    tuples, pos = conn.space.s:select(key, {limit=1000, after=pos,
        fetch_pos=true})
    if pos == nil then
        break
    end
    process_data(tuples)
end
```

Asynchronous API:
```lua
pos = ""
while true do
    ret = conn.space.s:select(key, {limit=1000, after=pos,
        fetch_pos=true, is_async=true})
    tuples = ret[1]
    pos = ret[2]
    if pos == nil then
        break
    end
    process_data(tuples)
end
```

NO_TEST=no changes

The patch introduces pagination to pairs: one can create iterator which
will start after specific tuple or position, described by option after.
Tuple (both cdata and array) and position (obtained by index:tuple_pos
or fetch_pos option of select) can be passed as option after.

NO_CHANGELOG=next commit
NO_DOC=next commit

Discovered by Coverity:

https://scan7.scan.coverity.com/reports.htm#v43693/p13437/fileInstanceId=130384650&defectInstanceId=18636974&mergedDefectId=1527607

Follow-up #5665

NO_TEST=nit
NO_CHANGELOG=nit
NO_DOC=nit

The test fails with:

  not ok 2 ...ty_or_nil_select.test_log_entry_presence_for_memtx_user_space
  gh_6539_log_user_space_empty_or_nil_select_test.lua:122: log must contain
  a critical entry about `box.space.test_memtx:select({0}, {limit = 1001,
  iterator = "ALL"})` call on a memtx user space
  expected: a value evaluating to true, actual: nil

Looks like it happens, because g.server:grep_log() is executed before
g.server:eval(call) completes writing to the log.
In other tests grep_log() is wrapped into t.helpers.retrying() in order
to avoid such issues, so do the same here.

May close tarantool/tarantool-qa#264

NO_DOC=test fix
NO_CHANGELOG=test fix

This commit adds the part number to the ER_WRONG_INDEX_PARTS error
message format to make it easier for the user to figure out what
went wrong.

Closes #7933

NO_DOC=verbosity

Currently, we include the bad field number into the error message
manually, using tt_sprintf, which looks cumbersome. For some fields,
we don't include it at all (e.g. invalid constraint definition).
Let's include it into the error message format instead.

Part of #7933

NO_DOC=verbosity
NO_CHANGELOG=later

Passing the error code to opts_decode complicates adding the space field
or index part number to the error message. Let's use the IllegalParams
error in opts_decode instead and set the proper ClientError at each call
site.

Needed for #7933

NO_DOC=refactoring
NO_TEST=refactoring
NO_CHANGELOG=refactoring

Currently, we raise the generic ER_IDENTIFIER error while we're supposed
to use the error code passed to opts_decode for verbosity. Fix this.

Follow-up commit 1d00b544 ("box: check constraint name against
identifier rules").

Part of #7933

NO_DOC=verbosity
NO_CHANGELOG=later

We're planning to simplify the opts_decode function protocol: instead of
passing an error code to it and let it set ClientError, we'll rework it
so that it may only set IllegalParams error, which is supposed to be
converted to ClientError with a proper error code at the upper level.
This will let us append extra information, such as field number, to the
error.

The problem is, space_upgrade_def_decode sets ER_UNSUPPORTED error,
which is against the new protocol. Let's move the error setting to
space_upgrade_check_alter, which looks like a better place for it,
anyway. To achieve that, we make space_upgrade_def_new skip the input
and return BAD_PTR, which is used as a marker indicating that the space
upgrade options were set.

Needed for #7933

NO_DOC=refactoring
NO_TEST=refactoring
NO_CHANGELOG=refactoring

For some options (OPT_STRPTR, OPT_CUSTOM), opts_decode may need to
allocate the result from the fiber region. The allocation shouldn't
normally fail (if it fails, it means the system is misconfigured and it
doesn't make much sense to carry on; essentially, the fiber region is
used like a stack). Still, we try to handle memory allocation failures
gracefully there by returning OutOfMemory error. This complicates the
opts_decode function protocol: we can't use IllegalParams for
propagating errors and convert the error to ClientError with a proper
error code at the call site, because the error would look ridiculous on
OOM (for example, "Wrong space options: Failed to allocate XX bytes for
..."). Instead, we have to pass the error code for ClientError to
opts_decode, which, in turn, makes it impossible to set the proper space
field or index part number for the sake of verbosity.

To address this issue, let's use xregion_alloc instead of region_alloc
and remove all OutOfMemory errors from opts_decode itself as well as all
callbacks that may allocate memory from the region.

Needed for #7933

NO_DOC=internal
NO_TEST=internal
NO_CHANGELOG=internal

When pagination is used, we must not assume that the first result
returned by the read iterator is the first tuple matching the iterator
criteria, because there may actually be tuples between the search and
after keys. Set vy_read_iterator::is_cache_boundary accordingly when
the iterator is opened.

Fixes commit 3f026339 ("vinyl: implement iterator pagination").

Closes #7943

NO_DOC=bug fix
NO_CHANGELOG=bug fix for unreleased feature

The read iterator skips DELETE statements. If a skipped DELETE statement
was read from the transaction write set, the read iterator breaks the
current cache chain by clearing vy_read_iterator::last_cached, because
the deleted tuple may actually be present at a lower level so adding
a gap there until the transaction is committed would be incorrect, see
commit dd926790 ("vinyl: fix a bug in adding of a cache chain").

The problem is vy_cache_add() assumes that if last_cached is NULL
the tuple added to the cache must be the first tuple that meets the
iteration criteria and sets the cache node boundary level accordingly.
This may lead to the previous tuple being erroneously skipped later
in case the transaction that attempted to delete it is rolled back.

Fix this issue by passing the flag indicating if the current tuple is
the first result of the iteration explicitly to vy_cache_add().

Closes #7947

NO_DOC=bug fix

As it breaks sane usage of region as a data stack:

	size_t region_svp = region_used(&fiber()->gc);
	/* some allocation on fiber gc and usage of allocated memory. */
	region_truncate(&fiber()->gc, region_svp);

If in the above snippet one calls a function that in turn calls
`fiber_gc` then the snippet code may have use-after-free and later UB
on truncation.

For this reason let's get read of fiber_gc. However we need to make sure
we won't introduce leaks this way. So before actually removing
fiber_gc we make it perform leak check instead and only after fixing
all the leaks the fiber_gc was removed.

In order to find the leak easily the backtrace of the first fiber gc
allocation that is not truncated is saved and then reported.

In order to catch leaks that are not triggered by the current test suit
and to prevent introducing leaks in future patches the leak check is
added on fiber exit/recycle and for long living system fibers on every loop
iteration.

Leak check in release build is on but without leak backtrace info by
default for performance reasons. Backtrace can be provided by using
`fiber.leak_backtrace_enable()` knob before starting leaking fiber.

Regularly leaks are only reported in log but it will not help to
catch errors when running test suits so build option ABORT_ON_LEAK
is added. When it is on we abort on leak. This option is turned off
for all builds that used in CI.

Closes #5665

NO_CHANGELOG=internal
NO_DOC=internal

Currently in space_execute_dml we have some txn related objects
allocated on fiber region. Use txn region as in other places.

NO_DOC=internal
NO_CHANGELOG=internal
NO_TEST=internal

Currently `backtrace_snprint ` indirectly uses `tt_static_buf()` by
itself. As a result its callers cannot use `tt_static_buf()`. With
large enough backtrace stack size buffer passed to `backtrace_snprint`
will be overwritten inside `backtrace_frame_resolve` call.

Part of #5665

NO_DOC=internal
NO_CHANGELOG=internal
NO_TEST=internal

* Ensure correct stack top for OOM error message.
* x86/x64: Check for jcc when using xor r,r in emit_loadi().
* Save trace recorder state around VM event call.
* Fix io.close() error message.
* Fix io.close().
* Cleanup math function compilation and fix inconsistencies.

Closes #3840
Closes #6782
Part of #7230

NO_DOC=LuaJIT submodule bump
NO_TEST=LuaJIT submodule bump

If create_index('...', {parts = {...}}) is called without the `collation`
option, then use collation from the space format.

Closes #5104

@TarantoolBot document
Title: Index options are inherited from the space format
Root document: https://www.tarantool.io/en/doc/latest/reference/reference_lua/box_space/create_index/

If `is_nullable` and `collation` options are not set, then they are
inherited from the space format, if applicable for that field type.

Local spaces can be written to on any replica, even on a read-only one.
This makes sense, because local space data isn't replicated, so it can't
lead to a conflict or violate consistency anyhow.

However, when used together with synchronous replication, local spaces
can't be written to by anyone but the synchro queue owner:
```
tarantool> box.info.synchro.queue.len
---
- 1
...
tarantool> box.space.loc:replace{2}
---
- error: Found uncommitted sync transactions from other instance with id 1
...
```
Fix this and allow to put transactions touching local spaces to the
synchro queue even if it is claimed by someone else.

Note, we can't let local transactions bypass the synchro queue completely.
This would lead to consistency loss in a case when synchro queue
contains a transaction [sync_row, local_row], and another transcation
[local_row], probably based on the sync transaction, bypasses the limbo.

Closes #7592

NO_DOC=bugfix

txn_commit() and txn_commit_try_async() share the common logic of
determining if a transaction should go to the synchronous transaction
queue and then putting the transaction there.

Factor the common places out to a helper.

Part-of #7592

NO_DOC=refactoring
NO_TEST=refactoring
NO_CHANGELOG=refactoring

If you shut down the replica and delete all xlog files on it, and it
reconnect to the master, may occur the restore error. Because there are
intermediate xlog files between the snap on the replica and the last
xlog on the master. When restoring xlog files on the replica, it can be
occurred that prev_signature < signature and this will lead to the crash
of the master.

Closes #5158

NO_DOC=bugfix

It appears that we have to wait for commit completion on master before
start waiting for it on replica.

Closes tarantool/tarantool-qa#284

NO_DOC=test fix
NO_CHANGELOG=test fix