Commits
- Commit:
5baf0756b052b8e7429ddb03575464f6c2662948
- From:
- Sergey Bronnikov <sergeyb@tarantool.org>
- Date:
luajit: bump new version
* LJ_GC64: Fix lua_concat().
Part of #8825
NO_DOC=LuaJIT submodule bump
NO_TEST=LuaJIT submodule bump
- Commit:
2c422a0b98675cab480ebb44256dfeb72bd2f820
- From:
- Sergey Ostanevich <sergos@tarantool.org>
- Via:
- Serge Petrenko <35663196+sergepetrenko@users.noreply.github.com>
- Date:
test: fixup the 1mops perf test
The option --sync was ignored due to a misprint.
The temporary dir was never removed, overflowing the /tmp by default.
NO_TEST=test update
NO_DOC=test update
NO_CHANGELOG=test update
- Commit:
e99f6cb094fc978346eda9000d0b7e6e0b2a2fbb
- From:
- Maksim Kokryashkin <max.kokryashkin@gmail.com>
- Via:
- Igor Munkin <imun@cpan.org>
- Date:
test: remove finalizers table overflow test
This test is no longer needed in the Tarantool test suite
since it was added to LuaJIT's test suite along with the fix
for the issue mentioned in #3060 in scope of #8825 in commit
tarantool/luajit@7b98314e0dacc7313c061aceeb0a32afd4e8cbce.
Closes #3060
Related to #8825
NO_DOC=Cleanup
NO_TEST=Already included in LuaJIT bump
NO_CHANGELOG=Already included in LuaJIT bump
- Commit:
4b88d5fd9833b1c236572e7c557646909ec415eb
- From:
- Vladimir Davydov <vdavydov@tarantool.org>
- Via:
- Vladimir Davydov <vdavydov.dev@gmail.com>
- Date:
box: allow lua_call priv owners to call registered Lua functions
Currently, the lua_call privilege simply doesn't work for registered
functions. This patch fixes this issue: now, it grants access to any
registered function that is written in Lua unless it's a built-in
function, such as dostring, or a persistent function.
Note, this patch renames access_check_call to access_check_lua_call to
avoid confusion because this function is now global. It also renames
access_check_eval to access_check_lua_eval for consistency.
Closes #9363
NO_DOC=updated doc ticket manually
NO_CHANGELOG=feature has not been released yet
- Commit:
44401529a2253cbf00583a3680ae01f0cb74693c
- From:
- Magomed Kostoev <m.kostoev@tarantool.org>
- Via:
- Vladimir Davydov <vdavydov.dev@gmail.com>
- Date:
fiber: make the concurrent fiber_join safer
Prior to this patch a bunch of illegal conditions was possible:
1. The joinability of a fiber could be changed while the fiber is
being joined by someone. This could lead to double recycling:
the first one happened on the fiber finish, and the second one
in the fiber join.
2. The joinability of a dead joinable fiber could be altered, this
led to inability jo join the dead fiber and free its resources.
3. A running fiber could be joined concurrently by two or more
fibers, so the fiber could be recycled more than once (once
per each concurrent join).
4. A dead recycled fiber could be made joinable and joined leading
to the double recycle.
Fixed these issues by adding a new FIBER_JOIN_BEEN_INVOKED flag: now
the `fiber_set_joinable` and `fiber_join_timeout` functions detect
the double join. Because of the API limitations both of them panic
when an invalid condition is met:
- The `fiber_set_joinable` was not designed to report errors.
- The `fiber_join_timeout` can't raise any error unless a timeout
is met, because the `fiber_join` users don't expect to receive
any error from this function at all (except the one generated
by the joined fiber).
It's still possible that a fiber join is performed on a struct which
has been recycled and, if the new fiber is joinable too, this can't
be detected. The current fiber API does not allow to fix this, so
this is to be the user's responsibility, they should be warned about
the fact the double join to the same fiber is illegal.
Closes #7562
@TarantoolBot document
Title: `fiber_join`, `fiber_join_timeout` and `fiber_set_joinable`
behave differently now.
`fiber_join` and `fiber_join_timeout` now panic in case if double
join of the given fiber is detected.
`fiber_set_joinable` now panics if the given fiber is dead or is
joined already. This prevents some amount of error conditions that
could happen when using the API in an unexpected way, including:
- Making a dead joinable fiber non-joinable could lead to a memory
leak: one can't join the fiber anymore.
- Making a dead joinable fiber joinable again is a sign of attempt
to join the fiber later. That means the fiber struct may be joined
later, when it's been recycled and reused. This could lead to a
very hard to debug double join.
- Making an alive joined fiber non-joinable would lead to the double
free: once on the fiber function finish, and secondly in the active
fiber join finish. Risks of making it joinable are described above.
- Making a dead and recycled fiber joinable allowed to join the fiber
once again leading to a double free.
Any given by the API `struct fiber` should only be joined once. If a
fiber is joined after the first join on it has finished the behavior
is undefined: it can either be a panic or an incidental join to a
totally foreign fiber.