Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

memory corruption - "Segmentation fault on shard 2" on 4 nodes after nodetool refresh #14618

Closed
2 tasks
yarongilor opened this issue Jul 11, 2023 · 24 comments
Closed
2 tasks
Assignees
Milestone

Comments

@yarongilor
Copy link

yarongilor commented Jul 11, 2023

Issue description

Issued a nodetool refresh on all 6 cluster nodes.
Few seconds later 4 nodes got segmentation fault.

sct-runner-events-996fb5c0$ egrep -i 'Segmentation fault on shard|nodetool  refresh' sct.log 
< t:2023-07-03 12:45:36,147 f:remote_base.py  l:520  c:RemoteLibSSH2CmdRunner p:DEBUG > Running command "/usr/bin/nodetool  refresh -- keyspace1 standard1"...
< t:2023-07-03 12:45:38,728 f:base.py         l:142  c:RemoteLibSSH2CmdRunner p:DEBUG > Command "/usr/bin/nodetool  refresh -- keyspace1 standard1" finished with status 0
< t:2023-07-03 12:45:38,729 f:cluster.py      l:2585 c:sdcm.cluster_gce     p:DEBUG > Node longevity-10gb-3h-master-db-node-996fb5c0-0-4 [34.148.210.57 | 10.142.0.99] (seed: True): Command '/usr/bin/nodetool  refresh -- keyspace1 standard1' duration -> 2.5810990879999736 s
< t:2023-07-03 12:45:42,971 f:remote_base.py  l:520  c:RemoteLibSSH2CmdRunner p:DEBUG > Running command "/usr/bin/nodetool  refresh -- keyspace1 standard1"...
< t:2023-07-03 12:45:45,549 f:base.py         l:142  c:RemoteLibSSH2CmdRunner p:DEBUG > Command "/usr/bin/nodetool  refresh -- keyspace1 standard1" finished with status 0
< t:2023-07-03 12:45:45,549 f:cluster.py      l:2585 c:sdcm.cluster_gce     p:DEBUG > Node longevity-10gb-3h-master-db-node-996fb5c0-0-5 [35.237.89.13 | 10.142.0.100] (seed: True): Command '/usr/bin/nodetool  refresh -- keyspace1 standard1' duration -> 2.577998179000133 s
< t:2023-07-03 12:45:48,124 f:db_log_reader.py l:114  c:sdcm.db_log_reader   p:DEBUG > 2023-07-03T12:45:48+00:00 longevity-10gb-3h-master-db-node-996fb5c0-0-4     !INFO | scylla[12456]: Segmentation fault on shard 2.
< t:2023-07-03 12:45:49,871 f:remote_base.py  l:520  c:RemoteLibSSH2CmdRunner p:DEBUG > Running command "/usr/bin/nodetool  refresh -- keyspace1 standard1"...
< t:2023-07-03 12:45:51,460 f:base.py         l:142  c:RemoteLibSSH2CmdRunner p:DEBUG > Command "/usr/bin/nodetool  refresh -- keyspace1 standard1" finished with status 0
< t:2023-07-03 12:45:51,460 f:cluster.py      l:2585 c:sdcm.cluster_gce     p:DEBUG > Node longevity-10gb-3h-master-db-node-996fb5c0-0-6 [35.229.91.148 | 10.142.0.106] (seed: True): Command '/usr/bin/nodetool  refresh -- keyspace1 standard1' duration -> 1.588782070999514 s
< t:2023-07-03 12:45:55,610 f:db_log_reader.py l:114  c:sdcm.db_log_reader   p:DEBUG > 2023-07-03T12:45:55+00:00 longevity-10gb-3h-master-db-node-996fb5c0-0-5     !INFO | scylla[12611]: Segmentation fault on shard 2.
< t:2023-07-03 12:45:56,257 f:remote_base.py  l:520  c:RemoteLibSSH2CmdRunner p:DEBUG > Running command "/usr/bin/nodetool  refresh -- keyspace1 standard1"...
< t:2023-07-03 12:45:57,855 f:base.py         l:142  c:RemoteLibSSH2CmdRunner p:DEBUG > Command "/usr/bin/nodetool  refresh -- keyspace1 standard1" finished with status 0
< t:2023-07-03 12:45:57,855 f:cluster.py      l:2585 c:sdcm.cluster_gce     p:DEBUG > Node longevity-10gb-3h-master-db-node-996fb5c0-0-7 [35.185.4.246 | 10.142.0.5] (seed: True): Command '/usr/bin/nodetool  refresh -- keyspace1 standard1' duration -> 1.5977162110011704 s
< t:2023-07-03 12:46:01,074 f:remote_base.py  l:520  c:RemoteLibSSH2CmdRunner p:DEBUG > Running command "/usr/bin/nodetool  refresh -- keyspace1 standard1"...
< t:2023-07-03 12:46:02,640 f:base.py         l:142  c:RemoteLibSSH2CmdRunner p:DEBUG > Command "/usr/bin/nodetool  refresh -- keyspace1 standard1" finished with status 0
< t:2023-07-03 12:46:02,646 f:cluster.py      l:2585 c:sdcm.cluster_gce     p:DEBUG > Node longevity-10gb-3h-master-db-node-996fb5c0-0-10 [35.196.155.42 | 10.142.0.81] (seed: True): Command '/usr/bin/nodetool  refresh -- keyspace1 standard1' duration -> 1.5658292730004177 s
< t:2023-07-03 12:46:06,502 f:remote_base.py  l:520  c:RemoteLibSSH2CmdRunner p:DEBUG > Running command "/usr/bin/nodetool  refresh -- keyspace1 standard1"...
< t:2023-07-03 12:46:08,056 f:base.py         l:142  c:RemoteLibSSH2CmdRunner p:DEBUG > Command "/usr/bin/nodetool  refresh -- keyspace1 standard1" finished with status 0
< t:2023-07-03 12:46:08,061 f:cluster.py      l:2585 c:sdcm.cluster_gce     p:DEBUG > Node longevity-10gb-3h-master-db-node-996fb5c0-0-11 [34.73.193.43 | 10.142.0.25] (seed: True): Command '/usr/bin/nodetool  refresh -- keyspace1 standard1' duration -> 1.5537066340002639 s
< t:2023-07-03 12:46:13,070 f:file_logger.py  l:101  c:sdcm.sct_events.file_logger p:ERROR > 2023-07-03T12:45:48+00:00 longevity-10gb-3h-master-db-node-996fb5c0-0-4     !INFO | scylla[12456]: Segmentation fault on shard 2.
< t:2023-07-03 12:46:13,490 f:db_log_reader.py l:114  c:sdcm.db_log_reader   p:DEBUG > 2023-07-03T12:46:13+00:00 longevity-10gb-3h-master-db-node-996fb5c0-0-10     !INFO | scylla[6241]: Segmentation fault on shard 2.
< t:2023-07-03 12:46:18,355 f:db_log_reader.py l:114  c:sdcm.db_log_reader   p:DEBUG > 2023-07-03T12:46:18+00:00 longevity-10gb-3h-master-db-node-996fb5c0-0-11     !INFO | scylla[6233]: Segmentation fault on shard 2.
< t:2023-07-03 12:46:20,144 f:file_logger.py  l:101  c:sdcm.sct_events.file_logger p:ERROR > 2023-07-03T12:45:55+00:00 longevity-10gb-3h-master-db-node-996fb5c0-0-5     !INFO | scylla[12611]: Segmentation fault on shard 2.
< t:2023-07-03 12:46:38,694 f:events_processes.py l:200  c:sdcm.sct_events.events_processes p:ERROR > 2023-07-03T12:46:13+00:00 longevity-10gb-3h-master-db-node-996fb5c0-0-10     !INFO | scylla[6241]: Segmentation fault on shard 2.
2023-07-03T12:46:13+00:00 longevity-10gb-3h-master-db-node-996fb5c0-0-10     !INFO | scylla[6241]: Segmentation fault on shard 2.
< t:2023-07-03 12:46:38,696 f:events_processes.py l:200  c:sdcm.sct_events.events_processes p:ERROR > 2023-07-03T12:46:13+00:00 longevity-10gb-3h-master-db-node-996fb5c0-0-10     !INFO | scylla[6241]: Segmentation fault on shard 2.
2023-07-03T12:46:13+00:00 longevity-10gb-3h-master-db-node-996fb5c0-0-10     !INFO | scylla[6241]: Segmentation fault on shard 2.
< t:2023-07-03 12:46:43,300 f:events_processes.py l:200  c:sdcm.sct_events.events_processes p:ERROR > 2023-07-03T12:46:18+00:00 longevity-10gb-3h-master-db-node-996fb5c0-0-11     !INFO | scylla[6233]: Segmentation fault on shard 2.
2023-07-03T12:46:18+00:00 longevity-10gb-3h-master-db-node-996fb5c0-0-11     !INFO | scylla[6233]: Segmentation fault on shard 2.
< t:2023-07-03 12:46:43,318 f:events_processes.py l:200  c:sdcm.sct_events.events_processes p:ERROR > 2023-07-03T12:46:18+00:00 longevity-10gb-3h-master-db-node-996fb5c0-0-11     !INFO | scylla[6233]: Segmentation fault on shard 2.
2023-07-03T12:46:18+00:00 longevity-10gb-3h-master-db-node-996fb5c0-0-11     !INFO | scylla[6233]: Segmentation fault on shard 2.
< t:2023-07-03 12:51:52,771 f:db_log_reader.py l:114  c:sdcm.db_log_reader   p:DEBUG > 2023-07-03T12:51:52+00:00 longevity-10gb-3h-master-db-node-996fb5c0-0-6     !INFO | scylla[7370]: Segmentation fault on shard 2.
< t:2023-07-03 12:52:17,418 f:file_logger.py  l:101  c:sdcm.sct_events.file_logger p:ERROR > 2023-07-03T12:51:52+00:00 longevity-10gb-3h-master-db-node-996fb5c0-0-6     !INFO | scylla[7370]: Segmentation fault on shard 2.

(not sure it's not related to #14299)
core dump details:

2023-07-03 12:45:48.125 <2023-07-03 12:45:48.000>: (DatabaseLogEvent Severity.ERROR) period_type=one-time event_id=efa9a1b9-b717-4afe-83a7-059a2ab4bf49: type=SEGMENTATION regex=segmentation line_number=17337 node=longevity-10gb-3h-master-db-node-996fb5c0-0-4
2023-07-03T12:45:48+00:00 longevity-10gb-3h-master-db-node-996fb5c0-0-4     !INFO | scylla[12456]: Segmentation fault on shard 2.
void seastar::backtrace<seastar::backtrace_buffer::append_backtrace()::{lambda(seastar::frame)#1}>(seastar::backtrace_buffer::append_backtrace()::{lambda(seastar::frame)#1}&&) at ./build/release/seastar/./seastar/include/seastar/util/backtrace.hh:64
(inlined by) seastar::backtrace_buffer::append_backtrace() at ./build/release/seastar/./seastar/src/core/reactor.cc:811
(inlined by) seastar::print_with_backtrace(seastar::backtrace_buffer&, bool) at ./build/release/seastar/./seastar/src/core/reactor.cc:841
seastar::print_with_backtrace(char const*, bool) at ./build/release/seastar/./seastar/src/core/reactor.cc:853
(inlined by) seastar::sigsegv_action() at ./build/release/seastar/./seastar/src/core/reactor.cc:3964
(inlined by) operator() at ./build/release/seastar/./seastar/src/core/reactor.cc:3945
(inlined by) __invoke at ./build/release/seastar/./seastar/src/core/reactor.cc:3941
?? ??:0
seastar::memory::small_pool::allocate() at ./build/release/seastar/./seastar/src/core/memory.cc:1263
(inlined by) seastar::memory::cpu_pages::allocate_small(unsigned int) at ./build/release/seastar/./seastar/src/core/memory.cc:875
(inlined by) seastar::memory::allocate(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:1424
operator new(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:2110
std::__new_allocator<seastar::basic_sstring<signed char, unsigned int, 31u, false> >::allocate(unsigned long, void const*) at /usr/bin/../lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/bits/new_allocator.h:137
(inlined by) std::allocator<seastar::basic_sstring<signed char, unsigned int, 31u, false> >::allocate(unsigned long) at /usr/bin/../lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/bits/allocator.h:188
(inlined by) std::allocator_traits<std::allocator<seastar::basic_sstring<signed char, unsigned int, 31u, false> > >::allocate(std::allocator<seastar::basic_sstring<signed char, unsigned int, 31u, false> >&, unsigned long) at /usr/bin/../lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/bits/alloc_traits.h:464
(inlined by) std::_Vector_base<seastar::basic_sstring<signed char, unsigned int, 31u, false>, std::allocator<seastar::basic_sstring<signed char, unsigned int, 31u, false> > >::_M_allocate(unsigned long) at /usr/bin/../lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/bits/stl_vector.h:378
(inlined by) void std::vector<seastar::basic_sstring<signed char, unsigned int, 31u, false>, std::allocator<seastar::basic_sstring<signed char, unsigned int, 31u, false> > >::_M_realloc_insert<seastar::basic_sstring<signed char, unsigned int, 31u, false> >(__gnu_cxx::__normal_iterator<seastar::basic_sstring<signed char, unsigned int, 31u, false>*, std::vector<seastar::basic_sstring<signed char, unsigned int, 31u, false>, std::allocator<seastar::basic_sstring<signed char, unsigned int, 31u, false> > > >, seastar::basic_sstring<signed char, unsigned int, 31u, false>&&) at /usr/bin/../lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/bits/vector.tcc:453
(inlined by) seastar::basic_sstring<signed char, unsigned int, 31u, false>& std::vector<seastar::basic_sstring<signed char, unsigned int, 31u, false>, std::allocator<seastar::basic_sstring<signed char, unsigned int, 31u, false> > >::emplace_back<seastar::basic_sstring<signed char, unsigned int, 31u, false> >(seastar::basic_sstring<signed char, unsigned int, 31u, false>&&) at /usr/bin/../lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/bits/vector.tcc:123
(inlined by) compound_wrapper<partition_key, partition_key_view>::explode() const at ././keys.hh:248
(inlined by) void ser::serializer<partition_key>::write<seastar::measuring_output_stream>(seastar::measuring_output_stream&, partition_key const&) at ./build/release/gen/idl/keys.dist.impl.hh:52
(inlined by) void ser::serialize<partition_key, seastar::measuring_output_stream>(seastar::measuring_output_stream&, partition_key const&) at ././serializer.hh:262
(inlined by) unsigned int ser::get_sizeof<partition_key>(partition_key const&) at ././serializer_impl.hh:706
(inlined by) void ser::set_size<bytes_ostream, partition_key>(bytes_ostream&, partition_key const&) at ././serializer_impl.hh:32
(inlined by) void ser::serializer<partition_key>::write<bytes_ostream>(bytes_ostream&, partition_key const&) at ./build/release/gen/idl/keys.dist.impl.hh:50
void ser::serialize<partition_key, bytes_ostream>(bytes_ostream&, partition_key const&) at ././serializer.hh:262
(inlined by) ser::after_mutation__schema_version<bytes_ostream>::write_key(partition_key const&) && at ./build/release/gen/idl/mutation.dist.impl.hh:7074
(inlined by) frozen_mutation at ./mutation/frozen_mutation.cc:84
freeze(mutation const&) at ./mutation/frozen_mutation.cc:132
shared_mutation at ./service/storage_proxy.cc:1029
(inlined by) std::__detail::_MakeUniq<service::shared_mutation>::__single_object std::make_unique<service::shared_mutation, mutation const&>(mutation const&) at /usr/bin/../lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/bits/unique_ptr.h:1065
(inlined by) service::storage_proxy::create_write_response_handler(mutation const&, db::consistency_level, db::write_type, tracing::trace_state_ptr, service_permit, seastar::bool_class<db::allow_per_partition_rate_limit_tag>) at ./service/storage_proxy.cc:3033
operator() at ./service/storage_proxy.cc:3129
operator() at ./service/storage_proxy.cc:3116
seastar::future<boost::outcome_v2::basic_result<utils::small_vector<service::storage_proxy::unique_response_handler, 1ul>, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > seastar::futurize<seastar::future<boost::outcome_v2::basic_result<utils::small_vector<service::storage_proxy::unique_response_handler, 1ul>, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > >::invoke<seastar::future<boost::outcome_v2::basic_result<utils::small_vector<service::storage_proxy::unique_response_handler, 1ul>, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > service::storage_proxy::mutate_prepare<boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, seastar::future<boost::outcome_v2::basic_result<utils::small_vector<service::storage_proxy::unique_response_handler, 1ul>, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > service::storage_proxy::mutate_prepare<boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&>(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level, db::write_type, tracing::trace_state_ptr, service_permit, seastar::bool_class<db::allow_per_partition_rate_limit_tag>)::{lambda(mutation const&, db::consistency_level, db::write_type, service_permit)#1}>(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level, db::write_type, service_permit, seastar::future<boost::outcome_v2::basic_result<utils::small_vector<service::storage_proxy::unique_response_handler, 1ul>, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > service::storage_proxy::mutate_prepare<boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&>(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level, db::write_type, tracing::trace_state_ptr, service_permit, seastar::bool_class<db::allow_per_partition_rate_limit_tag>)::{lambda(mutation const&, db::consistency_level, db::write_type, service_permit)#1})::{lambda(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level, db::write_type, service_permit, {lambda(mutation const&, db::consistency_level, db::write_type, service_permit)#1})#1}, boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level&, db::write_type&, service_permit, {lambda(mutation const&, db::consistency_level, db::write_type, service_permit)#1}>(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level&, db::write_type&, service_permit&&, {lambda(mutation const&, db::consistency_level, db::write_type, service_permit)#1}&&) at ././seastar/include/seastar/core/future.hh:2006
auto seastar::futurize_invoke<seastar::future<boost::outcome_v2::basic_result<utils::small_vector<service::storage_proxy::unique_response_handler, 1ul>, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > service::storage_proxy::mutate_prepare<boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, seastar::future<boost::outcome_v2::basic_result<utils::small_vector<service::storage_proxy::unique_response_handler, 1ul>, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > service::storage_proxy::mutate_prepare<boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&>(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level, db::write_type, tracing::trace_state_ptr, service_permit, seastar::bool_class<db::allow_per_partition_rate_limit_tag>)::{lambda(mutation const&, db::consistency_level, db::write_type, service_permit)#1}>(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level, db::write_type, service_permit, seastar::future<boost::outcome_v2::basic_result<utils::small_vector<service::storage_proxy::unique_response_handler, 1ul>, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > service::storage_proxy::mutate_prepare<boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&>(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level, db::write_type, tracing::trace_state_ptr, service_permit, seastar::bool_class<db::allow_per_partition_rate_limit_tag>)::{lambda(mutation const&, db::consistency_level, db::write_type, service_permit)#1})::{lambda(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level, db::write_type, service_permit, {lambda(mutation const&, db::consistency_level, db::write_type, service_permit)#1})#1}, boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level&, db::write_type&, service_permit, {lambda(mutation const&, db::consistency_level, db::write_type, service_permit)#1}>(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level&, db::write_type&, service_permit&&, {lambda(mutation const&, db::consistency_level, db::write_type, service_permit)#1}&&) at ././seastar/include/seastar/core/future.hh:2037
(inlined by) seastar::future<boost::outcome_v2::basic_result<utils::small_vector<service::storage_proxy::unique_response_handler, 1ul>, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > service::storage_proxy::mutate_prepare<boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, seastar::future<boost::outcome_v2::basic_result<utils::small_vector<service::storage_proxy::unique_response_handler, 1ul>, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > service::storage_proxy::mutate_prepare<boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&>(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level, db::write_type, tracing::trace_state_ptr, service_permit, seastar::bool_class<db::allow_per_partition_rate_limit_tag>)::{lambda(mutation const&, db::consistency_level, db::write_type, service_permit)#1}>(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level, db::write_type, service_permit, seastar::future<boost::outcome_v2::basic_result<utils::small_vector<service::storage_proxy::unique_response_handler, 1ul>, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > service::storage_proxy::mutate_prepare<boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&>(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level, db::write_type, tracing::trace_state_ptr, service_permit, seastar::bool_class<db::allow_per_partition_rate_limit_tag>)::{lambda(mutation const&, db::consistency_level, db::write_type, service_permit)#1}) at ./service/storage_proxy.cc:3112
(inlined by) seastar::future<boost::outcome_v2::basic_result<utils::small_vector<service::storage_proxy::unique_response_handler, 1ul>, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > service::storage_proxy::mutate_prepare<boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&>(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >&, db::consistency_level, db::write_type, tracing::trace_state_ptr, service_permit, seastar::bool_class<db::allow_per_partition_rate_limit_tag>) at ./service/storage_proxy.cc:3128
(inlined by) seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > service::storage_proxy::mutate_internal<boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > > >(boost::iterator_range<__gnu_cxx::__normal_iterator<mutation*, std::vector<mutation, std::allocator<mutation> > > >, db::consistency_level, bool, tracing::trace_state_ptr, service_permit, std::optional<std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > > >, seastar::lw_shared_ptr<cdc::operation_result_tracker>, seastar::bool_class<db::allow_per_partition_rate_limit_tag>) at ./service/storage_proxy.cc:3447
service::storage_proxy::do_mutate(std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>) at ./service/storage_proxy.cc:3407
seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > std::__invoke_impl<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> >, seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy::* const&)(std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>), service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker> >(std::__invoke_memfun_deref, seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy::* const&)(std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>), service::storage_proxy*&&, std::vector<mutation, std::allocator<mutation> >&&, db::consistency_level&&, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >&&, tracing::trace_state_ptr&&, service_permit&&, bool&&, seastar::bool_class<db::allow_per_partition_rate_limit_tag>&&, seastar::lw_shared_ptr<cdc::operation_result_tracker>&&) at /usr/bin/../lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/bits/invoke.h:74
std::__invoke_result<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy::* const&)(std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>), service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker> >::type std::__invoke<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy::* const&)(std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>), service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker> >(seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy::* const&)(std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>), service::storage_proxy*&&, std::vector<mutation, std::allocator<mutation> >&&, db::consistency_level&&, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >&&, tracing::trace_state_ptr&&, service_permit&&, bool&&, seastar::bool_class<db::allow_per_partition_rate_limit_tag>&&, seastar::lw_shared_ptr<cdc::operation_result_tracker>&&) at /usr/bin/../lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/bits/invoke.h:96
(inlined by) _ZNKSt12_Mem_fn_baseIMN7service13storage_proxyEFN7seastar6futureIN5boost10outcome_v212basic_resultIvN5utils19exception_containerIJN10exceptions32mutation_write_timeout_exceptionENS9_22read_timeout_exceptionENS9_22read_failure_exceptionENS9_20rate_limit_exceptionEEEENS7_32exception_container_throw_policyEEEEESt6vectorI8mutationSaISJ_EEN2db17consistency_levelENSt6chrono10time_pointINS2_12lowres_clockENSO_8durationIlSt5ratioILl1ELl1000000000EEEEEEN7tracing15trace_state_ptrE14service_permitbNS2_10bool_classINSM_34allow_per_partition_rate_limit_tagEEENS2_13lw_shared_ptrIN3cdc24operation_result_trackerEEEELb1EEclIJPS1_SL_SN_SV_SX_SY_bS11_S15_EEEDTclsr3stdE8__invokedtdefpT6_M_pmfspclsr3stdE7forwardIT_Efp_EEEDpOS1B_ at /usr/bin/../lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/functional:167
(inlined by) seastar::noncopyable_function<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>)>::direct_vtable_for<std::_Mem_fn<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy::*)(std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>)> >::call(seastar::noncopyable_function<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>)> const*, service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>) at ././seastar/include/seastar/util/noncopyable_function.hh:129
seastar::noncopyable_function<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>)>::operator()(service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>) const at ././seastar/include/seastar/util/noncopyable_function.hh:215
operator() at ././seastar/include/seastar/core/execution_stage.hh:342
seastar::noncopyable_function<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>)>::direct_vtable_for<seastar::inheriting_concrete_execution_stage<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> >, service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker> >::make_stage_for_group(seastar::scheduling_group)::{lambda(service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>)#1}>::call(seastar::noncopyable_function<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>)> const*, service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>) at ././seastar/include/seastar/util/noncopyable_function.hh:129
seastar::noncopyable_function<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>)>::operator()(service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>) const at ././seastar/include/seastar/util/noncopyable_function.hh:215
seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > std::__invoke_impl<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> >, seastar::noncopyable_function<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>)>&, service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker> >(std::__invoke_other, seastar::noncopyable_function<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>)>&, service::storage_proxy*&&, std::vector<mutation, std::allocator<mutation> >&&, db::consistency_level&&, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >&&, tracing::trace_state_ptr&&, service_permit&&, bool&&, seastar::bool_class<db::allow_per_partition_rate_limit_tag>&&, seastar::lw_shared_ptr<cdc::operation_result_tracker>&&) at /usr/bin/../lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/bits/invoke.h:61
std::__invoke_result<seastar::noncopyable_function<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>)>&, service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker> >::type std::__invoke<seastar::noncopyable_function<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>)>&, service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker> >(seastar::noncopyable_function<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>)>&, service::storage_proxy*&&, std::vector<mutation, std::allocator<mutation> >&&, db::consistency_level&&, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >&&, tracing::trace_state_ptr&&, service_permit&&, bool&&, seastar::bool_class<db::allow_per_partition_rate_limit_tag>&&, seastar::lw_shared_ptr<cdc::operation_result_tracker>&&) at /usr/bin/../lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/bits/invoke.h:96
(inlined by) _ZSt12__apply_implIRN7seastar20noncopyable_functionIFNS0_6futureIN5boost10outcome_v212basic_resultIvN5utils19exception_containerIJN10exceptions32mutation_write_timeout_exceptionENS8_22read_timeout_exceptionENS8_22read_failure_exceptionENS8_20rate_limit_exceptionEEEENS6_32exception_container_throw_policyEEEEEPN7service13storage_proxyESt6vectorI8mutationSaISL_EEN2db17consistency_levelENSt6chrono10time_pointINS0_12lowres_clockENSQ_8durationIlSt5ratioILl1ELl1000000000EEEEEEN7tracing15trace_state_ptrE14service_permitbNS0_10bool_classINSO_34allow_per_partition_rate_limit_tagEEENS0_13lw_shared_ptrIN3cdc24operation_result_trackerEEEEEESt5tupleIJSJ_SN_SP_SX_SZ_S10_bS13_S17_EEJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8EEEDcOT_OT0_St16integer_sequenceImJXspT1_EEE at /usr/bin/../lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/tuple:1852
(inlined by) _ZSt5applyIRN7seastar20noncopyable_functionIFNS0_6futureIN5boost10outcome_v212basic_resultIvN5utils19exception_containerIJN10exceptions32mutation_write_timeout_exceptionENS8_22read_timeout_exceptionENS8_22read_failure_exceptionENS8_20rate_limit_exceptionEEEENS6_32exception_container_throw_policyEEEEEPN7service13storage_proxyESt6vectorI8mutationSaISL_EEN2db17consistency_levelENSt6chrono10time_pointINS0_12lowres_clockENSQ_8durationIlSt5ratioILl1ELl1000000000EEEEEEN7tracing15trace_state_ptrE14service_permitbNS0_10bool_classINSO_34allow_per_partition_rate_limit_tagEEENS0_13lw_shared_ptrIN3cdc24operation_result_trackerEEEEEESt5tupleIJSJ_SN_SP_SX_SZ_S10_bS13_S17_EEEDcOT_OT0_ at /usr/bin/../lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/tuple:1863
(inlined by) seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > seastar::futurize<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > >::apply<seastar::noncopyable_function<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>)>&, service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker> >(seastar::noncopyable_function<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> > (service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker>)>&, std::tuple<service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker> >&&) at ././seastar/include/seastar/core/future.hh:1973
(inlined by) seastar::concrete_execution_stage<seastar::future<boost::outcome_v2::basic_result<void, utils::exception_container<exceptions::mutation_write_timeout_exception, exceptions::read_timeout_exception, exceptions::read_failure_exception, exceptions::rate_limit_exception>, utils::exception_container_throw_policy> >, service::storage_proxy*, std::vector<mutation, std::allocator<mutation> >, db::consistency_level, std::chrono::time_point<seastar::lowres_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l> > >, tracing::trace_state_ptr, service_permit, bool, seastar::bool_class<db::allow_per_partition_rate_limit_tag>, seastar::lw_shared_ptr<cdc::operation_result_tracker> >::do_flush() at ././seastar/include/seastar/core/execution_stage.hh:251
operator() at ./build/release/seastar/./seastar/src/core/execution_stage.cc:149
(inlined by) seastar::future<void> seastar::futurize<void>::invoke<seastar::execution_stage::flush()::$_1&>(seastar::execution_stage::flush()::$_1&) at ./build/release/seastar/./seastar/include/seastar/core/future.hh:2003
(inlined by) seastar::lambda_task<seastar::execution_stage::flush()::$_1>::run_and_dispose() at ./build/release/seastar/./seastar/include/seastar/core/make_task.hh:45
seastar::reactor::run_tasks(seastar::reactor::task_queue&) at ./build/release/seastar/./seastar/src/core/reactor.cc:2590
(inlined by) seastar::reactor::run_some_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3053
seastar::reactor::do_run() at ./build/release/seastar/./seastar/src/core/reactor.cc:3222
operator() at ./build/release/seastar/./seastar/src/core/reactor.cc:4426
(inlined by) void std::__invoke_impl<void, seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_96&>(std::__invoke_other, seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_96&) at /usr/bin/../lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/bits/invoke.h:61
(inlined by) std::enable_if<is_invocable_r_v<void, seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_96&>, void>::type std::__invoke_r<void, seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_96&>(seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_96&) at /usr/bin/../lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/bits/invoke.h:111
(inlined by) std::_Function_handler<void (), seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_96>::_M_invoke(std::_Any_data const&) at /usr/bin/../lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/bits/std_function.h:290
std::function<void ()>::operator()() const at /usr/bin/../lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/bits/std_function.h:591
(inlined by) seastar::posix_thread::start_routine(void*) at ./build/release/seastar/./seastar/src/core/posix.cc:90
?? ??:0
?? ??:0
2023-07-03 12:45:55.611 <2023-07-03 12:45:55.000>: (DatabaseLogEvent Severity.ERROR) period_type=one-time event_id=efa9a1b9-b717-4afe-83a7-059a2ab4bf49: type=SEGMENTATION regex=segmentation line_number=17056 node=longevity-10gb-3h-master-db-node-996fb5c0-0-5
2023-07-03T12:45:55+00:00 longevity-10gb-3h-master-db-node-996fb5c0-0-5     !INFO | scylla[12611]: Segmentation fault on shard 2.
void seastar::backtrace<seastar::backtrace_buffer::append_backtrace()::{lambda(seastar::frame)#1}>(seastar::backtrace_buffer::append_backtrace()::{lambda(seastar::frame)#1}&&) at ./build/release/seastar/./seastar/include/seastar/util/backtrace.hh:64
(inlined by) seastar::backtrace_buffer::append_backtrace() at ./build/release/seastar/./seastar/src/core/reactor.cc:811
(inlined by) seastar::print_with_backtrace(seastar::backtrace_buffer&, bool) at ./build/release/seastar/./seastar/src/core/reactor.cc:841
seastar::print_with_backtrace(char const*, bool) at ./build/release/seastar/./seastar/src/core/reactor.cc:853
(inlined by) seastar::sigsegv_action() at ./build/release/seastar/./seastar/src/core/reactor.cc:3964
(inlined by) operator() at ./build/release/seastar/./seastar/src/core/reactor.cc:3945
(inlined by) __invoke at ./build/release/seastar/./seastar/src/core/reactor.cc:3941
?? ??:0
seastar::memory::small_pool::allocate() at ./build/release/seastar/./seastar/src/core/memory.cc:1263
(inlined by) seastar::memory::cpu_pages::allocate_small(unsigned int) at ./build/release/seastar/./seastar/src/core/memory.cc:875
(inlined by) seastar::memory::allocate(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:1424
operator new(unsigned long) at ./build/release/seastar/./seastar/src/core/memory.cc:2110
std::__new_allocator<std::__detail::_Hash_node<std::pair<utils::tagged_uuid<table_id_tag> const, service::cache_hitrate_calculator::stat>, false> >::allocate(unsigned long, void const*) at /usr/bin/../lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/bits/new_allocator.h:137
(inlined by) std::allocator<std::__detail::_Hash_node<std::pair<utils::tagged_uuid<table_id_tag> const, service::cache_hitrate_calculator::stat>, false> >::allocate(unsigned long) at /usr/bin/../lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/bits/allocator.h:188
(inlined by) std::allocator_traits<std::allocator<std::__detail::_Hash_node<std::pair<utils::tagged_uuid<table_id_tag> const, service::cache_hitrate_calculator::stat>, false> > >::allocate(std::allocator<std::__detail::_Hash_node<std::pair<utils::tagged_uuid<table_id_tag> const, service::cache_hitrate_calculator::stat>, false> >&, unsigned long) at /usr/bin/../lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/bits/alloc_traits.h:464
(inlined by) std::__detail::_Hash_node<std::pair<utils::tagged_uuid<table_id_tag> const, service::cache_hitrate_calculator::stat>, false>* std::__detail::_Hashtable_alloc<std::allocator<std::__detail::_Hash_node<std::pair<utils::tagged_uuid<table_id_tag> const, service::cache_hitrate_calculator::stat>, false> > >::_M_allocate_node<std::pair<utils::tagged_uuid<table_id_tag>, service::cache_hitrate_calculator::stat> >(std::pair<utils::tagged_uuid<table_id_tag>, service::cache_hitrate_calculator::stat>&&) at /usr/bin/../lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/bits/hashtable_policy.h:1963
(inlined by) _Scoped_node<std::pair<utils::tagged_uuid<table_id_tag>, service::cache_hitrate_calculator::stat> > at /usr/bin/../lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/bits/hashtable.h:308
(inlined by) std::pair<std::__detail::_Node_iterator<std::pair<utils::tagged_uuid<table_id_tag> const, service::cache_hitrate_calculator::stat>, false, false>, bool> std::_Hashtable<utils::tagged_uuid<table_id_tag>, std::pair<utils::tagged_uuid<table_id_tag> const, service::cache_hitrate_calculator::stat>, std::allocator<std::pair<utils::tagged_uuid<table_id_tag> const, service::cache_hitrate_calculator::stat> >, std::__detail::_Select1st, std::equal_to<utils::tagged_uuid<table_id_tag> >, std::hash<utils::tagged_uuid<table_id_tag> >, std::__detail::_Mod_range_hashing, std::__detail::_Default_ranged_hash, std::__detail::_Prime_rehash_policy, std::__detail::_Hashtable_traits<false, false, true> >::_M_emplace<std::pair<utils::tagged_uuid<table_id_tag>, service::cache_hitrate_calculator::stat> >(std::integral_constant<bool, true>, std::pair<utils::tagged_uuid<table_id_tag>, service::cache_hitrate_calculator::stat>&&) at /usr/bin/../lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/bits/hashtable.h:2063
(inlined by) std::pair<std::__detail::_Node_iterator<std::pair<utils::tagged_uuid<table_id_tag> const, service::cache_hitrate_calculator::stat>, false, false>, bool> std::__detail::_Insert<utils::tagged_uuid<table_id_tag>, std::pair<utils::tagged_uuid<table_id_tag> const, service::cache_hitrate_calculator::stat>, std::allocator<std::pair<utils::tagged_uuid<table_id_tag> const, service::cache_hitrate_calculator::stat> >, std::__detail::_Select1st, std::equal_to<utils::tagged_uuid<table_id_tag> >, std::hash<utils::tagged_uuid<table_id_tag> >, std::__detail::_Mod_range_hashing, std::__detail::_Default_ranged_hash, std::__detail::_Prime_rehash_policy, std::__detail::_Hashtable_traits<false, false, true>, false>::insert<std::pair<utils::tagged_uuid<table_id_tag>, service::cache_hitrate_calculator::stat>, void>(std::pair<utils::tagged_uuid<table_id_tag>, service::cache_hitrate_calculator::stat>&&) at /usr/bin/../lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/bits/hashtable_policy.h:1085
(inlined by) _Hashtable<boost::iterators::transform_iterator<(lambda at service/misc_services.cc:141:46), boost::iterators::filter_iterator<boost::range_detail::default_constructible_unary_fn_wrapper<(lambda at service/misc_services.cc:135:30), bool>, std::__detail::_Node_iterator<std::pair<const utils::tagged_uuid<table_id_tag>, seastar::lw_shared_ptr<replica::table> >, false, false> >, boost::use_default, boost::use_default> > at /usr/bin/../lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/bits/hashtable.h:1191
(inlined by) _Hashtable<boost::iterators::transform_iterator<(lambda at service/misc_services.cc:141:46), boost::iterators::filter_iterator<boost::range_detail::default_constructible_unary_fn_wrapper<(lambda at service/misc_services.cc:135:30), bool>, std::__detail::_Node_iterator<std::pair<const utils::tagged_uuid<table_id_tag>, seastar::lw_shared_ptr<replica::table> >, false, false> >, boost::use_default, boost::use_default> > at /usr/bin/../lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/bits/hashtable.h:568
(inlined by) unordered_map<boost::iterators::transform_iterator<(lambda at service/misc_services.cc:141:46), boost::iterators::filter_iterator<boost::range_detail::default_constructible_unary_fn_wrapper<(lambda at service/misc_services.cc:135:30), bool>, std::__detail::_Node_iterator<std::pair<const utils::tagged_uuid<table_id_tag>, seastar::lw_shared_ptr<replica::table> >, false, false> >, boost::use_default, boost::use_default> > at /usr/bin/../lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/bits/unordered_map.h:177
(inlined by) std::unordered_map<utils::tagged_uuid<table_id_tag>, service::cache_hitrate_calculator::stat, std::hash<utils::tagged_uuid<table_id_tag> >, std::equal_to<utils::tagged_uuid<table_id_tag> >, std::allocator<std::pair<utils::tagged_uuid<table_id_tag> const, service::cache_hitrate_calculator::stat> > > boost::copy_range<std::unordered_map<utils::tagged_uuid<table_id_tag>, service::cache_hitrate_calculator::stat, std::hash<utils::tagged_uuid<table_id_tag> >, std::equal_to<utils::tagged_uuid<table_id_tag> >, std::allocator<std::pair<utils::tagged_uuid<table_id_tag> const, service::cache_hitrate_calculator::stat> > >, boost::range_detail::transformed_range<service::cache_hitrate_calculator::recalculate_hitrates()::$_13::operator()(replica::database&) const::{lambda(std::pair<utils::tagged_uuid<table_id_tag>, seastar::lw_shared_ptr<replica::table> > const&)#1}, boost::range_detail::filtered_range<service::cache_hitrate_calculator::recalculate_hitrates()::$_12, std::unordered_map<utils::tagged_uuid<table_id_tag>, seastar::lw_shared_ptr<replica::table>, std::hash<utils::tagged_uuid<table_id_tag> >, std::equal_to<utils::tagged_uuid<table_id_tag> >, std::allocator<std::pair<utils::tagged_uuid<table_id_tag> const, seastar::lw_shared_ptr<replica::table> > > > > const> >(boost::range_detail::transformed_range<service::cache_hitrate_calculator::recalculate_hitrates()::$_13::operator()(replica::database&) const::{lambda(std::pair<utils::tagged_uuid<table_id_tag>, seastar::lw_shared_ptr<replica::table> > const&)#1}, boost::range_detail::filtered_range<service::cache_hitrate_calculator::recalculate_hitrates()::$_12, std::unordered_map<utils::tagged_uuid<table_id_tag>, seastar::lw_shared_ptr<replica::table>, std::hash<utils::tagged_uuid<table_id_tag> >, std::equal_to<utils::tagged_uuid<table_id_tag> >, std::allocator<std::pair<utils::tagged_uuid<table_id_tag> const, seastar::lw_shared_ptr<replica::table> > > > > const> const&) at /usr/include/boost/range/iterator_range_core.hpp:842
(inlined by) operator() at ./service/misc_services.cc:140
(inlined by) std::unordered_map<utils::tagged_uuid<table_id_tag>, service::cache_hitrate_calculator::stat, std::hash<utils::tagged_uuid<table_id_tag> >, std::equal_to<utils::tagged_uuid<table_id_tag> >, std::allocator<std::pair<utils::tagged_uuid<table_id_tag> const, service::cache_hitrate_calculator::stat> > > std::__invoke_impl<std::unordered_map<utils::tagged_uuid<table_id_tag>, service::cache_hitrate_calculator::stat, std::hash<utils::tagged_uuid<table_id_tag> >, std::equal_to<utils::tagged_uuid<table_id_tag> >, std::allocator<std::pair<utils::tagged_uuid<table_id_tag> const, service::cache_hitrate_calculator::stat> > >, service::cache_hitrate_calculator::recalculate_hitrates()::$_13 const&, replica::database&>(std::__invoke_other, service::cache_hitrate_calculator::recalculate_hitrates()::$_13 const&, replica::database&) at /usr/bin/../lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/bits/invoke.h:61
(inlined by) std::__invoke_result<service::cache_hitrate_calculator::recalculate_hitrates()::$_13 const&, replica::database&>::type std::__invoke<service::cache_hitrate_calculator::recalculate_hitrates()::$_13 const&, replica::database&>(service::cache_hitrate_calculator::recalculate_hitrates()::$_13 const&, replica::database&) at /usr/bin/../lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/bits/invoke.h:96
(inlined by) std::invoke_result<service::cache_hitrate_calculator::recalculate_hitrates()::$_13 const&, replica::database&>::type std::invoke<service::cache_hitrate_calculator::recalculate_hitrates()::$_13 const&, replica::database&>(service::cache_hitrate_calculator::recalculate_hitrates()::$_13 const&, replica::database&) at /usr/bin/../lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/functional:110
(inlined by) operator() at ././seastar/include/seastar/core/sharded.hh:397
seastar::future<std::unordered_map<utils::tagged_uuid<table_id_tag>, service::cache_hitrate_calculator::stat, std::hash<utils::tagged_uuid<table_id_tag> >, std::equal_to<utils::tagged_uuid<table_id_tag> >, std::allocator<std::pair<utils::tagged_uuid<table_id_tag> const, service::cache_hitrate_calculator::stat> > > > seastar::futurize<std::unordered_map<utils::tagged_uuid<table_id_tag>, service::cache_hitrate_calculator::stat, std::hash<utils::tagged_uuid<table_id_tag> >, std::equal_to<utils::tagged_uuid<table_id_tag> >, std::allocator<std::pair<utils::tagged_uuid<table_id_tag> const, service::cache_hitrate_calculator::stat> > > >::invoke<seastar::future<std::unordered_map<utils::tagged_uuid<table_id_tag>, service::cache_hitrate_calculator::stat, std::hash<utils::tagged_uuid<table_id_tag> >, std::equal_to<utils::tagged_uuid<table_id_tag> >, std::allocator<std::pair<utils::tagged_uuid<table_id_tag> const, service::cache_hitrate_calculator::stat> > > > seastar::sharded<replica::database>::map_reduce0<service::cache_hitrate_calculator::recalculate_hitrates()::$_13, std::unordered_map<utils::tagged_uuid<table_id_tag>, service::cache_hitrate_calculator::stat, std::hash<utils::tagged_uuid<table_id_tag> >, std::equal_to<utils::tagged_uuid<table_id_tag> >, std::allocator<std::pair<utils::tagged_uuid<table_id_tag> const, service::cache_hitrate_calculator::stat> > >, service::cache_hitrate_calculator::recalculate_hitrates()::$_14>(service::cache_hitrate_calculator::recalculate_hitrates()::$_13, std::unordered_map<utils::tagged_uuid<table_id_tag>, service::cache_hitrate_calculator::stat, std::hash<utils::tagged_uuid<table_id_tag> >, std::equal_to<utils::tagged_uuid<table_id_tag> >, std::allocator<std::pair<utils::tagged_uuid<table_id_tag> const, service::cache_hitrate_calculator::stat> > >, service::cache_hitrate_calculator::recalculate_hitrates()::$_14)::{lambda(unsigned int)#1}::operator()(unsigned int) const::{lambda()#1}&>(seastar::future<std::unordered_map<utils::tagged_uuid<table_id_tag>, service::cache_hitrate_calculator::stat, std::hash<utils::tagged_uuid<table_id_tag> >, std::equal_to<utils::tagged_uuid<table_id_tag> >, std::allocator<std::pair<utils::tagged_uuid<table_id_tag> const, service::cache_hitrate_calculator::stat> > > > seastar::sharded<replica::database>::map_reduce0<service::cache_hitrate_calculator::recalculate_hitrates()::$_13, std::unordered_map<utils::tagged_uuid<table_id_tag>, service::cache_hitrate_calculator::stat, std::hash<utils::tagged_uuid<table_id_tag> >, std::equal_to<utils::tagged_uuid<table_id_tag> >, std::allocator<std::pair<utils::tagged_uuid<table_id_tag> const, service::cache_hitrate_calculator::stat> > >, service::cache_hitrate_calculator::recalculate_hitrates()::$_14>(service::cache_hitrate_calculator::recalculate_hitrates()::$_13, std::unordered_map<utils::tagged_uuid<table_id_tag>, service::cache_hitrate_calculator::stat, std::hash<utils::tagged_uuid<table_id_tag> >, std::equal_to<utils::tagged_uuid<table_id_tag> >, std::allocator<std::pair<utils::tagged_uuid<table_id_tag> const, service::cache_hitrate_calculator::stat> > >, service::cache_hitrate_calculator::recalculate_hitrates()::$_14)::{lambda(unsigned int)#1}::operator()(unsigned int) const::{lambda()#1}&) at ././seastar/include/seastar/core/future.hh:2008
(inlined by) seastar::smp_message_queue::async_work_item<seastar::future<std::unordered_map<utils::tagged_uuid<table_id_tag>, service::cache_hitrate_calculator::stat, std::hash<utils::tagged_uuid<table_id_tag> >, std::equal_to<utils::tagged_uuid<table_id_tag> >, std::allocator<std::pair<utils::tagged_uuid<table_id_tag> const, service::cache_hitrate_calculator::stat> > > > seastar::sharded<replica::database>::map_reduce0<service::cache_hitrate_calculator::recalculate_hitrates()::$_13, std::unordered_map<utils::tagged_uuid<table_id_tag>, service::cache_hitrate_calculator::stat, std::hash<utils::tagged_uuid<table_id_tag> >, std::equal_to<utils::tagged_uuid<table_id_tag> >, std::allocator<std::pair<utils::tagged_uuid<table_id_tag> const, service::cache_hitrate_calculator::stat> > >, service::cache_hitrate_calculator::recalculate_hitrates()::$_14>(service::cache_hitrate_calculator::recalculate_hitrates()::$_13, std::unordered_map<utils::tagged_uuid<table_id_tag>, service::cache_hitrate_calculator::stat, std::hash<utils::tagged_uuid<table_id_tag> >, std::equal_to<utils::tagged_uuid<table_id_tag> >, std::allocator<std::pair<utils::tagged_uuid<table_id_tag> const, service::cache_hitrate_calculator::stat> > >, service::cache_hitrate_calculator::recalculate_hitrates()::$_14)::{lambda(unsigned int)#1}::operator()(unsigned int) const::{lambda()#1}>::run_and_dispose() at ././seastar/include/seastar/core/smp.hh:255
seastar::reactor::run_tasks(seastar::reactor::task_queue&) at ./build/release/seastar/./seastar/src/core/reactor.cc:2590
(inlined by) seastar::reactor::run_some_tasks() at ./build/release/seastar/./seastar/src/core/reactor.cc:3053
seastar::reactor::do_run() at ./build/release/seastar/./seastar/src/core/reactor.cc:3222
operator() at ./build/release/seastar/./seastar/src/core/reactor.cc:4426
(inlined by) void std::__invoke_impl<void, seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_96&>(std::__invoke_other, seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_96&) at /usr/bin/../lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/bits/invoke.h:61
(inlined by) std::enable_if<is_invocable_r_v<void, seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_96&>, void>::type std::__invoke_r<void, seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_96&>(seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_96&) at /usr/bin/../lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/bits/invoke.h:111
(inlined by) std::_Function_handler<void (), seastar::smp::configure(seastar::smp_options const&, seastar::reactor_options const&)::$_96>::_M_invoke(std::_Any_data const&) at /usr/bin/../lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/bits/std_function.h:290
std::function<void ()>::operator()() const at /usr/bin/../lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/bits/std_function.h:591
(inlined by) seastar::posix_thread::start_routine(void*) at ./build/release/seastar/./seastar/src/core/posix.cc:90
?? ??:0
?? ??:0
  • This issue is a regression.
  • It is unknown if this issue is a regression.

Describe your issue in detail and steps it took to produce it.

Impact

Describe the impact this issue causes to the user.

How frequently does it reproduce?

Describe the frequency with how this issue can be reproduced.

Installation details

Kernel Version: 5.15.0-1037-gcp
Scylla version (or git commit hash): 5.4.0~dev-20230703.1ab2bb69b8a6 with build-id 1054adfa55f238441c3044e6213fd02d31d43279

Cluster size: 6 nodes (n1-highmem-16)

Scylla Nodes used in this run:

  • longevity-10gb-3h-master-db-node-996fb5c0-0-9 (35.243.198.190 | 10.142.0.15) (shards: 14)
  • longevity-10gb-3h-master-db-node-996fb5c0-0-8 (35.229.77.142 | 10.142.0.6) (shards: 14)
  • longevity-10gb-3h-master-db-node-996fb5c0-0-7 (35.185.4.246 | 10.142.0.5) (shards: 14)
  • longevity-10gb-3h-master-db-node-996fb5c0-0-6 (35.229.91.148 | 10.142.0.106) (shards: 14)
  • longevity-10gb-3h-master-db-node-996fb5c0-0-5 (35.237.89.13 | 10.142.0.100) (shards: 14)
  • longevity-10gb-3h-master-db-node-996fb5c0-0-4 (34.148.210.57 | 10.142.0.99) (shards: 14)
  • longevity-10gb-3h-master-db-node-996fb5c0-0-3 (34.74.154.210 | 10.142.0.97) (shards: 14)
  • longevity-10gb-3h-master-db-node-996fb5c0-0-2 (35.231.54.136 | 10.142.0.95) (shards: 14)
  • longevity-10gb-3h-master-db-node-996fb5c0-0-11 (34.73.193.43 | 10.142.0.25) (shards: 14)
  • longevity-10gb-3h-master-db-node-996fb5c0-0-10 (35.196.155.42 | 10.142.0.81) (shards: 14)
  • longevity-10gb-3h-master-db-node-996fb5c0-0-1 (34.138.92.218 | 10.142.0.91) (shards: 14)

OS / Image: `` (gce: undefined_region)

Test: longevity-10gb-3h-gce-test
Test id: 996fb5c0-da43-41b1-9a72-4b1ee54f4fac
Test name: scylla-master/longevity/longevity-10gb-3h-gce-test
Test config file(s):

Logs and commands
  • Restore Monitor Stack command: $ hydra investigate show-monitor 996fb5c0-da43-41b1-9a72-4b1ee54f4fac
  • Restore monitor on AWS instance using Jenkins job
  • Show all stored logs command: $ hydra investigate show-logs 996fb5c0-da43-41b1-9a72-4b1ee54f4fac

Logs:

Jenkins job URL
Argus

@michoecho
Copy link
Contributor

This is a memory corruption bug, so I'm setting P1.

@michoecho
Copy link
Contributor

michoecho commented Jul 11, 2023

I looked at 3 out of 4 cores. In all cases the 32-byte small pool is corrupted. Its _free pointer holds some misaligned garbage.

It appears that either free was called with a wrong address (pointing inside some live memory in the pool, but misaligned) or a pointer to such address was written to a freed slot (either due to use-after-free or due to buffer overflow).

But the crashes happen in unrelated code paths. It seems that the corruption happened some time before the crash and its source won't be easily figured out from the dump.

But since it happened on multiple nodes at once, it's likely reproducible, and we could bisect it.

@avikivity
Copy link
Member

Misaligned pointers can happen when we have a seastar shared pointer that crossed shards. This can causes an early free, or a wild increment or decrement that can hit something.

@avikivity
Copy link
Member

This is a memory corruption bug, so I'm setting P1.

Absolutely

@avikivity
Copy link
Member

We can try a version that has SEASTAR_DEBUG_SHARED_PTR set, if it indeed looks like this sort of bug.

@avikivity avikivity changed the title "Segmentation fault on shard 2" on 4 nodes after nodetool refresh memory corruption - "Segmentation fault on shard 2" on 4 nodes after nodetool refresh Jul 11, 2023
@michoecho
Copy link
Contributor

Misaligned pointers can happen when we have a seastar shared pointer that crossed shards. This can causes an early free, or a wild increment or decrement that can hit something.

Wow, it really is a wild decrement. I verified this by reconstructing the presumed true head of the free list from the garbage, and following it until the end. The length of this list is consistent with the length written down in small_pool.

In other words, there are some wild decrements-after-free. (In 2/3 cores the wild decrement happened once, in 1/3 cores the decrement happened thrice.)

But I'm not sure if I see how cross-sharded seastar shared pointers explain this. Do you mean their non-atomic crements? It would explain what we see, but isn't it unlikely (although totally possible) that their made the count off by 3?

@raphaelsc
Copy link
Member

seems a duplicate of #14475 (comment)

@avikivity
Copy link
Member

avikivity commented Jul 11, 2023

We've seen it (wild decrements due to badly shared pointers) multiple times.

@avikivity
Copy link
Member

seems a duplicate of #14475 (comment)

Yes

@raphaelsc
Copy link
Member

my gut feeling is that this is a recent regression.

@avikivity
Copy link
Member

For sure

@michoecho
Copy link
Contributor

@raphaelsc
Copy link
Member

that's indeed a good candidate.

lw shared ptr doesn't use atomic for refcounting, so it's susceptible to races.

@avikivity
Copy link
Member

Well that's deleted code.

I think it's unlikely since resharding likely since resharding happens during nodetool refresh.

@avikivity
Copy link
Member

Could be tested by forcing a reshard with a debug build.

@avikivity
Copy link
Member

/cc @Deexie

@michoecho
Copy link
Contributor

Well that's deleted code.

I think it's unlikely since resharding likely since resharding happens during nodetool refresh.

That deleted code made a local copy of lw_shared_ptr's contents. After it was deleted, remote shards copy the foreign lw_shared_ptr instead, which is exactly the problem we are looking for.

@avikivity
Copy link
Member

But I don't see anything wrong there. The shared_ptr doesn't come from the caller shard or is leaked back into it.

@avikivity
Copy link
Member

Yes

@avikivity
Copy link
Member

@michoecho please file a revert pull request with this analysis.

@michoecho
Copy link
Contributor

Revert? Or just fix the bug by making a local copy of the vector, as it was before the bad patch?

michoecho added a commit to michoecho/scylla that referenced this issue Jul 11, 2023
This reverts commit 2a58b4a, reversing
changes made to dd63169.

After patch 87c8d63,
table_resharding_compaction_task_impl::run() performs the forbidden
action of copying a lw_shared_ptr (_owned_ranges_ptr) on a remote shard,
which is a data race that can cause a use-after-free, typically manifesting
as allocator corruption.

Note: before the bad patch, this was avoided by copying the _contents_ of the
lw_shared_ptr into a new, local lw_shared_ptr.

Fixes scylladb#14475
Fixes scylladb#14618
@michoecho
Copy link
Contributor

Okay, you said "revert", so revert it is: #14641

I'll leave the pleasure of fixing the new code to @Deexie.

Deexie added a commit to Deexie/scylla that referenced this issue Jul 11, 2023
table_resharding_compaction_task_impl::run() performs the forbidden
action of copying a lw_shared_ptr (_owned_ranges_ptr) on a remote
shard, which is a data race that can cause a use-after-free, typically
manifesting as allocator corruption.

Content of _owned_ranges_ptr is copied to local lw_shared_ptrs.

Fixes scylladb#14475
Fixes scylladb#14618
@DoronArazii DoronArazii added this to the 5.4 milestone Jul 11, 2023
@raphaelsc
Copy link
Member

Could be tested by forcing a reshard with a debug build.

we need reshard on refresh as the owned ranges must be propagated

I think we can even make this a py test in core

denesb added a commit that referenced this issue Jul 20, 2023
Task manager tasks covering reshard compaction.

Reattempt on #14044. Bugfix for #14618 is squashed with 95191f4.
Regression test added.

Closes #14739

* github.com:scylladb/scylladb:
  test: add test for resharding with non-empty owned_ranges_ptr
  test: extend test_compaction_task.py to test resharding compaction
  compaction: add shard_reshard_sstables_compaction_task_impl
  compaction: invoke resharding on sharded database
  compaction: move run_resharding_jobs into reshard_sstables_compaction_task_impl::run()
  compaction: add reshard_sstables_compaction_task_impl
  compaction: create resharding_compaction_task_impl
@avikivity
Copy link
Member

No vulnerable branches, not backporting.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment