Fix missing include for schema.hh in system0_virtual_tables.cc

Co-authored-by: tgrabiec <283695+tgrabiec@users.noreply.github.com>

.github/CODEOWNERS

@@ -57,6 +57,7 @@ repair/* @tgrabiec @asias
 
 # SCHEMA MANAGEMENT
 db/schema_tables* @tgrabiec
+db/legacy_schema_migrator* @tgrabiec
 service/migration* @tgrabiec
 schema* @tgrabiec
 

alternator/executor.cc

@@ -2223,12 +2223,12 @@ void validate_value(const rjson::value& v, const char* caller) {
 
 // The put_or_delete_item class builds the mutations needed by the PutItem and
 // DeleteItem operations - either as stand-alone commands or part of a list
-// of commands in BatchWriteItem.
+// of commands in BatchWriteItems.
 // put_or_delete_item splits each operation into two stages: Constructing the
 // object parses and validates the user input (throwing exceptions if there
 // are input errors). Later, build() generates the actual mutation, with a
 // specified timestamp. This split is needed because of the peculiar needs of
-// BatchWriteItem and LWT. BatchWriteItem needs all parsing to happen before
+// BatchWriteItems and LWT. BatchWriteItems needs all parsing to happen before
 // any writing happens (if one of the commands has an error, none of the
 // writes should be done). LWT makes it impossible for the parse step to
 // generate "mutation" objects, because the timestamp still isn't known.
@@ -2739,7 +2739,7 @@ future<executor::request_return_type> rmw_operation::execute(service::storage_pr
     auto read_command = needs_read_before_write ?
             previous_item_read_command(proxy, schema(), _ck, selection) :
             nullptr;
-    return proxy.cas(schema(), std::move(*cas_shard), *this, read_command, to_partition_ranges(*schema(), _pk),
+    return proxy.cas(schema(), std::move(*cas_shard), shared_from_this(), read_command, to_partition_ranges(*schema(), _pk),
             {timeout, std::move(permit), client_state, trace_state},
             db::consistency_level::LOCAL_SERIAL, db::consistency_level::LOCAL_QUORUM, timeout, timeout, true, std::move(cdc_opts)).then([this, read_command, &wcu_total] (bool is_applied) mutable {
         if (!is_applied) {
@@ -3026,20 +3026,17 @@ struct primary_key_equal {
 };
 
 // This is a cas_request subclass for applying given put_or_delete_items to
-// one partition using LWT as part as BatchWriteItem. This is a write-only
+// one partition using LWT as part as BatchWriteItems. This is a write-only
 // operation, not needing the previous value of the item (the mutation to be
 // done is known prior to starting the operation). Nevertheless, we want to
 // do this mutation via LWT to ensure that it is serialized with other LWT
 // mutations to the same partition.
-// 
-// The std::vector<put_or_delete_item> must remain alive until the
-// storage_proxy::cas() future is resolved.
 class put_or_delete_item_cas_request : public service::cas_request {
     schema_ptr schema;
-    const std::vector<put_or_delete_item>& _mutation_builders;
+    std::vector<put_or_delete_item> _mutation_builders;
 public:
-    put_or_delete_item_cas_request(schema_ptr s, const std::vector<put_or_delete_item>& b) :
-        schema(std::move(s)), _mutation_builders(b) { }
+    put_or_delete_item_cas_request(schema_ptr s, std::vector<put_or_delete_item>&& b) :
+        schema(std::move(s)), _mutation_builders(std::move(b)) { }
     virtual ~put_or_delete_item_cas_request() = default;
     virtual std::optional<mutation> apply(foreign_ptr<lw_shared_ptr<query::result>> qr, const query::partition_slice& slice, api::timestamp_type ts, cdc::per_request_options& cdc_opts) override {
         std::optional<mutation> ret;
@@ -3055,21 +3052,20 @@ public:
     }
 };
 
-static future<> cas_write(service::storage_proxy& proxy, schema_ptr schema, service::cas_shard cas_shard, const dht::decorated_key& dk, const std::vector<put_or_delete_item>& mutation_builders,
+static future<> cas_write(service::storage_proxy& proxy, schema_ptr schema, service::cas_shard cas_shard, dht::decorated_key dk, std::vector<put_or_delete_item>&& mutation_builders,
         service::client_state& client_state, tracing::trace_state_ptr trace_state, service_permit permit) {
     auto timeout = executor::default_timeout();
-    auto op = std::make_unique<put_or_delete_item_cas_request>(schema, mutation_builders);
-    auto* op_ptr = op.get();
+    auto op = seastar::make_shared<put_or_delete_item_cas_request>(schema, std::move(mutation_builders));
     auto cdc_opts = cdc::per_request_options{
         .alternator = true,
         .alternator_streams_increased_compatibility =
                 schema->cdc_options().enabled() && proxy.data_dictionary().get_config().alternator_streams_increased_compatibility(),
     };
-    return proxy.cas(schema, std::move(cas_shard), *op_ptr, nullptr, to_partition_ranges(dk),
+    return proxy.cas(schema, std::move(cas_shard), op, nullptr, to_partition_ranges(dk),
             {timeout, std::move(permit), client_state, trace_state},
             db::consistency_level::LOCAL_SERIAL, db::consistency_level::LOCAL_QUORUM,
-            timeout, timeout, true, std::move(cdc_opts)).finally([op = std::move(op)]{}).discard_result();
-    // We discarded cas()'s future value ("is_applied") because BatchWriteItem
+            timeout, timeout, true, std::move(cdc_opts)).discard_result();
+    // We discarded cas()'s future value ("is_applied") because BatchWriteItems
     // does not need to support conditional updates.
 }
 
@@ -3135,34 +3131,30 @@ static future<> do_batch_write(service::storage_proxy& proxy,
         // Multiple mutations may be destined for the same partition, adding
         // or deleting different items of one partition. Join them together
         // because we can do them in one cas() call.
-        using map_type = std::unordered_map<schema_decorated_key, 
-            std::vector<put_or_delete_item>, 
-            schema_decorated_key_hash, 
-            schema_decorated_key_equal>;
-        auto key_builders = std::make_unique<map_type>(1, schema_decorated_key_hash{}, schema_decorated_key_equal{});
+        std::unordered_map<schema_decorated_key, std::vector<put_or_delete_item>, schema_decorated_key_hash, schema_decorated_key_equal>
+            key_builders(1, schema_decorated_key_hash{}, schema_decorated_key_equal{});
         for (auto& b : mutation_builders) {
             auto dk = dht::decorate_key(*b.first, b.second.pk());
-            auto [it, added] = key_builders->try_emplace(schema_decorated_key{b.first, dk});
+            auto [it, added] = key_builders.try_emplace(schema_decorated_key{b.first, dk});
             it->second.push_back(std::move(b.second));
         }
-        auto* key_builders_ptr = key_builders.get();
-        return parallel_for_each(*key_builders_ptr, [&proxy, &client_state, &stats, trace_state, ssg, permit = std::move(permit)] (const auto& e) {
+        return parallel_for_each(std::move(key_builders), [&proxy, &client_state, &stats, trace_state, ssg, permit = std::move(permit)] (auto& e) {
             stats.write_using_lwt++;
             auto desired_shard = service::cas_shard(*e.first.schema, e.first.dk.token());
             if (desired_shard.this_shard()) {
-                return cas_write(proxy, e.first.schema, std::move(desired_shard), e.first.dk, e.second, client_state, trace_state, permit);
+                return cas_write(proxy, e.first.schema, std::move(desired_shard), e.first.dk, std::move(e.second), client_state, trace_state, permit);
             } else {
                 stats.shard_bounce_for_lwt++;
                 return proxy.container().invoke_on(desired_shard.shard(), ssg,
                             [cs = client_state.move_to_other_shard(),
-                             &mb = e.second,
-                             &dk = e.first.dk,
+                             mb = e.second,
+                             dk = e.first.dk,
                              ks = e.first.schema->ks_name(),
                              cf = e.first.schema->cf_name(),
                              gt =  tracing::global_trace_state_ptr(trace_state),
                              permit = std::move(permit)]
                             (service::storage_proxy& proxy) mutable {
-                    return do_with(cs.get(), [&proxy, &mb, &dk, ks = std::move(ks), cf = std::move(cf),
+                    return do_with(cs.get(), [&proxy, mb = std::move(mb), dk = std::move(dk), ks = std::move(ks), cf = std::move(cf),
                                               trace_state = tracing::trace_state_ptr(gt)]
                                               (service::client_state& client_state) mutable {
                         auto schema = proxy.data_dictionary().find_schema(ks, cf);
@@ -3176,11 +3168,11 @@ static future<> do_batch_write(service::storage_proxy& proxy,
                         //FIXME: Instead of passing empty_service_permit() to the background operation,
                         // the current permit's lifetime should be prolonged, so that it's destructed
                         // only after all background operations are finished as well.
-                        return cas_write(proxy, schema, std::move(cas_shard), dk, mb, client_state, std::move(trace_state), empty_service_permit());
+                        return cas_write(proxy, schema, std::move(cas_shard), dk, std::move(mb), client_state, std::move(trace_state), empty_service_permit());
                     });
                 }).finally([desired_shard = std::move(desired_shard)]{});
             }
-        }).finally([key_builders = std::move(key_builders)]{});
+        });
     }
 }
 

api/api-doc/task_manager.json

@@ -349,13 +349,9 @@
                "type":"long",
                "description":"The shard the task is running on"
             },
-            "creation_time":{
-               "type":"datetime",
-               "description":"The creation time of the task (when it was queued); extracted from the task_id UUID"
-            },
             "start_time":{
                "type":"datetime",
-               "description":"The start time of the task (when execution began); unspecified (equal to epoch) when state == created"
+               "description":"The start time of the task; unspecified (equal to epoch) when state == created"
             },
             "end_time":{
                "type":"datetime",
@@ -402,17 +398,13 @@
                "type":"boolean",
                "description":"Boolean flag indicating whether the task can be aborted"
             },
-            "creation_time":{
-               "type":"datetime",
-               "description":"The creation time of the task (when it was queued); extracted from the task_id UUID"
-            },
             "start_time":{
                "type":"datetime",
-               "description":"The start time of the task (when execution began); unspecified (equal to epoch) when state == created"
+               "description":"The start time of the task"
             },
             "end_time":{
                "type":"datetime",
-               "description":"The end time of the task (when execution completed); unspecified (equal to epoch) when the task is not completed"
+               "description":"The end time of the task (unspecified when the task is not completed)"
             },
             "error":{
                "type":"string",

api/task_manager.cc

@@ -55,7 +55,6 @@ tm::task_status make_status(tasks::task_status status, sharded<gms::gossiper>& g
     res.scope = status.scope;
     res.state = status.state;
     res.is_abortable = bool(status.is_abortable);
-    res.creation_time = get_time(status.creation_time);
     res.start_time = get_time(status.start_time);
     res.end_time = get_time(status.end_time);
     res.error = status.error;
@@ -84,7 +83,6 @@ tm::task_stats make_stats(tasks::task_stats stats) {
     res.table = stats.table;
     res.entity = stats.entity;
     res.shard = stats.shard;
-    res.creation_time = get_time(stats.creation_time);
     res.start_time = get_time(stats.start_time);
     res.end_time = get_time(stats.end_time);;
     return res;

auth/certificate_authenticator.cc

@@ -8,7 +8,6 @@
  */
 
 #include "auth/certificate_authenticator.hh"
-#include "auth/cache.hh"
 
 #include <boost/regex.hpp>
 #include <fmt/ranges.h>
@@ -35,14 +34,13 @@ static const class_registrator<auth::authenticator
     , cql3::query_processor&
     , ::service::raft_group0_client&
     , ::service::migration_manager&
-    , auth::cache&
     , utils::alien_worker&> cert_auth_reg(CERT_AUTH_NAME);
 
 enum class auth::certificate_authenticator::query_source {
     subject, altname
 };
 
-auth::certificate_authenticator::certificate_authenticator(cql3::query_processor& qp, ::service::raft_group0_client&, ::service::migration_manager&, auth::cache&, utils::alien_worker&)
+auth::certificate_authenticator::certificate_authenticator(cql3::query_processor& qp, ::service::raft_group0_client&, ::service::migration_manager&, utils::alien_worker&)
     : _queries([&] {
         auto& conf = qp.db().get_config();
         auto queries = conf.auth_certificate_role_queries();

auth/certificate_authenticator.hh

@@ -26,15 +26,13 @@ class raft_group0_client;
 
 namespace auth {
 
-class cache;
-
 extern const std::string_view certificate_authenticator_name;
 
 class certificate_authenticator : public authenticator {
     enum class query_source;
     std::vector<std::pair<query_source, boost::regex>> _queries;
 public:
-    certificate_authenticator(cql3::query_processor&, ::service::raft_group0_client&, ::service::migration_manager&, cache&, utils::alien_worker&);
+    certificate_authenticator(cql3::query_processor&, ::service::raft_group0_client&, ::service::migration_manager&, utils::alien_worker&);
     ~certificate_authenticator();
 
     future<> start() override;

configure.py

@@ -1062,6 +1062,7 @@ scylla_core = (['message/messaging_service.cc',
                 'db/hints/resource_manager.cc',
                 'db/hints/sync_point.cc',
                 'db/large_data_handler.cc',
+                'db/legacy_schema_migrator.cc',
                 'db/marshal/type_parser.cc',
                 'db/per_partition_rate_limit_options.cc',
                 'db/rate_limiter.cc',
@@ -1084,6 +1085,7 @@ scylla_core = (['message/messaging_service.cc',
                 'db/view/view_building_task_mutation_builder.cc',
                 'db/virtual_table.cc',
                 'db/virtual_tables.cc',
+                'db/system0_virtual_tables.cc',
                 'db/tablet_options.cc',
                 'db/object_storage_endpoint_param.cc',
                 'index/secondary_index_manager.cc',

cql3/statements/alter_keyspace_statement.cc

@@ -165,7 +165,8 @@ cql3::statements::alter_keyspace_statement::prepare_schema_mutations(query_proce
 
             service::topology_mutation_builder builder(ts);
             service::topology_request_tracking_mutation_builder rtbuilder{global_request_id, qp.proxy().features().topology_requests_type_column};
-            rtbuilder.set("done", false);
+            rtbuilder.set("done", false)
+                     .set("start_time", db_clock::now());
             if (!qp.proxy().features().topology_global_request_queue) {
                 builder.set_global_topology_request(service::global_topology_request::keyspace_rf_change);
                 builder.set_global_topology_request_id(global_request_id);

cql3/statements/batch_statement.cc

@@ -331,7 +331,7 @@ future<shared_ptr<cql_transport::messages::result_message>> batch_statement::exe
     if (!cl_for_paxos) [[unlikely]] {
         return make_exception_future<shared_ptr<cql_transport::messages::result_message>>(std::move(cl_for_paxos).assume_error());
     }
-    std::unique_ptr<cas_request> request;
+    seastar::shared_ptr<cas_request> request;
     schema_ptr schema;
 
     db::timeout_clock::time_point now = db::timeout_clock::now();
@@ -354,9 +354,9 @@ future<shared_ptr<cql_transport::messages::result_message>> batch_statement::exe
         if (keys.empty()) {
             continue;
         }
-        if (!request) {
+        if (request.get() == nullptr) {
             schema = statement.s;
-            request = std::make_unique<cas_request>(schema, std::move(keys));
+            request = seastar::make_shared<cas_request>(schema, std::move(keys));
         } else if (keys.size() != 1 || keys.front().equal(request->key().front(), dht::ring_position_comparator(*schema)) == false) {
             throw exceptions::invalid_request_exception("BATCH with conditions cannot span multiple partitions");
         }
@@ -366,7 +366,7 @@ future<shared_ptr<cql_transport::messages::result_message>> batch_statement::exe
 
         request->add_row_update(statement, std::move(ranges), std::move(json_cache), statement_options);
     }
-    if (!request) {
+    if (request.get() == nullptr) {
         throw exceptions::invalid_request_exception(format("Unrestricted partition key in a conditional BATCH"));
     }
 
@@ -377,10 +377,9 @@ future<shared_ptr<cql_transport::messages::result_message>> batch_statement::exe
             );
     }
 
-    auto* request_ptr = request.get();
-    return qp.proxy().cas(schema, std::move(cas_shard), *request_ptr, request->read_command(qp), request->key(),
+    return qp.proxy().cas(schema, std::move(cas_shard), request, request->read_command(qp), request->key(),
             {read_timeout, qs.get_permit(), qs.get_client_state(), qs.get_trace_state()},
-            std::move(cl_for_paxos).assume_value(), cl_for_learn, batch_timeout, cas_timeout).then([this, request = std::move(request)] (bool is_applied) {
+            std::move(cl_for_paxos).assume_value(), cl_for_learn, batch_timeout, cas_timeout).then([this, request] (bool is_applied) {
         return request->build_cas_result_set(_metadata, _columns_of_cas_result_set, is_applied);
     });
 }

cql3/statements/modification_statement.cc

@@ -401,8 +401,7 @@ modification_statement::execute_with_condition(query_processor& qp, service::que
                     type.is_update() ? "update" : "deletion"));
     }
 
-    auto request = std::make_unique<cas_request>(s, std::move(keys));
-    auto* request_ptr = request.get();
+    auto request = seastar::make_shared<cas_request>(s, std::move(keys));
     // cas_request can be used for batches as well single statements; Here we have just a single
     // modification in the list of CAS commands, since we're handling single-statement execution.
     request->add_row_update(*this, std::move(ranges), std::move(json_cache), options);
@@ -428,9 +427,9 @@ modification_statement::execute_with_condition(query_processor& qp, service::que
         tablet_info = erm->check_locality(token);
     }
 
-    return qp.proxy().cas(s, std::move(cas_shard), *request_ptr, request->read_command(qp), request->key(),
+    return qp.proxy().cas(s, std::move(cas_shard), request, request->read_command(qp), request->key(),
             {read_timeout, qs.get_permit(), qs.get_client_state(), qs.get_trace_state()},
-            std::move(cl_for_paxos).assume_value(), cl_for_learn, statement_timeout, cas_timeout).then([this, request = std::move(request), tablet_replicas = std::move(tablet_info->tablet_replicas), token_range = tablet_info->token_range] (bool is_applied) {
+            std::move(cl_for_paxos).assume_value(), cl_for_learn, statement_timeout, cas_timeout).then([this, request, tablet_replicas = std::move(tablet_info->tablet_replicas), token_range = tablet_info->token_range] (bool is_applied) {
         auto result = request->build_cas_result_set(_metadata, _columns_of_cas_result_set, is_applied);
         result->add_tablet_info(tablet_replicas, token_range);
         return result;

db/CMakeLists.txt

@@ -10,6 +10,7 @@ target_sources(db
     schema_applier.cc
     schema_tables.cc
     cql_type_parser.cc
+    legacy_schema_migrator.cc
     commitlog/commitlog.cc
     commitlog/commitlog_replayer.cc
     commitlog/commitlog_entry.cc

db/legacy_schema_migrator.cc

@@ -0,0 +1,602 @@
+/*
+ * Modified by ScyllaDB
+ * Copyright (C) 2017-present ScyllaDB
+ */
+
+/*
+ * SPDX-License-Identifier: (LicenseRef-ScyllaDB-Source-Available-1.0 and Apache-2.0)
+ */
+
+// Since Scylla 2.0, we use system tables whose schemas were introduced in
+// Cassandra 3. If Scylla boots to find a data directory with system tables
+// with older schemas - produced by pre-2.0 Scylla or by pre-3.0 Cassandra,
+// we need to migrate these old tables to the new format.
+//
+// We provide here a function, db::legacy_schema_migrator::migrate(),
+// for a one-time migration from old to new system tables. The function
+// reads old system tables, write them back in the new format, and finally
+// delete the old system tables. Scylla's main should call this function and
+// wait for the returned future, before starting to serve the database.
+
+#include <boost/iterator/filter_iterator.hpp>
+#include <seastar/core/future-util.hh>
+#include <seastar/util/log.hh>
+#include <map>
+#include <unordered_set>
+#include <chrono>
+
+#include "replica/database.hh"
+#include "legacy_schema_migrator.hh"
+#include "system_keyspace.hh"
+#include "schema_tables.hh"
+#include "schema/schema_builder.hh"
+#include "service/storage_proxy.hh"
+#include "utils/rjson.hh"
+#include "cql3/query_processor.hh"
+#include "cql3/untyped_result_set.hh"
+#include "cql3/util.hh"
+#include "cql3/statements/property_definitions.hh"
+
+static seastar::logger mlogger("legacy_schema_migrator");
+
+namespace db {
+namespace legacy_schema_migrator {
+
+// local data carriers
+
+class migrator {
+public:
+    static const std::unordered_set<sstring> legacy_schema_tables;
+
+    migrator(sharded<service::storage_proxy>& sp, sharded<replica::database>& db, sharded<db::system_keyspace>& sys_ks, cql3::query_processor& qp)
+                    : _sp(sp), _db(db), _sys_ks(sys_ks), _qp(qp) {
+    }
+    migrator(migrator&&) = default;
+
+    typedef db_clock::time_point time_point;
+
+    // TODO: we don't support triggers.
+    // this is a placeholder.
+    struct trigger {
+        time_point timestamp;
+        sstring name;
+        std::unordered_map<sstring, sstring> options;
+    };
+
+    struct table {
+        time_point timestamp;
+        schema_ptr metadata;
+        std::vector<trigger> triggers;
+    };
+
+    struct type {
+        time_point timestamp;
+        user_type metadata;
+    };
+
+    struct function {
+        time_point timestamp;
+        sstring ks_name;
+        sstring fn_name;
+        std::vector<sstring> arg_names;
+        std::vector<sstring> arg_types;
+        sstring return_type;
+        bool called_on_null_input;
+        sstring language;
+        sstring body;
+    };
+
+    struct aggregate {
+        time_point timestamp;
+        sstring ks_name;
+        sstring fn_name;
+        std::vector<sstring> arg_names;
+        std::vector<sstring> arg_types;
+        sstring return_type;
+        sstring final_func;
+        sstring initcond;
+        sstring state_func;
+        sstring state_type;
+    };
+
+    struct keyspace {
+        time_point timestamp;
+        sstring name;
+        bool durable_writes;
+        std::map<sstring, sstring> replication_params;
+
+        std::vector<table> tables;
+        std::vector<type> types;
+        std::vector<function> functions;
+        std::vector<aggregate> aggregates;
+    };
+
+    class unsupported_feature : public std::runtime_error {
+    public:
+        using runtime_error::runtime_error;
+    };
+
+    static sstring fmt_query(const char* fmt, const char* table) {
+        return fmt::format(fmt::runtime(fmt), db::system_keyspace::NAME, table);
+    }
+
+    typedef ::shared_ptr<cql3::untyped_result_set> result_set_type;
+    typedef const cql3::untyped_result_set::row row_type;
+
+    future<> read_table(keyspace& dst, sstring cf_name, time_point timestamp) {
+        auto fmt = "SELECT * FROM {}.{} WHERE keyspace_name = ? AND columnfamily_name = ?";
+        auto tq = fmt_query(fmt, db::system_keyspace::legacy::COLUMNFAMILIES);
+        auto cq = fmt_query(fmt, db::system_keyspace::legacy::COLUMNS);
+        auto zq = fmt_query(fmt, db::system_keyspace::legacy::TRIGGERS);
+
+        typedef std::tuple<future<result_set_type>, future<result_set_type>, future<result_set_type>, future<db::schema_tables::legacy::schema_mutations>> result_tuple;
+
+        return when_all(_qp.execute_internal(tq, { dst.name, cf_name }, cql3::query_processor::cache_internal::yes),
+                        _qp.execute_internal(cq, { dst.name, cf_name }, cql3::query_processor::cache_internal::yes),
+                        _qp.execute_internal(zq, { dst.name, cf_name }, cql3::query_processor::cache_internal::yes),
+                        db::schema_tables::legacy::read_table_mutations(_sp, dst.name, cf_name, db::system_keyspace::legacy::column_families()))
+                    .then([&dst, cf_name, timestamp](result_tuple&& t) {
+
+            result_set_type tables = std::get<0>(t).get();
+            result_set_type columns = std::get<1>(t).get();
+            result_set_type triggers = std::get<2>(t).get();
+            db::schema_tables::legacy::schema_mutations sm = std::get<3>(t).get();
+
+            row_type& td = tables->one();
+
+            auto ks_name = td.get_as<sstring>("keyspace_name");
+            auto cf_name = td.get_as<sstring>("columnfamily_name");
+            auto id = table_id(td.get_or("cf_id", generate_legacy_id(ks_name, cf_name).uuid()));
+
+            schema_builder builder(dst.name, cf_name, id);
+
+            builder.with_version(sm.digest());
+
+            cf_type cf = sstring_to_cf_type(td.get_or("type", sstring("standard")));
+            if (cf == cf_type::super) {
+                fail(unimplemented::cause::SUPER);
+            }
+
+            auto comparator = td.get_as<sstring>("comparator");
+            bool is_compound = cell_comparator::check_compound(comparator);
+            builder.set_is_compound(is_compound);
+            cell_comparator::read_collections(builder, comparator);
+
+            bool filter_sparse = false;
+
+            data_type default_validator = {};
+            if (td.has("default_validator")) {
+                default_validator = db::schema_tables::parse_type(td.get_as<sstring>("default_validator"));
+                if (default_validator->is_counter()) {
+                    builder.set_is_counter(true);
+                }
+                builder.set_default_validation_class(default_validator);
+            }
+
+            /*
+             * Determine whether or not the table is *really* dense
+             * We cannot trust is_dense value of true (see CASSANDRA-11502, that fixed the issue for 2.2 only, and not retroactively),
+             * but we can trust is_dense value of false.
+             */
+            auto is_dense = td.get_opt<bool>("is_dense");
+            if (!is_dense || *is_dense) {
+                is_dense = [&] {
+                    /*
+                     * As said above, this method is only here because we need to deal with thrift upgrades.
+                     * Once a CF has been "upgraded", i.e. we've rebuilt and save its CQL3 metadata at least once,
+                     * then we'll have saved the "is_dense" value and will be good to go.
+                     *
+                     * But non-upgraded thrift CF (and pre-7744 CF) will have no value for "is_dense", so we need
+                     * to infer that information without relying on it in that case. And for the most part this is
+                     * easy, a CF that has at least one REGULAR definition is not dense. But the subtlety is that not
+                     * having a REGULAR definition may not mean dense because of CQL3 definitions that have only the
+                     * PRIMARY KEY defined.
+                     *
+                     * So we need to recognize those special case CQL3 table with only a primary key. If we have some
+                     * clustering columns, we're fine as said above. So the only problem is that we cannot decide for
+                     * sure if a CF without REGULAR columns nor CLUSTERING_COLUMN definition is meant to be dense, or if it
+                     * has been created in CQL3 by say:
+                     *    CREATE TABLE test (k int PRIMARY KEY)
+                     * in which case it should not be dense. However, we can limit our margin of error by assuming we are
+                     * in the latter case only if the comparator is exactly CompositeType(UTF8Type).
+                     */
+                    std::optional<column_id> max_cl_idx;
+                    const cql3::untyped_result_set::row * regular = nullptr;
+                    for (auto& row : *columns) {
+                        auto kind_str = row.get_as<sstring>("type");
+                        if (kind_str == "compact_value") {
+                            continue;
+                        }
+
+                        auto kind = db::schema_tables::deserialize_kind(kind_str);
+
+                        if (kind == column_kind::regular_column) {
+                            if (regular != nullptr) {
+                                return false;
+                            }
+                            regular = &row;
+                            continue;
+                        }
+                        if (kind == column_kind::clustering_key) {
+                            max_cl_idx = std::max(column_id(row.get_or("component_index", 0)), max_cl_idx.value_or(column_id()));
+                        }
+                    }
+
+                    auto is_cql3_only_pk_comparator = [](const sstring& comparator) {
+                        if (!cell_comparator::check_compound(comparator)) {
+                            return false;
+                        }
+                        // CMH. We don't have composites, nor a parser for it. This is a simple way of c
+                        // checking the same.
+                        auto comma = comparator.find(',');
+                        if (comma != sstring::npos) {
+                            return false;
+                        }
+                        auto off = comparator.find('(');
+                        auto end = comparator.find(')');
+
+                        return comparator.compare(off, end - off, utf8_type->name()) == 0;
+                    };
+
+                    if (max_cl_idx) {
+                        auto n = std::count(comparator.begin(), comparator.end(), ','); // num comp - 1
+                        return *max_cl_idx == n;
+                    }
+
+                    if (regular) {
+                        return false;
+                    }
+
+                    return !is_cql3_only_pk_comparator(comparator);
+
+                }();
+
+                // now, if switched to sparse, remove redundant compact_value column and the last clustering column,
+                // directly copying CASSANDRA-11502 logic. See CASSANDRA-11315.
+
+                filter_sparse = !*is_dense;
+            }
+            builder.set_is_dense(*is_dense);
+
+            auto is_cql = !*is_dense && is_compound;
+            auto is_static_compact = !*is_dense && !is_compound;
+
+            // org.apache.cassandra.schema.LegacySchemaMigrator#isEmptyCompactValueColumn
+            auto is_empty_compact_value = [](const cql3::untyped_result_set::row& column_row) {
+                auto kind_str = column_row.get_as<sstring>("type");
+                // Cassandra only checks for "compact_value", but Scylla generates "regular" instead (#2586)
+                return (kind_str == "compact_value" || kind_str == "regular")
+                       && column_row.get_as<sstring>("column_name").empty();
+            };
+
+            for (auto& row : *columns) {
+                auto kind_str = row.get_as<sstring>("type");
+                auto kind = db::schema_tables::deserialize_kind(kind_str);
+                auto component_index = kind > column_kind::clustering_key ? 0 : column_id(row.get_or("component_index", 0));
+                auto name = row.get_or<sstring>("column_name", sstring());
+                auto validator = db::schema_tables::parse_type(row.get_as<sstring>("validator"));
+
+                if (is_empty_compact_value(row)) {
+                    continue;
+                }
+
+                if (filter_sparse) {
+                    if (kind_str == "compact_value") {
+                        continue;
+                    }
+                    if (kind == column_kind::clustering_key) {
+                        if (cf == cf_type::super && component_index != 0) {
+                            continue;
+                        }
+                        if (cf != cf_type::super && !is_compound) {
+                            continue;
+                        }
+                    }
+                }
+
+                std::optional<index_metadata_kind> index_kind;
+                sstring index_name;
+                index_options_map options;
+                if (row.has("index_type")) {
+                    index_kind = schema_tables::deserialize_index_kind(row.get_as<sstring>("index_type"));
+                }
+                if (row.has("index_name")) {
+                    index_name = row.get_as<sstring>("index_name");
+                }
+                if (row.has("index_options")) {
+                    sstring index_options_str = row.get_as<sstring>("index_options");
+                    options = rjson::parse_to_map<index_options_map>(std::string_view(index_options_str));
+                    sstring type;
+                    auto i = options.find("index_keys");
+                    if (i != options.end()) {
+                        options.erase(i);
+                        type = "KEYS";
+                    }
+                    i = options.find("index_keys_and_values");
+                    if (i != options.end()) {
+                        options.erase(i);
+                        type = "KEYS_AND_VALUES";
+                    }
+                    if (type.empty()) {
+                        if (validator->is_collection() && validator->is_multi_cell()) {
+                            type = "FULL";
+                        } else {
+                            type = "VALUES";
+                        }
+                    }
+                    auto column = cql3::util::maybe_quote(name);
+                    options["target"] = validator->is_collection()
+                                    ? type + "(" + column + ")"
+                                    : column;
+                }
+                if (index_kind) {
+                    // Origin assumes index_name is always set, so let's do the same
+                    builder.with_index(index_metadata(index_name, options, *index_kind, index_metadata::is_local_index::no));
+                }
+
+                data_type column_name_type = [&] {
+                    if (is_static_compact && kind == column_kind::regular_column) {
+                        return db::schema_tables::parse_type(comparator);
+                    }
+                    return utf8_type;
+                }();
+                auto column_name = [&] {
+                    try {
+                        return column_name_type->from_string(name);
+                    } catch (marshal_exception&) {
+                        // #2597: Scylla < 2.0 writes names in serialized form, try to recover
+                        column_name_type->validate(to_bytes_view(name));
+                        return to_bytes(name);
+                    }
+                }();
+                builder.with_column_ordered(column_definition(std::move(column_name), std::move(validator), kind, component_index));
+            }
+
+            if (is_static_compact) {
+                builder.set_regular_column_name_type(db::schema_tables::parse_type(comparator));
+            }
+
+            if (td.has("gc_grace_seconds")) {
+                builder.set_gc_grace_seconds(td.get_as<int32_t>("gc_grace_seconds"));
+            }
+            if (td.has("min_compaction_threshold")) {
+                builder.set_min_compaction_threshold(td.get_as<int32_t>("min_compaction_threshold"));
+            }
+            if (td.has("max_compaction_threshold")) {
+                builder.set_max_compaction_threshold(td.get_as<int32_t>("max_compaction_threshold"));
+            }
+            if (td.has("comment")) {
+                builder.set_comment(td.get_as<sstring>("comment"));
+            }
+            if (td.has("memtable_flush_period_in_ms")) {
+                builder.set_memtable_flush_period(td.get_as<int32_t>("memtable_flush_period_in_ms"));
+            }
+            if (td.has("caching")) {
+                builder.set_caching_options(caching_options::from_sstring(td.get_as<sstring>("caching")));
+            }
+            if (td.has("default_time_to_live")) {
+                builder.set_default_time_to_live(gc_clock::duration(td.get_as<int32_t>("default_time_to_live")));
+            }
+            if (td.has("speculative_retry")) {
+                builder.set_speculative_retry(td.get_as<sstring>("speculative_retry"));
+            }
+            if (td.has("compaction_strategy_class")) {
+                auto strategy = td.get_as<sstring>("compaction_strategy_class");
+                try {
+                    builder.set_compaction_strategy(compaction::compaction_strategy::type(strategy));
+                } catch (const exceptions::configuration_exception& e) {
+                    // If compaction strategy class isn't supported, fallback to incremental.
+                    mlogger.warn("Falling back to incremental compaction strategy after the problem: {}", e.what());
+                    builder.set_compaction_strategy(compaction::compaction_strategy_type::incremental);
+                }
+            }
+            if (td.has("compaction_strategy_options")) {
+                sstring strategy_options_str = td.get_as<sstring>("compaction_strategy_options");
+                builder.set_compaction_strategy_options(rjson::parse_to_map<std::map<sstring, sstring>>(std::string_view(strategy_options_str)));
+            }
+            auto comp_param = td.get_as<sstring>("compression_parameters");
+            compression_parameters cp(rjson::parse_to_map<std::map<sstring, sstring>>(std::string_view(comp_param)));
+            builder.set_compressor_params(cp);
+
+            if (td.has("min_index_interval")) {
+                builder.set_min_index_interval(td.get_as<int32_t>("min_index_interval"));
+            } else if (td.has("index_interval")) { // compatibility
+                builder.set_min_index_interval(td.get_as<int32_t>("index_interval"));
+            }
+            if (td.has("max_index_interval")) {
+                builder.set_max_index_interval(td.get_as<int32_t>("max_index_interval"));
+            }
+            if (td.has("bloom_filter_fp_chance")) {
+                builder.set_bloom_filter_fp_chance(td.get_as<double>("bloom_filter_fp_chance"));
+            } else {
+                builder.set_bloom_filter_fp_chance(builder.get_bloom_filter_fp_chance());
+            }
+            if (td.has("dropped_columns")) {
+                auto map = td.get_map<sstring, int64_t>("dropped_columns");
+                for (auto&& e : map) {
+                    builder.without_column(e.first, api::timestamp_type(e.second));
+                };
+            }
+
+            // ignore version. we're transient
+            if (!triggers->empty()) {
+                throw unsupported_feature("triggers");
+            }
+
+            dst.tables.emplace_back(table{timestamp, builder.build() });
+        });
+    }
+
+    future<> read_tables(keyspace& dst) {
+        auto query = fmt_query("SELECT columnfamily_name, writeTime(type) AS timestamp FROM {}.{} WHERE keyspace_name = ?",
+                        db::system_keyspace::legacy::COLUMNFAMILIES);
+        return _qp.execute_internal(query, {dst.name}, cql3::query_processor::cache_internal::yes).then([this, &dst](result_set_type result) {
+            return parallel_for_each(*result, [this, &dst](row_type& row) {
+                return read_table(dst, row.get_as<sstring>("columnfamily_name"), row.get_as<time_point>("timestamp"));
+            }).finally([result] {});
+        });
+    }
+
+    future<time_point> read_type_timestamp(keyspace& dst, sstring type_name) {
+        // TODO: Unfortunately there is not a single REGULAR column in system.schema_usertypes, so annoyingly we cannot
+        // use the writeTime() CQL function, and must resort to a lower level.
+        // Origin digs up the actual cells of target partition and gets timestamp from there.
+        // We should do the same, but g-dam that's messy. Lets give back dung value for now.
+        return make_ready_future<time_point>(dst.timestamp);
+    }
+
+    future<> read_types(keyspace& dst) {
+        auto query = fmt_query("SELECT * FROM {}.{} WHERE keyspace_name = ?", db::system_keyspace::legacy::USERTYPES);
+        return _qp.execute_internal(query, {dst.name}, cql3::query_processor::cache_internal::yes).then([this, &dst](result_set_type result) {
+            return parallel_for_each(*result, [this, &dst](row_type& row) {
+                auto name = row.get_blob_unfragmented("type_name");
+                auto columns = row.get_list<bytes>("field_names");
+                auto types = row.get_list<sstring>("field_types");
+                std::vector<data_type> field_types;
+                for (auto&& value : types) {
+                    field_types.emplace_back(db::schema_tables::parse_type(value));
+                }
+                auto ut = user_type_impl::get_instance(dst.name, name, columns, field_types, false);
+                return read_type_timestamp(dst, value_cast<sstring>(utf8_type->deserialize(name))).then([ut = std::move(ut), &dst](time_point timestamp) {
+                    dst.types.emplace_back(type{timestamp, ut});
+                });
+            }).finally([result] {});
+        });
+    }
+
+    future<> read_functions(keyspace& dst) {
+        auto query = fmt_query("SELECT * FROM {}.{} WHERE keyspace_name = ?", db::system_keyspace::legacy::FUNCTIONS);
+        return _qp.execute_internal(query, {dst.name}, cql3::query_processor::cache_internal::yes).then([](result_set_type result) {
+            if (!result->empty()) {
+                throw unsupported_feature("functions");
+            }
+        });
+    }
+
+    future<> read_aggregates(keyspace& dst) {
+        auto query = fmt_query("SELECT * FROM {}.{} WHERE keyspace_name = ?", db::system_keyspace::legacy::AGGREGATES);
+        return _qp.execute_internal(query, {dst.name}, cql3::query_processor::cache_internal::yes).then([](result_set_type result) {
+            if (!result->empty()) {
+                throw unsupported_feature("aggregates");
+            }
+        });
+    }
+
+    future<keyspace> read_keyspace(sstring ks_name, bool durable_writes, sstring strategy_class, sstring strategy_options, time_point timestamp) {
+        auto map = rjson::parse_to_map<std::map<sstring, sstring>>(std::string_view(strategy_options));
+        map.emplace("class", std::move(strategy_class));
+        auto ks = ::make_lw_shared<keyspace>(keyspace{timestamp, std::move(ks_name), durable_writes, std::move(map) });
+
+        return read_tables(*ks).then([this, ks] {
+            //Collection<Type> types = readTypes(keyspaceName);
+            return read_types(*ks);
+        }).then([this, ks] {
+            return read_functions(*ks);
+        }).then([this, ks] {
+            return read_aggregates(*ks);
+        }).then([ks] {
+            return make_ready_future<keyspace>(std::move(*ks));
+        });
+    }
+
+    future<> read_all_keyspaces() {
+        static auto ks_filter = [](row_type& row) {
+            auto ks_name = row.get_as<sstring>("keyspace_name");
+            return ks_name != db::system_keyspace::NAME && ks_name != db::schema_tables::v3::NAME;
+        };
+
+        auto query = fmt_query("SELECT keyspace_name, durable_writes, strategy_options, strategy_class, writeTime(durable_writes) AS timestamp FROM {}.{}",
+                        db::system_keyspace::legacy::KEYSPACES);
+
+        return _qp.execute_internal(query, cql3::query_processor::cache_internal::yes).then([this](result_set_type result) {
+            auto i = boost::make_filter_iterator(ks_filter, result->begin(), result->end());
+            auto e = boost::make_filter_iterator(ks_filter, result->end(), result->end());
+            return parallel_for_each(i, e, [this](row_type& row) {
+                return read_keyspace(row.get_as<sstring>("keyspace_name")
+                                , row.get_as<bool>("durable_writes")
+                                , row.get_as<sstring>("strategy_class")
+                                , row.get_as<sstring>("strategy_options")
+                                , row.get_as<db_clock::time_point>("timestamp")
+                                ).then([this](keyspace ks) {
+                    _keyspaces.emplace_back(std::move(ks));
+                   });
+            }).finally([result] {});
+        });
+    }
+
+    future<> drop_legacy_tables() {
+        mlogger.info("Dropping legacy schema tables");
+        auto with_snapshot = !_keyspaces.empty();
+        for (const sstring& cfname : legacy_schema_tables) {
+            co_await replica::database::legacy_drop_table_on_all_shards(_db, _sys_ks, db::system_keyspace::NAME, cfname, with_snapshot);
+        }
+    }
+
+    future<> store_keyspaces_in_new_schema_tables() {
+        mlogger.info("Moving {} keyspaces from legacy schema tables to the new schema keyspace ({})",
+                        _keyspaces.size(), db::schema_tables::v3::NAME);
+
+        utils::chunked_vector<mutation> mutations;
+
+        for (auto& ks : _keyspaces) {
+            auto ksm = ::make_lw_shared<keyspace_metadata>(ks.name
+                            , ks.replication_params["class"] // TODO, make ksm like c3?
+                            , cql3::statements::property_definitions::to_extended_map(ks.replication_params)
+                            , std::nullopt
+                            , std::nullopt
+                            , ks.durable_writes);
+
+            // we want separate time stamps for tables/types, so cannot bulk them into the ksm.
+            for (auto&& m : db::schema_tables::make_create_keyspace_mutations(schema_features::full(), ksm, ks.timestamp.time_since_epoch().count(), false)) {
+                mutations.emplace_back(std::move(m));
+            }
+            for (auto& t : ks.tables) {
+                db::schema_tables::add_table_or_view_to_schema_mutation(t.metadata, t.timestamp.time_since_epoch().count(), true, mutations);
+            }
+            for (auto& t : ks.types) {
+                db::schema_tables::add_type_to_schema_mutation(t.metadata, t.timestamp.time_since_epoch().count(), mutations);
+            }
+        }
+        return _qp.proxy().mutate_locally(std::move(mutations), tracing::trace_state_ptr());
+    }
+
+    future<> flush_schemas() {
+        auto& db = _qp.db().real_database().container();
+        return replica::database::flush_tables_on_all_shards(db, db::schema_tables::all_table_infos(schema_features::full()));
+    }
+
+    future<> migrate() {
+        return read_all_keyspaces().then([this]() {
+            // write metadata to the new schema tables
+            return store_keyspaces_in_new_schema_tables()
+                                                .then(std::bind(&migrator::flush_schemas, this))
+                                                .then(std::bind(&migrator::drop_legacy_tables, this))
+                                                .then([] { mlogger.info("Completed migration of legacy schema tables"); });
+        });
+    }
+
+    sharded<service::storage_proxy>& _sp;
+    sharded<replica::database>& _db;
+    sharded<db::system_keyspace>& _sys_ks;
+    cql3::query_processor& _qp;
+    std::vector<keyspace> _keyspaces;
+};
+
+const std::unordered_set<sstring> migrator::legacy_schema_tables = {
+                db::system_keyspace::legacy::KEYSPACES,
+                db::system_keyspace::legacy::COLUMNFAMILIES,
+                db::system_keyspace::legacy::COLUMNS,
+                db::system_keyspace::legacy::TRIGGERS,
+                db::system_keyspace::legacy::USERTYPES,
+                db::system_keyspace::legacy::FUNCTIONS,
+                db::system_keyspace::legacy::AGGREGATES,
+};
+
+}
+}
+
+future<>
+db::legacy_schema_migrator::migrate(sharded<service::storage_proxy>& sp, sharded<replica::database>& db, sharded<db::system_keyspace>& sys_ks, cql3::query_processor& qp) {
+    return do_with(migrator(sp, db, sys_ks, qp), std::bind(&migrator::migrate, std::placeholders::_1));
+}
+

db/legacy_schema_migrator.hh

@@ -0,0 +1,37 @@
+/*
+ * Modified by ScyllaDB
+ * Copyright (C) 2017-present ScyllaDB
+ */
+
+/*
+ * SPDX-License-Identifier: (LicenseRef-ScyllaDB-Source-Available-1.0 and Apache-2.0)
+ */
+
+#pragma once
+
+#include <seastar/core/future.hh>
+#include <seastar/core/sharded.hh>
+
+#include "seastarx.hh"
+
+namespace replica {
+class database;
+}
+
+namespace cql3 {
+class query_processor;
+}
+
+namespace service {
+class storage_proxy;
+}
+
+namespace db {
+class system_keyspace;
+
+namespace legacy_schema_migrator {
+
+future<> migrate(sharded<service::storage_proxy>&, sharded<replica::database>& db, sharded<db::system_keyspace>& sys_ks, cql3::query_processor&);
+
+}
+}

db/partition_snapshot_row_cursor.hh

@@ -542,7 +542,6 @@ public:
     // Returns the range tombstone for the key range adjacent to the cursor's position from the side of smaller keys.
     // Excludes the range for the row itself. That information is returned by range_tombstone_for_row().
     // It's possible that range_tombstone() is empty and range_tombstone_for_row() is not empty.
-    // Note that this is different from the meaning of rows_entry::range_tombstone(), which includes the row itself.
     tombstone range_tombstone() const { return _range_tombstone; }
 
     // Can be called when cursor is pointing at a row.

db/row_cache.cc

@@ -1287,15 +1287,6 @@ row_cache::row_cache(schema_ptr s, snapshot_source src, cache_tracker& tracker,
     , _partitions(dht::raw_token_less_comparator{})
     , _underlying(src())
     , _snapshot_source(std::move(src))
-    , _update_section(abstract_formatter([this] (fmt::context& ctx) {
-        fmt::format_to(ctx.out(), "cache.update {}.{}", _schema->ks_name(), _schema->cf_name());
-    }))
-    , _populate_section(abstract_formatter([this] (fmt::context& ctx) {
-        fmt::format_to(ctx.out(), "cache.populate {}.{}", _schema->ks_name(), _schema->cf_name());
-    }))
-    , _read_section(abstract_formatter([this] (fmt::context& ctx) {
-        fmt::format_to(ctx.out(), "cache.read {}.{}", _schema->ks_name(), _schema->cf_name());
-    }))
 {
   try {
     with_allocator(_tracker.allocator(), [this, cont] {

db/schema_tables.cc

@@ -404,7 +404,10 @@ const std::unordered_set<table_id>& schema_tables_holding_schema_mutations() {
                 computed_columns(),
                 dropped_columns(),
                 indexes(),
-                scylla_tables()}) {
+                scylla_tables(),
+                db::system_keyspace::legacy::column_families(),
+                db::system_keyspace::legacy::columns(),
+                db::system_keyspace::legacy::triggers()}) {
             SCYLLA_ASSERT(s->clustering_key_size() > 0);
             auto&& first_column_name = s->clustering_column_at(0).name_as_text();
             SCYLLA_ASSERT(first_column_name == "table_name"
@@ -2837,6 +2840,26 @@ void check_no_legacy_secondary_index_mv_schema(replica::database& db, const view
 }
 
 
+namespace legacy {
+
+table_schema_version schema_mutations::digest() const {
+    md5_hasher h;
+    const db::schema_features no_features;
+    db::schema_tables::feed_hash_for_schema_digest(h, _columnfamilies, no_features);
+    db::schema_tables::feed_hash_for_schema_digest(h, _columns, no_features);
+    return table_schema_version(utils::UUID_gen::get_name_UUID(h.finalize()));
+}
+
+future<schema_mutations> read_table_mutations(sharded<service::storage_proxy>& proxy,
+    sstring keyspace_name, sstring table_name, schema_ptr s)
+{
+    mutation cf_m = co_await read_schema_partition_for_table(proxy, s, keyspace_name, table_name);
+    mutation col_m = co_await read_schema_partition_for_table(proxy, db::system_keyspace::legacy::columns(), keyspace_name, table_name);
+    co_return schema_mutations{std::move(cf_m), std::move(col_m)};
+}
+
+} // namespace legacy
+
 static auto GET_COLUMN_MAPPING_QUERY = format("SELECT column_name, clustering_order, column_name_bytes, kind, position, type FROM system.{} WHERE cf_id = ? AND schema_version = ?",
     db::schema_tables::SCYLLA_TABLE_SCHEMA_HISTORY);
 

db/schema_tables.hh

@@ -155,6 +155,24 @@ schema_ptr scylla_table_schema_history();
 const std::unordered_set<table_id>& schema_tables_holding_schema_mutations();
 }
 
+namespace legacy {
+
+class schema_mutations {
+    mutation _columnfamilies;
+    mutation _columns;
+public:
+    schema_mutations(mutation columnfamilies, mutation columns)
+        : _columnfamilies(std::move(columnfamilies))
+        , _columns(std::move(columns))
+    { }
+    table_schema_version digest() const;
+};
+
+future<schema_mutations> read_table_mutations(sharded<service::storage_proxy>& proxy,
+    sstring keyspace_name, sstring table_name, schema_ptr s);
+
+}
+
 struct qualified_name {
     sstring keyspace_name;
     sstring table_name;

db/system0_virtual_tables.cc

@@ -0,0 +1,201 @@
+/*
+ * Copyright (C) 2024-present ScyllaDB
+ */
+
+/*
+ * SPDX-License-Identifier: LicenseRef-ScyllaDB-Source-Available-1.0
+ */
+
+#include "db/system0_virtual_tables.hh"
+#include "db/system_keyspace.hh"
+#include "db/virtual_table.hh"
+#include "replica/database.hh"
+#include "replica/tablets.hh"
+#include "schema/schema.hh"
+#include "schema/schema_builder.hh"
+#include "cql3/query_processor.hh"
+#include "mutation/frozen_mutation.hh"
+#include "types/types.hh"
+#include "utils/log.hh"
+#include <seastar/core/coroutine.hh>
+
+namespace db {
+
+namespace {
+
+static constexpr auto SYSTEM0_KEYSPACE_NAME = "system0";
+
+logging::logger sys0log("system0_virtual_tables");
+
+// Virtual table that mirrors system.topology but allows writes via group0
+class system0_topology_table : public memtable_filling_virtual_table {
+private:
+    cql3::query_processor& _qp;
+
+public:
+    explicit system0_topology_table(cql3::query_processor& qp)
+        : memtable_filling_virtual_table(build_schema())
+        , _qp(qp)
+    {}
+
+    static schema_ptr build_schema() {
+        // Use the same schema as system.topology but in system0 keyspace
+        auto id = generate_legacy_id(SYSTEM0_KEYSPACE_NAME, system_keyspace::TOPOLOGY);
+        return schema_builder(SYSTEM0_KEYSPACE_NAME, system_keyspace::TOPOLOGY, std::optional(id))
+            .with_column("key", utf8_type, column_kind::partition_key)
+            .with_column("host_id", uuid_type, column_kind::clustering_key)
+            .with_column("datacenter", utf8_type)
+            .with_column("rack", utf8_type)
+            .with_column("tokens", set_type_impl::get_instance(utf8_type, true))
+            .with_column("node_state", utf8_type)
+            .with_column("release_version", utf8_type)
+            .with_column("topology_request", utf8_type)
+            .with_column("replaced_id", uuid_type)
+            .with_column("rebuild_option", utf8_type)
+            .with_column("num_tokens", int32_type)
+            .with_column("tokens_string", utf8_type)
+            .with_column("shard_count", int32_type)
+            .with_column("ignore_msb", int32_type)
+            .with_column("cleanup_status", utf8_type)
+            .with_column("supported_features", set_type_impl::get_instance(utf8_type, true))
+            .with_column("request_id", timeuuid_type)
+            .with_column("ignore_nodes", set_type_impl::get_instance(uuid_type, true), column_kind::static_column)
+            .with_column("new_cdc_generation_data_uuid", timeuuid_type, column_kind::static_column)
+            .with_column("new_keyspace_rf_change_ks_name", utf8_type, column_kind::static_column)
+            .with_column("new_keyspace_rf_change_data", map_type_impl::get_instance(utf8_type, utf8_type, false), column_kind::static_column)
+            .with_column("version", long_type, column_kind::static_column)
+            .with_column("fence_version", long_type, column_kind::static_column)
+            .with_column("transition_state", utf8_type, column_kind::static_column)
+            .with_column("committed_cdc_generations", set_type_impl::get_instance(cdc_generation_ts_id_type, true), column_kind::static_column)
+            .with_column("unpublished_cdc_generations", set_type_impl::get_instance(cdc_generation_ts_id_type, true), column_kind::static_column)
+            .with_column("global_topology_request", utf8_type, column_kind::static_column)
+            .with_column("global_topology_request_id", timeuuid_type, column_kind::static_column)
+            .with_column("enabled_features", set_type_impl::get_instance(utf8_type, true), column_kind::static_column)
+            .with_column("session", uuid_type, column_kind::static_column)
+            .with_column("tablet_balancing_enabled", boolean_type, column_kind::static_column)
+            .with_column("upgrade_state", utf8_type, column_kind::static_column)
+            .with_column("global_requests", set_type_impl::get_instance(timeuuid_type, true), column_kind::static_column)
+            .set_comment("Virtual table for updating system.topology via group0")
+            .with_hash_version()
+            .build();
+    }
+
+    future<> execute(std::function<void(mutation)> mutation_sink) override {
+        // For reads, we mirror the actual system.topology table
+        // This is a simplified placeholder implementation
+        sys0log.debug("system0.topology: read operation");
+        co_return;
+    }
+
+    future<> apply(const frozen_mutation& fm) override {
+        sys0log.info("system0.topology: received write operation");
+        
+        // Convert mutation from system0.topology schema to system.topology schema
+        const mutation m = fm.unfreeze(_s);
+        
+        // Re-freeze the mutation with the system.topology schema
+        auto system_topology_schema = system_keyspace::topology();
+        mutation target_m(system_topology_schema, m.key());
+        target_m.partition() = m.partition();
+        
+        // TODO: Submit mutation to group0 via raft_group0_client
+        // For now, just log a warning
+        sys0log.warn("system0.topology: write operations require group0 integration (not yet implemented)");
+        
+        co_return;
+    }
+};
+
+// Virtual table that mirrors system.tablets but allows writes via group0
+class system0_tablets_table : public memtable_filling_virtual_table {
+private:
+    cql3::query_processor& _qp;
+
+public:
+    explicit system0_tablets_table(cql3::query_processor& qp)
+        : memtable_filling_virtual_table(build_schema())
+        , _qp(qp)
+    {}
+
+    static schema_ptr build_schema() {
+        // Create a simple schema for tablets in system0 keyspace
+        // This mirrors system.tablets structure
+        auto id = generate_legacy_id(SYSTEM0_KEYSPACE_NAME, system_keyspace::TABLETS);
+        auto replica_set_type = replica::get_replica_set_type();
+        
+        return schema_builder(SYSTEM0_KEYSPACE_NAME, system_keyspace::TABLETS, id)
+                .with_column("table_id", uuid_type, column_kind::partition_key)
+                .with_column("tablet_count", int32_type, column_kind::static_column)
+                .with_column("keyspace_name", utf8_type, column_kind::static_column)
+                .with_column("table_name", utf8_type, column_kind::static_column)
+                .with_column("last_token", long_type, column_kind::clustering_key)
+                .with_column("replicas", replica_set_type)
+                .with_column("new_replicas", replica_set_type)
+                .with_column("stage", utf8_type)
+                .with_column("transition", utf8_type)
+                .with_column("session", uuid_type)
+                .set_comment("Virtual table for updating system.tablets via group0")
+                .with_hash_version()
+                .build();
+    }
+
+    future<> execute(std::function<void(mutation)> mutation_sink) override {
+        // For reads, we mirror the actual system.tablets table
+        // This is a simplified placeholder implementation
+        sys0log.debug("system0.tablets: read operation");
+        co_return;
+    }
+
+    future<> apply(const frozen_mutation& fm) override {
+        sys0log.info("system0.tablets: received write operation");
+        
+        // Convert mutation from system0.tablets schema to system.tablets schema
+        const mutation m = fm.unfreeze(_s);
+        
+        // Re-freeze the mutation with the system.tablets schema
+        auto system_tablets_schema = system_keyspace::tablets();
+        mutation target_m(system_tablets_schema, m.key());
+        target_m.partition() = m.partition();
+        
+        // TODO: Submit mutation to group0 via raft_group0_client
+        // For now, just log a warning
+        sys0log.warn("system0.tablets: write operations require group0 integration (not yet implemented)");
+        
+        co_return;
+    }
+};
+
+} // anonymous namespace
+
+future<> initialize_system0_virtual_tables(
+        sharded<service::raft_group_registry>& dist_raft_gr,
+        sharded<db::system_keyspace>& sys_ks,
+        sharded<cql3::query_processor>& qp) {
+    
+    auto& virtual_tables_registry = sys_ks.local().get_virtual_tables_registry();
+    auto& virtual_tables = *virtual_tables_registry;
+    auto& db = sys_ks.local().local_db();
+
+    auto add_table = [&] (std::unique_ptr<virtual_table>&& tbl) -> future<> {
+        auto schema = tbl->schema();
+        virtual_tables[schema->id()] = std::move(tbl);
+        
+        // Add the table as a local system table (similar to regular virtual tables)
+        // Note: This creates tables in the system0 keyspace which is treated as internal
+        co_await db.add_column_family_and_make_directory(schema, replica::database::is_new_cf::yes);
+        
+        auto& cf = db.find_column_family(schema);
+        cf.mark_ready_for_writes(nullptr);
+        auto& vt = virtual_tables[schema->id()];
+        cf.set_virtual_reader(vt->as_mutation_source());
+        cf.set_virtual_writer([&vt = *vt] (const frozen_mutation& m) { return vt.apply(m); });
+    };
+
+    // Add system0 virtual tables
+    co_await add_table(std::make_unique<system0_topology_table>(qp.local()));
+    co_await add_table(std::make_unique<system0_tablets_table>(qp.local()));
+    
+    sys0log.info("system0 virtual tables initialized");
+}
+
+} // namespace db

db/system0_virtual_tables.hh

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2024-present ScyllaDB
+ */
+
+/*
+ * SPDX-License-Identifier: LicenseRef-ScyllaDB-Source-Available-1.0
+ */
+
+#pragma once
+
+#include <seastar/core/sharded.hh>
+#include "schema/schema_fwd.hh"
+
+namespace service {
+class raft_group_registry;
+}
+
+namespace cql3 {
+class query_processor;
+}
+
+namespace db {
+
+class system_keyspace;
+
+// Initialize virtual tables in the system0 keyspace which mirror group0 tables
+// from the system keyspace but allow writes via group0.
+future<> initialize_system0_virtual_tables(
+    sharded<service::raft_group_registry>& dist_raft_gr,
+    sharded<db::system_keyspace>& sys_ks,
+    sharded<cql3::query_processor>& qp);
+
+} // namespace db

db/system_keyspace.cc

@@ -847,6 +847,8 @@ schema_ptr system_keyspace::corrupt_data() {
     return corrupt_data;
 }
 
+static constexpr auto schema_gc_grace = std::chrono::duration_cast<std::chrono::seconds>(days(7)).count();
+
 /*static*/ schema_ptr system_keyspace::scylla_local() {
     static thread_local auto scylla_local = [] {
         schema_builder builder(generate_legacy_id(NAME, SCYLLA_LOCAL), NAME, SCYLLA_LOCAL,
@@ -1358,6 +1360,289 @@ schema_ptr system_keyspace::role_permissions() {
     return schema;
 }
 
+schema_ptr system_keyspace::legacy::hints() {
+    static thread_local auto schema = [] {
+        schema_builder builder(generate_legacy_id(NAME, HINTS), NAME, HINTS,
+        // partition key
+        {{"target_id", uuid_type}},
+        // clustering key
+        {{"hint_id", timeuuid_type}, {"message_version", int32_type}},
+        // regular columns
+        {{"mutation", bytes_type}},
+        // static columns
+        {},
+        // regular column name type
+        utf8_type,
+        // comment
+        "*DEPRECATED* hints awaiting delivery"
+       );
+       builder.set_gc_grace_seconds(0);
+       builder.set_compaction_strategy(compaction::compaction_strategy_type::incremental);
+       builder.set_compaction_strategy_options({{"enabled", "false"}});
+       builder.with(schema_builder::compact_storage::yes);
+       builder.with_hash_version();
+       return builder.build();
+    }();
+    return schema;
+}
+
+schema_ptr system_keyspace::legacy::batchlog() {
+    static thread_local auto schema = [] {
+        schema_builder builder(generate_legacy_id(NAME, BATCHLOG), NAME, BATCHLOG,
+        // partition key
+        {{"id", uuid_type}},
+        // clustering key
+        {},
+        // regular columns
+        {{"data", bytes_type}, {"version", int32_type}, {"written_at", timestamp_type}},
+        // static columns
+        {},
+        // regular column name type
+        utf8_type,
+        // comment
+        "*DEPRECATED* batchlog entries"
+       );
+       builder.set_gc_grace_seconds(0);
+       builder.set_compaction_strategy(compaction::compaction_strategy_type::incremental);
+       builder.set_compaction_strategy_options({{"min_threshold", "2"}});
+       builder.with(schema_builder::compact_storage::no);
+       builder.with_hash_version();
+       return builder.build();
+    }();
+    return schema;
+}
+
+schema_ptr system_keyspace::legacy::keyspaces() {
+    static thread_local auto schema = [] {
+        schema_builder builder(generate_legacy_id(NAME, KEYSPACES), NAME, KEYSPACES,
+        // partition key
+        {{"keyspace_name", utf8_type}},
+        // clustering key
+        {},
+        // regular columns
+        {
+         {"durable_writes", boolean_type},
+         {"strategy_class", utf8_type},
+         {"strategy_options", utf8_type}
+        },
+        // static columns
+        {},
+        // regular column name type
+        utf8_type,
+        // comment
+        "*DEPRECATED* keyspace definitions"
+       );
+       builder.set_gc_grace_seconds(schema_gc_grace);
+       builder.with(schema_builder::compact_storage::yes);
+       builder.with_hash_version();
+       return builder.build();
+    }();
+    return schema;
+}
+
+schema_ptr system_keyspace::legacy::column_families() {
+    static thread_local auto schema = [] {
+        schema_builder builder(generate_legacy_id(NAME, COLUMNFAMILIES), NAME, COLUMNFAMILIES,
+        // partition key
+        {{"keyspace_name", utf8_type}},
+        // clustering key
+        {{"columnfamily_name", utf8_type}},
+        // regular columns
+        {
+         {"bloom_filter_fp_chance", double_type},
+         {"caching", utf8_type},
+         {"cf_id", uuid_type},
+         {"comment", utf8_type},
+         {"compaction_strategy_class", utf8_type},
+         {"compaction_strategy_options", utf8_type},
+         {"comparator", utf8_type},
+         {"compression_parameters", utf8_type},
+         {"default_time_to_live", int32_type},
+         {"default_validator", utf8_type},
+         {"dropped_columns",  map_type_impl::get_instance(utf8_type, long_type, true)},
+         {"gc_grace_seconds", int32_type},
+         {"is_dense", boolean_type},
+         {"key_validator", utf8_type},
+         {"max_compaction_threshold", int32_type},
+         {"max_index_interval", int32_type},
+         {"memtable_flush_period_in_ms", int32_type},
+         {"min_compaction_threshold", int32_type},
+         {"min_index_interval", int32_type},
+         {"speculative_retry", utf8_type},
+         {"subcomparator", utf8_type},
+         {"type", utf8_type},
+         // The following 4 columns are only present up until 2.1.8 tables
+         {"key_aliases", utf8_type},
+         {"value_alias", utf8_type},
+         {"column_aliases", utf8_type},
+         {"index_interval", int32_type},},
+        // static columns
+        {},
+        // regular column name type
+        utf8_type,
+        // comment
+        "*DEPRECATED* table definitions"
+       );
+       builder.set_gc_grace_seconds(schema_gc_grace);
+       builder.with(schema_builder::compact_storage::no);
+       builder.with_hash_version();
+       return builder.build();
+    }();
+    return schema;
+}
+
+schema_ptr system_keyspace::legacy::columns() {
+    static thread_local auto schema = [] {
+        schema_builder builder(generate_legacy_id(NAME, COLUMNS), NAME, COLUMNS,
+        // partition key
+        {{"keyspace_name", utf8_type}},
+        // clustering key
+        {{"columnfamily_name", utf8_type}, {"column_name", utf8_type}},
+        // regular columns
+        {
+            {"component_index", int32_type},
+            {"index_name", utf8_type},
+            {"index_options", utf8_type},
+            {"index_type", utf8_type},
+            {"type", utf8_type},
+            {"validator", utf8_type},
+        },
+        // static columns
+        {},
+        // regular column name type
+        utf8_type,
+        // comment
+        "column definitions"
+        );
+        builder.set_gc_grace_seconds(schema_gc_grace);
+        builder.with(schema_builder::compact_storage::no);
+        builder.with_hash_version();
+        return builder.build();
+    }();
+    return schema;
+}
+
+schema_ptr system_keyspace::legacy::triggers() {
+    static thread_local auto schema = [] {
+        schema_builder builder(generate_legacy_id(NAME, TRIGGERS), NAME, TRIGGERS,
+        // partition key
+        {{"keyspace_name", utf8_type}},
+        // clustering key
+        {{"columnfamily_name", utf8_type}, {"trigger_name", utf8_type}},
+        // regular columns
+        {
+            {"trigger_options",  map_type_impl::get_instance(utf8_type, utf8_type, true)},
+        },
+        // static columns
+        {},
+        // regular column name type
+        utf8_type,
+        // comment
+        "trigger definitions"
+        );
+        builder.set_gc_grace_seconds(schema_gc_grace);
+        builder.with(schema_builder::compact_storage::no);
+        builder.with_hash_version();
+        return builder.build();
+    }();
+    return schema;
+}
+
+schema_ptr system_keyspace::legacy::usertypes() {
+    static thread_local auto schema = [] {
+        schema_builder builder(generate_legacy_id(NAME, USERTYPES), NAME, USERTYPES,
+        // partition key
+        {{"keyspace_name", utf8_type}},
+        // clustering key
+        {{"type_name", utf8_type}},
+        // regular columns
+        {
+            {"field_names", list_type_impl::get_instance(utf8_type, true)},
+            {"field_types", list_type_impl::get_instance(utf8_type, true)},
+        },
+        // static columns
+        {},
+        // regular column name type
+        utf8_type,
+        // comment
+        "user defined type definitions"
+        );
+        builder.set_gc_grace_seconds(schema_gc_grace);
+        builder.with(schema_builder::compact_storage::no);
+        builder.with_hash_version();
+        return builder.build();
+    }();
+    return schema;
+}
+
+schema_ptr system_keyspace::legacy::functions() {
+    /**
+     * Note: we have our own "legacy" version of this table (in schema_tables),
+     * but it is (afaik) not used, and differs slightly from the origin one.
+     * This is based on the origin schema, since we're more likely to encounter
+     * installations of that to migrate, rather than our own (if we dont use the table).
+     */
+    static thread_local auto schema = [] {
+        schema_builder builder(generate_legacy_id(NAME, FUNCTIONS), NAME, FUNCTIONS,
+        // partition key
+        {{"keyspace_name", utf8_type}},
+        // clustering key
+        {{"function_name", utf8_type},{"signature", list_type_impl::get_instance(utf8_type, false)}},
+        // regular columns
+        {
+            {"argument_names", list_type_impl::get_instance(utf8_type, true)},
+            {"argument_types", list_type_impl::get_instance(utf8_type, true)},
+            {"body", utf8_type},
+            {"language", utf8_type},
+            {"return_type", utf8_type},
+            {"called_on_null_input", boolean_type},
+        },
+        // static columns
+        {},
+        // regular column name type
+        utf8_type,
+        // comment
+        "*DEPRECATED* user defined type definitions"
+        );
+        builder.set_gc_grace_seconds(schema_gc_grace);
+        builder.with(schema_builder::compact_storage::no);
+        builder.with_hash_version();
+        return builder.build();
+    }();
+    return schema;
+}
+
+schema_ptr system_keyspace::legacy::aggregates() {
+    static thread_local auto schema = [] {
+        schema_builder builder(generate_legacy_id(NAME, AGGREGATES), NAME, AGGREGATES,
+        // partition key
+        {{"keyspace_name", utf8_type}},
+        // clustering key
+        {{"aggregate_name", utf8_type},{"signature", list_type_impl::get_instance(utf8_type, false)}},
+        // regular columns
+        {
+            {"argument_types", list_type_impl::get_instance(utf8_type, true)},
+            {"final_func", utf8_type},
+            {"initcond", bytes_type},
+            {"return_type", utf8_type},
+            {"state_func", utf8_type},
+            {"state_type", utf8_type},
+        },
+        // static columns
+        {},
+        // regular column name type
+        utf8_type,
+        // comment
+        "*DEPRECATED* user defined aggregate definition"
+        );
+        builder.set_gc_grace_seconds(schema_gc_grace);
+        builder.with(schema_builder::compact_storage::no);
+        builder.with_hash_version();
+        return builder.build();
+    }();
+    return schema;
+}
+
 schema_ptr system_keyspace::dicts() {
     static thread_local auto schema = [] {
         auto id = generate_legacy_id(NAME, DICTS);
@@ -2330,6 +2615,13 @@ std::vector<schema_ptr> system_keyspace::all_tables(const db::config& cfg) {
     if (cfg.check_experimental(db::experimental_features_t::feature::KEYSPACE_STORAGE_OPTIONS)) {
         r.insert(r.end(), {sstables_registry()});
     }
+    // legacy schema
+    r.insert(r.end(), {
+                    // TODO: once we migrate hints/batchlog and add converter
+                    // legacy::hints(), legacy::batchlog(),
+                    legacy::keyspaces(), legacy::column_families(),
+                    legacy::columns(), legacy::triggers(), legacy::usertypes(),
+                    legacy::functions(), legacy::aggregates(), });
 
     return r;
 }

db/system_keyspace.hh

@@ -241,6 +241,28 @@ public:
         static schema_ptr cdc_local();
     };
 
+    struct legacy {
+        static constexpr auto HINTS = "hints";
+        static constexpr auto BATCHLOG = "batchlog";
+        static constexpr auto KEYSPACES = "schema_keyspaces";
+        static constexpr auto COLUMNFAMILIES = "schema_columnfamilies";
+        static constexpr auto COLUMNS = "schema_columns";
+        static constexpr auto TRIGGERS = "schema_triggers";
+        static constexpr auto USERTYPES = "schema_usertypes";
+        static constexpr auto FUNCTIONS = "schema_functions";
+        static constexpr auto AGGREGATES = "schema_aggregates";
+
+        static schema_ptr keyspaces();
+        static schema_ptr column_families();
+        static schema_ptr columns();
+        static schema_ptr triggers();
+        static schema_ptr usertypes();
+        static schema_ptr functions();
+        static schema_ptr aggregates();
+        static schema_ptr hints();
+        static schema_ptr batchlog();
+    };
+
     // Partition estimates for a given range of tokens.
     struct range_estimates {
         schema_ptr schema;

docs/dev/task_manager.md

@@ -45,22 +45,6 @@ immediately after it's finished.
 
 A flag which determines if a task can be aborted through API.
 
-# Task timing fields
-
-Tasks have three timing fields that track different stages of their lifecycle:
-
-- `creation_time` - When the task was created/queued. This is extracted from the task's
-  UUID (which is a timeuuid) and represents the moment the task request was submitted.
-- `start_time` - When the task actually began executing. For tasks that are queued, this
-  will be unspecified (equal to epoch) until execution starts. For node operations
-  like decommission, this is set when the request is picked up for execution by the
-  topology coordinator.
-- `end_time` - When the task completed (successfully or with an error). This is
-  unspecified (equal to epoch) until the task finishes.
-
-The difference between `creation_time` and `start_time` represents the time a task
-spent waiting in the queue before execution began.
-
 # Type vs scope vs kind
 
 `type` of a task describes what operation is covered by a task,

docs/operating-scylla/nodetool-commands/setlogginglevel.rst

@@ -110,6 +110,7 @@ To display the log classes (output changes with each version so your display may
    keys
    keyspace_utils
    large_data
+   legacy_schema_migrator
    lister
    load_balancer
    load_broadcaster

docs/operating-scylla/nodetool-commands/tasks/list.rst

@@ -42,21 +42,21 @@ For single list:
 
 .. code-block:: shell
 
-    task_id                              type   kind scope    state sequence_number keyspace table entity shard creation_time        start_time           end_time
-    5116ddb6-85b5-4c3e-94fb-72128f15d7b4 repair node keyspace done  3               abc                   0     2025-01-16T16:12:08Z 2025-01-16T16:12:11Z 2025-01-16T16:12:13Z
+    task_id                              type   kind scope    state sequence_number keyspace table entity shard start_time           end_time
+    5116ddb6-85b5-4c3e-94fb-72128f15d7b4 repair node keyspace done  3               abc                   0     2025-01-16T16:12:11Z 2025-01-16T16:12:13Z
 
 With repetition:
 
 .. code-block:: shell
 
-    task_id                              type   kind scope    state   sequence_number keyspace table entity shard creation_time        start_time           end_time
-    d8926ee7-0faf-47b7-bfeb-82477e0c7b33 repair node keyspace running 5               abc                   0     2025-01-16T16:12:54Z 2025-01-16T16:12:57Z
-    1e028cb8-31a3-45ed-8728-af7a1ab586f6 repair node keyspace done    4               abc                   0     2025-01-16T16:12:42Z 2025-01-16T16:12:45Z 2025-01-16T16:12:47Z
+    task_id                              type   kind scope    state   sequence_number keyspace table entity shard start_time           end_time
+    d8926ee7-0faf-47b7-bfeb-82477e0c7b33 repair node keyspace running 5               abc                   0     2025-01-16T16:12:57Z
+    1e028cb8-31a3-45ed-8728-af7a1ab586f6 repair node keyspace done    4               abc                   0     2025-01-16T16:12:45Z 2025-01-16T16:12:47Z
 
-    task_id                              type   kind scope    state   sequence_number keyspace table entity shard creation_time        start_time           end_time
-    1e535f9b-97fa-4788-a956-8f3216a6ea8d repair node keyspace created 6               abc                   0     2025-01-16T16:13:02Z
-    d8926ee7-0faf-47b7-bfeb-82477e0c7b33 repair node keyspace running 5               abc                   0     2025-01-16T16:12:54Z 2025-01-16T16:12:57Z
-    1e028cb8-31a3-45ed-8728-af7a1ab586f6 repair node keyspace done    4               abc                   0     2025-01-16T16:12:42Z 2025-01-16T16:12:45Z 2025-01-16T16:12:47Z
+    task_id                              type   kind scope    state   sequence_number keyspace table entity shard start_time           end_time
+    1e535f9b-97fa-4788-a956-8f3216a6ea8d repair node keyspace created 6               abc                   0
+    d8926ee7-0faf-47b7-bfeb-82477e0c7b33 repair node keyspace running 5               abc                   0     2025-01-16T16:12:57Z
+    1e028cb8-31a3-45ed-8728-af7a1ab586f6 repair node keyspace done    4               abc                   0     2025-01-16T16:12:45Z 2025-01-16T16:12:47Z
 
 See also
 --------

docs/operating-scylla/nodetool-commands/tasks/status.rst

@@ -25,7 +25,6 @@ Example output
    scope: keyspace
    state: running
    is_abortable: true
-   creation_time: 2024-07-29T15:48:50Z
    start_time: 2024-07-29T15:48:55Z
    end_time:
    error:

docs/operating-scylla/nodetool-commands/tasks/tree.rst

@@ -26,22 +26,22 @@ For single task:
 
 .. code-block:: shell
 
-   id                                   type   kind scope    state is_abortable creation_time        start_time           end_time             error parent_id                            sequence_number shard keyspace table entity progress_units total completed children_ids
-   be5559ea-bc5a-428c-b8ce-d14eac7a1765 repair node keyspace done  true         2024-07-29T16:06:43Z 2024-07-29T16:06:46Z 2024-07-29T16:06:46Z       none                                 1               0     abc                   ranges         4     4         [{task_id: 542e38cb-9ad4-40aa-9010-de2630004e55, node: 127.0.0.1 }, {task_id: 8974ebcc-1e87-4040-88fe-f2438261f7fb, node: 127.0.0.1 }]
-   542e38cb-9ad4-40aa-9010-de2630004e55 repair node shard    done  false        2024-07-29T16:06:43Z 2024-07-29T16:06:46Z 2024-07-29T16:06:46Z       be5559ea-bc5a-428c-b8ce-d14eac7a1765 1               0     abc                   ranges         2     2         []
-   8974ebcc-1e87-4040-88fe-f2438261f7fb repair node shard    done  false        2024-07-29T16:06:43Z 2024-07-29T16:06:46Z 2024-07-29T16:06:46Z       be5559ea-bc5a-428c-b8ce-d14eac7a1765 1               1     abc                   ranges         2     2         []
+   id                                   type   kind scope    state is_abortable start_time           end_time             error parent_id                            sequence_number shard keyspace table entity progress_units total completed children_ids
+   be5559ea-bc5a-428c-b8ce-d14eac7a1765 repair node keyspace done  true         2024-07-29T16:06:46Z 2024-07-29T16:06:46Z       none                                 1               0     abc                   ranges         4     4         [{task_id: 542e38cb-9ad4-40aa-9010-de2630004e55, node: 127.0.0.1 }, {task_id: 8974ebcc-1e87-4040-88fe-f2438261f7fb, node: 127.0.0.1 }]
+   542e38cb-9ad4-40aa-9010-de2630004e55 repair node shard    done  false        2024-07-29T16:06:46Z 2024-07-29T16:06:46Z       be5559ea-bc5a-428c-b8ce-d14eac7a1765 1               0     abc                   ranges         2     2         []
+   8974ebcc-1e87-4040-88fe-f2438261f7fb repair node shard    done  false        2024-07-29T16:06:46Z 2024-07-29T16:06:46Z       be5559ea-bc5a-428c-b8ce-d14eac7a1765 1               1     abc                   ranges         2     2         []
 
 For all tasks:
 
 .. code-block:: shell
 
-   id                                   type                   kind    scope    state is_abortable creation_time        start_time           end_time             error parent_id                            sequence_number shard keyspace table entity progress_units total completed children_ids
-   16eafb1e-8b2e-48e6-bd7a-432ca3d8b9fc repair                 node    keyspace done  true         2024-07-29T16:34:43Z 2024-07-29T16:34:46Z 2024-07-29T16:34:46Z       none                                 1               0     abc                   ranges         4     4         [{task_id: e0aa1aa4-58ca-4bfb-b3e6-74e5f3a0f6ee, node: 127.0.0.1 }, {task_id: 49eb5797-b67e-46b0-9365-4460f7cf988a, node: 127.0.0.1 }]
-   e0aa1aa4-58ca-4bfb-b3e6-74e5f3a0f6ee repair                 node    shard    done  false        2024-07-29T16:34:43Z 2024-07-29T16:34:46Z 2024-07-29T16:34:46Z       16eafb1e-8b2e-48e6-bd7a-432ca3d8b9fc 1               0     abc                   ranges         2     2         []
-   49eb5797-b67e-46b0-9365-4460f7cf988a repair                 node    shard    done  false        2024-07-29T16:34:43Z 2024-07-29T16:34:46Z 2024-07-29T16:34:46Z       16eafb1e-8b2e-48e6-bd7a-432ca3d8b9fc 1               1     abc                   ranges         2     2         []
-   82d7b2a4-146e-4a72-ba93-c66d5b4e9867 offstrategy compaction node    keyspace done  true         2024-07-29T16:34:13Z 2024-07-29T16:34:16Z 2024-07-29T16:34:16Z       none                                 954             0     abc                                  1     1         [{task_id: 9818277b-238d-4298-a56b-c0d2153bf140, node: 127.0.0.1 }, {task_id: c1eb0701-ad7a-45ff-956f-7b8d671fc5db, node: 127.0.0.1 }
-   9818277b-238d-4298-a56b-c0d2153bf140 offstrategy compaction node    shard    done  false        2024-07-29T16:34:13Z 2024-07-29T16:34:16Z 2024-07-29T16:34:16Z       82d7b2a4-146e-4a72-ba93-c66d5b4e9867 954             0     abc                                  1     1         []
-   c1eb0701-ad7a-45ff-956f-7b8d671fc5db offstrategy compaction node    shard    done  false        2024-07-29T16:34:13Z 2024-07-29T16:34:16Z 2024-07-29T16:34:16Z       82d7b2a4-146e-4a72-ba93-c66d5b4e9867 954             1     abc                                  1     1         []
+   id                                   type                   kind    scope    state is_abortable start_time           end_time             error parent_id                            sequence_number shard keyspace table entity progress_units total completed children_ids
+   16eafb1e-8b2e-48e6-bd7a-432ca3d8b9fc repair                 node    keyspace done  true         2024-07-29T16:34:46Z 2024-07-29T16:34:46Z       none                                 1               0     abc                   ranges         4     4         [{task_id: e0aa1aa4-58ca-4bfb-b3e6-74e5f3a0f6ee, node: 127.0.0.1 }, {task_id: 49eb5797-b67e-46b0-9365-4460f7cf988a, node: 127.0.0.1 }]
+   e0aa1aa4-58ca-4bfb-b3e6-74e5f3a0f6ee repair                 node    shard    done  false        2024-07-29T16:34:46Z 2024-07-29T16:34:46Z       16eafb1e-8b2e-48e6-bd7a-432ca3d8b9fc 1               0     abc                   ranges         2     2         []
+   49eb5797-b67e-46b0-9365-4460f7cf988a repair                 node    shard    done  false        2024-07-29T16:34:46Z 2024-07-29T16:34:46Z       16eafb1e-8b2e-48e6-bd7a-432ca3d8b9fc 1               1     abc                   ranges         2     2         []
+   82d7b2a4-146e-4a72-ba93-c66d5b4e9867 offstrategy compaction node    keyspace done  true         2024-07-29T16:34:16Z 2024-07-29T16:34:16Z       none                                 954             0     abc                                  1     1         [{task_id: 9818277b-238d-4298-a56b-c0d2153bf140, node: 127.0.0.1 }, {task_id: c1eb0701-ad7a-45ff-956f-7b8d671fc5db, node: 127.0.0.1 }
+   9818277b-238d-4298-a56b-c0d2153bf140 offstrategy compaction node    shard    done  false        2024-07-29T16:34:16Z 2024-07-29T16:34:16Z       82d7b2a4-146e-4a72-ba93-c66d5b4e9867 954             0     abc                                  1     1         []
+   c1eb0701-ad7a-45ff-956f-7b8d671fc5db offstrategy compaction node    shard    done  false        2024-07-29T16:34:16Z 2024-07-29T16:34:16Z       82d7b2a4-146e-4a72-ba93-c66d5b4e9867 954             1     abc                                  1     1         []
 
 See also
 --------

idl/raft.idl.hh

@@ -129,6 +129,6 @@ struct direct_fd_ping_reply {
     std::variant<std::monostate, service::wrong_destination, service::group_liveness_info> result;
 };
 
-verb [[with_client_info, with_timeout, cancellable]] direct_fd_ping (raft::server_id dst_id) -> service::direct_fd_ping_reply;
+verb [[with_client_info, cancellable]] direct_fd_ping (raft::server_id dst_id) -> service::direct_fd_ping_reply;
 
 } // namespace service

main.cc

@@ -39,6 +39,7 @@
 #include "api/api_init.hh"
 #include "db/config.hh"
 #include "db/extensions.hh"
+#include "db/legacy_schema_migrator.hh"
 #include "service/storage_service.hh"
 #include "service/migration_manager.hh"
 #include "service/tablet_allocator.hh"
@@ -107,6 +108,7 @@
 #include "lang/manager.hh"
 #include "sstables/sstables_manager.hh"
 #include "db/virtual_tables.hh"
+#include "db/system0_virtual_tables.hh"
 
 #include "service/raft/raft_group_registry.hh"
 #include "service/raft/raft_group0_client.hh"
@@ -1640,7 +1642,7 @@ To start the scylla server proper, simply invoke as: scylla server (or just scyl
             fd.start(
                 std::ref(fd_pinger), std::ref(fd_clock),
                 service::direct_fd_clock::base::duration{std::chrono::milliseconds{100}}.count(),
-                service::direct_fd_clock::base::duration{std::chrono::milliseconds{cfg->direct_failure_detector_ping_timeout_in_ms()}}.count(), dbcfg.gossip_scheduling_group).get();
+                service::direct_fd_clock::base::duration{std::chrono::milliseconds{cfg->direct_failure_detector_ping_timeout_in_ms()}}.count()).get();
 
             auto stop_fd = defer_verbose_shutdown("direct_failure_detector", [] {
                 fd.stop().get();
@@ -1835,6 +1837,11 @@ To start the scylla server proper, simply invoke as: scylla server (or just scyl
                 return db::initialize_virtual_tables(db, ss, gossiper, raft_gr, sys_ks, tablet_allocator, messaging, *cfg);
             }).get();
 
+            checkpoint(stop_signal, "initializing system0 virtual tables");
+            smp::invoke_on_all([&] {
+                return db::initialize_system0_virtual_tables(raft_gr, sys_ks, qp);
+            }).get();
+
             // #293 - do not stop anything
             // engine().at_exit([&qp] { return qp.stop(); });
             sstables::init_metrics().get();
@@ -1850,6 +1857,8 @@ To start the scylla server proper, simply invoke as: scylla server (or just scyl
             group0_client.init().get();
 
             checkpoint(stop_signal, "initializing system schema");
+            // schema migration, if needed, is also done on shard 0
+            db::legacy_schema_migrator::migrate(proxy, db, sys_ks, qp.local()).get();
             db::schema_tables::save_system_schema(qp.local()).get();
             db::schema_tables::recalculate_schema_version(sys_ks, proxy, feature_service.local()).get();
 

message/messaging_service.cc

@@ -686,7 +686,6 @@ static constexpr unsigned do_get_rpc_client_idx(messaging_verb verb) {
     case messaging_verb::RAFT_MODIFY_CONFIG:
     case messaging_verb::RAFT_PULL_SNAPSHOT:
     case messaging_verb::NOTIFY_BANNED:
-    case messaging_verb::DIRECT_FD_PING:
         // See comment above `TOPOLOGY_INDEPENDENT_IDX`.
         // DO NOT put any 'hot' (e.g. data path) verbs in this group,
         // only verbs which are 'rare' and 'cheap'.
@@ -748,6 +747,7 @@ static constexpr unsigned do_get_rpc_client_idx(messaging_verb verb) {
     case messaging_verb::PAXOS_ACCEPT:
     case messaging_verb::PAXOS_LEARN:
     case messaging_verb::PAXOS_PRUNE:
+    case messaging_verb::DIRECT_FD_PING:
         return 2;
     case messaging_verb::MUTATION_DONE:
     case messaging_verb::MUTATION_FAILED:

mutation/partition_version.cc

@@ -575,15 +575,10 @@ utils::coroutine partition_entry::apply_to_incomplete(const schema& s,
                         }
                         res.row.set_range_tombstone(cur.range_tombstone_for_row() + src_cur.range_tombstone());
 
-                        if (need_preempt()) {
-                            lb = position_in_partition(cur.position());
-                            ++tracker.get_stats().rows_covered_by_range_tombstones_from_memtable;
-                            return stop_iteration::no;
-                        }
-
                         // FIXME: Compact the row
                         ++tracker.get_stats().rows_covered_by_range_tombstones_from_memtable;
                         cur.next();
+                        // FIXME: preempt
                     }
                 }
                 {

node_ops/task_manager_module.cc

@@ -14,7 +14,6 @@
 #include "tasks/task_handler.hh"
 #include "tasks/virtual_task_hint.hh"
 #include "utils/error_injection.hh"
-#include "utils/UUID_gen.hh"
 #include <variant>
 #include "utils/overloaded_functor.hh"
 
@@ -91,7 +90,6 @@ future<std::optional<tasks::task_status>> node_ops_virtual_task::get_status_help
         .scope = "cluster",
         .state = get_state(entry),
         .is_abortable = co_await is_abortable(std::move(hint)),
-        .creation_time = db_clock::time_point(utils::UUID_gen::unix_timestamp(id.uuid())),
         .start_time = entry.start_time,
         .end_time = entry.end_time,
         .error = entry.error,
@@ -169,7 +167,6 @@ future<std::vector<tasks::task_stats>> node_ops_virtual_task::get_stats() {
             .table = "",
             .entity = "",
             .shard = 0,
-            .creation_time = db_clock::time_point(utils::UUID_gen::unix_timestamp(id)),
             .start_time = entry.start_time,
             .end_time = entry.end_time
         };

replica/distributed_loader.cc

@@ -50,7 +50,8 @@ static const std::unordered_set<std::string_view> internal_keyspaces = {
         db::system_keyspace::NAME,
         db::schema_tables::NAME,
         auth::meta::legacy::AUTH_KS,
-        tracing::trace_keyspace_helper::KEYSPACE_NAME
+        tracing::trace_keyspace_helper::KEYSPACE_NAME,
+        "system0" // Virtual keyspace for group0 table updates
 };
 
 bool is_internal_keyspace(std::string_view name) {

service/direct_failure_detector/failure_detector.cc

@@ -6,7 +6,6 @@
  * SPDX-License-Identifier: LicenseRef-ScyllaDB-Source-Available-1.0
  */
 
-#include "seastar/core/scheduling.hh"
 #include "utils/assert.hh"
 #include <unordered_set>
 
@@ -18,7 +17,6 @@
 #include <seastar/core/condition-variable.hh>
 #include <seastar/coroutine/parallel_for_each.hh>
 #include <seastar/util/defer.hh>
-#include <seastar/coroutine/switch_to.hh>
 
 #include "utils/log.hh"
 
@@ -120,7 +118,7 @@ struct failure_detector::impl {
 
     // Fetches endpoint updates from _endpoint_queue and performs the add/remove operation.
     // Runs on shard 0 only.
-    future<> update_endpoint_fiber(seastar::scheduling_group sg);
+    future<> update_endpoint_fiber();
     future<> _update_endpoint_fiber = make_ready_future<>();
 
     // Workers running on this shard.
@@ -142,7 +140,7 @@ struct failure_detector::impl {
     // The unregistering process requires cross-shard operations which we perform on this fiber.
     future<> _destroy_subscriptions = make_ready_future<>();
 
-    impl(failure_detector& parent, pinger&, clock&, clock::interval_t ping_period, clock::interval_t ping_timeout, seastar::scheduling_group sg);
+    impl(failure_detector& parent, pinger&, clock&, clock::interval_t ping_period, clock::interval_t ping_timeout);
     ~impl();
 
     // Inform update_endpoint_fiber() about an added/removed endpoint.
@@ -179,19 +177,19 @@ struct failure_detector::impl {
 };
 
 failure_detector::failure_detector(
-    pinger& pinger, clock& clock, clock::interval_t ping_period, clock::interval_t ping_timeout, seastar::scheduling_group sg)
-        : _impl(std::make_unique<impl>(*this, pinger, clock, ping_period, ping_timeout, sg))
+    pinger& pinger, clock& clock, clock::interval_t ping_period, clock::interval_t ping_timeout)
+        : _impl(std::make_unique<impl>(*this, pinger, clock, ping_period, ping_timeout))
 {}
 
 failure_detector::impl::impl(
-    failure_detector& parent, pinger& pinger, clock& clock, clock::interval_t ping_period, clock::interval_t ping_timeout, seastar::scheduling_group sg)
+    failure_detector& parent, pinger& pinger, clock& clock, clock::interval_t ping_period, clock::interval_t ping_timeout)
         : _parent(parent), _pinger(pinger), _clock(clock), _ping_period(ping_period), _ping_timeout(ping_timeout) {
     if (this_shard_id() != 0) {
         return;
     }
 
     _num_workers.resize(smp::count, 0);
-    _update_endpoint_fiber = update_endpoint_fiber(sg);
+    _update_endpoint_fiber = update_endpoint_fiber();
 }
 
 void failure_detector::impl::send_update_endpoint(pinger::endpoint_id ep, endpoint_update update) {
@@ -207,9 +205,9 @@ void failure_detector::impl::send_update_endpoint(pinger::endpoint_id ep, endpoi
     _endpoint_changed.signal();
 }
 
-future<> failure_detector::impl::update_endpoint_fiber(seastar::scheduling_group sg) {
+future<> failure_detector::impl::update_endpoint_fiber() {
     SCYLLA_ASSERT(this_shard_id() == 0);
-    co_await coroutine::switch_to(sg);
+
     while (true) {
         co_await _endpoint_changed.wait([this] { return !_endpoint_updates.empty(); });
 
@@ -482,7 +480,7 @@ static future<bool> ping_with_timeout(pinger::endpoint_id id, clock::timepoint_t
         }
     });
 
-    auto f = pinger.ping(id, timeout, timeout_as, c);
+    auto f = pinger.ping(id, timeout_as);
     auto sleep_and_abort = [] (clock::timepoint_t timeout, abort_source& timeout_as, clock& c) -> future<> {
         co_await c.sleep_until(timeout, timeout_as).then_wrapped([&timeout_as] (auto&& f) {
             // Avoid throwing if sleep was aborted.

service/direct_failure_detector/failure_detector.hh

@@ -19,6 +19,26 @@ class abort_source;
 
 namespace direct_failure_detector {
 
+class pinger {
+public:
+    // Opaque endpoint ID.
+    // A specific implementation of `pinger` maps those IDs to 'real' addresses.
+    using endpoint_id = utils::UUID;
+
+    // Send a message to `ep` and wait until it responds.
+    // The wait can be aborted using `as`.
+    // Abort should be signalized with `abort_requested_exception`.
+    //
+    // If the ping fails in an expected way (e.g. the endpoint is down and refuses to connect),
+    // returns `false`. If it succeeds, returns `true`.
+    virtual future<bool> ping(endpoint_id ep, abort_source& as) = 0;
+
+protected:
+    // The `pinger` object must not be destroyed through the `pinger` interface.
+    // `failure_detector` does not take ownership of `pinger`, only a non-owning reference.
+    ~pinger() = default;
+};
+
 // A clock that uses abstract units to measure time.
 // The implementation is responsible for periodically advancing the clock.
 //
@@ -40,33 +60,12 @@ public:
     // Aborts should be signalized using `seastar::sleep_aborted`.
     virtual future<> sleep_until(timepoint_t tp, abort_source& as) = 0;
 
-    virtual std::chrono::milliseconds to_milliseconds(timepoint_t tp) const = 0;
 protected:
     // The `clock` object must not be destroyed through the `clock` interface.
     // `failure_detector` does not take ownership of `clock`, only a non-owning reference.
     ~clock() = default;
 };
 
-class pinger {
-public:
-    // Opaque endpoint ID.
-    // A specific implementation of `pinger` maps those IDs to 'real' addresses.
-    using endpoint_id = utils::UUID;
-
-    // Send a message to `ep` and wait until it responds.
-    // The wait can be aborted using `as`.
-    // Abort should be signalized with `abort_requested_exception`.
-    //
-    // If the ping fails in an expected way (e.g. the endpoint is down and refuses to connect),
-    // returns `false`. If it succeeds, returns `true`.
-    virtual future<bool> ping(endpoint_id ep, clock::timepoint_t timeout, abort_source& as, clock& c) = 0;
-
-protected:
-    // The `pinger` object must not be destroyed through the `pinger` interface.
-    // `failure_detector` does not take ownership of `pinger`, only a non-owning reference.
-    ~pinger() = default;
-};
-
 class listener {
 public:
     // Called when an endpoint in the detected set (added by `failure_detector::add_endpoint`) responds to a ping
@@ -128,10 +127,7 @@ public:
 
         // Duration after which a ping is aborted, so that next ping can be started
         // (pings are sent sequentially).
-        clock::interval_t ping_timeout,
-
-        // Scheduling group used for fibers inside the failure detector.
-        seastar::scheduling_group sg
+        clock::interval_t ping_timeout
     );
 
     ~failure_detector();

service/raft/raft_group_registry.cc

@@ -18,7 +18,6 @@
 #include "utils/error_injection.hh"
 #include "seastar/core/shared_future.hh"
 
-#include <chrono>
 #include <seastar/core/coroutine.hh>
 #include <seastar/core/when_all.hh>
 #include <seastar/core/sleep.hh>
@@ -203,11 +202,8 @@ void raft_group_registry::init_rpc_verbs() {
     });
 
     ser::raft_rpc_verbs::register_direct_fd_ping(&_ms,
-            [this] (const rpc::client_info&, rpc::opt_time_point timeout, raft::server_id dst) -> future<direct_fd_ping_reply> {
-
-        if (timeout && *timeout <= netw::messaging_service::clock_type::now()) {
-            throw timed_out_error{};
-        }
+            [this] (const rpc::client_info&, raft::server_id dst) -> future<direct_fd_ping_reply> {
+        // XXX: update address map here as well?
 
         if (_my_id != dst) {
             return make_ready_future<direct_fd_ping_reply>(direct_fd_ping_reply {
@@ -217,10 +213,19 @@ void raft_group_registry::init_rpc_verbs() {
             });
         }
 
-        return make_ready_future<direct_fd_ping_reply>(direct_fd_ping_reply {
-            .result = service::group_liveness_info{
-                .group0_alive = _group0_is_alive,
+        return container().invoke_on(0, [] (raft_group_registry& me) -> future<direct_fd_ping_reply> {
+            bool group0_alive = false;
+            if (me._group0_id) {
+                auto* group0_server = me.find_server(*me._group0_id);
+                if (group0_server && group0_server->is_alive()) {
+                    group0_alive = true;
+                }
             }
+            co_return direct_fd_ping_reply {
+                .result = service::group_liveness_info{
+                    .group0_alive = group0_alive,
+                }
+            };
         });
     });
 }
@@ -375,12 +380,6 @@ future<> raft_group_registry::start_server_for_group(raft_server_for_group new_g
         co_await server.abort();
         std::rethrow_exception(ex);
     }
-
-    if (gid == _group0_id) {
-        co_await container().invoke_on_all([] (raft_group_registry& rg) {
-            rg._group0_is_alive = true;
-        });
-    }
 }
 
 future<> raft_group_registry::abort_server(raft::group_id gid, sstring reason) {
@@ -390,18 +389,14 @@ future<> raft_group_registry::abort_server(raft::group_id gid, sstring reason) {
     if (const auto it = _servers.find(gid); it != _servers.end()) {
         auto& [gid, s] = *it;
         if (!s.aborted) {
-            if (gid == _group0_id) {
-                co_await container().invoke_on_all([] (raft_group_registry& rg) {
-                    rg._group0_is_alive = false;
-                });
-            }
             s.aborted = s.server->abort(std::move(reason))
                 .handle_exception([gid] (std::exception_ptr ex) {
                     rslog.warn("Failed to abort raft group server {}: {}", gid, ex);
                 });
         }
-        co_await s.aborted->get_future();
+        return s.aborted->get_future();
     }
+    return make_ready_future<>();
 }
 
 unsigned raft_group_registry::shard_for_group(const raft::group_id& gid) const {
@@ -522,13 +517,11 @@ future<> raft_server_with_timeouts::read_barrier(seastar::abort_source* as, std:
     }, "read_barrier", as, timeout);
 }
 
-future<bool> direct_fd_pinger::ping(direct_failure_detector::pinger::endpoint_id id, direct_failure_detector::clock::timepoint_t timeout, abort_source& as, direct_failure_detector::clock& c) {
+future<bool> direct_fd_pinger::ping(direct_failure_detector::pinger::endpoint_id id, abort_source& as) {
     auto dst_id = raft::server_id{id};
 
     try {
-        std::chrono::milliseconds timeout_ms = c.to_milliseconds(timeout);
-        netw::messaging_service::clock_type::time_point deadline = netw::messaging_service::clock_type::now() + timeout_ms;
-        auto reply = co_await ser::raft_rpc_verbs::send_direct_fd_ping(&_ms, locator::host_id{id}, deadline, as, dst_id);
+        auto reply = co_await ser::raft_rpc_verbs::send_direct_fd_ping(&_ms, locator::host_id{id}, as, dst_id);
         if (auto* wrong_dst = std::get_if<wrong_destination>(&reply.result)) {
             // FIXME: after moving to host_id based verbs we will not get `wrong_destination`
             //        any more since the connection will fail
@@ -561,11 +554,4 @@ future<> direct_fd_clock::sleep_until(direct_failure_detector::clock::timepoint_
     return sleep_abortable(t - n, as);
 }
 
-std::chrono::milliseconds direct_fd_clock::to_milliseconds(direct_failure_detector::clock::timepoint_t tp) const {
-    auto t = base::time_point{base::duration{tp}};
-    auto n = base::now();
-    return std::chrono::duration_cast<std::chrono::milliseconds>(t - n);
-}
-
-
 } // end of namespace service

service/raft/raft_group_registry.hh

@@ -127,7 +127,6 @@ private:
     // My Raft ID. Shared between different Raft groups.
     raft::server_id _my_id;
 
-    bool _group0_is_alive = false;
 public:
     raft_group_registry(raft::server_id my_id, netw::messaging_service& ms,
             direct_failure_detector::failure_detector& fd);
@@ -182,9 +181,6 @@ public:
     unsigned shard_for_group(const raft::group_id& gid) const;
     shared_ptr<raft::failure_detector> failure_detector();
     direct_failure_detector::failure_detector& direct_fd() { return _direct_fd; }
-    bool is_group0_alive() const {
-        return _group0_is_alive;
-    }
 };
 
 // Implementation of `direct_failure_detector::pinger` which uses DIRECT_FD_PING verb for pinging.
@@ -202,7 +198,7 @@ public:
     direct_fd_pinger(const direct_fd_pinger&) = delete;
     direct_fd_pinger(direct_fd_pinger&&) = delete;
 
-    future<bool> ping(direct_failure_detector::pinger::endpoint_id id, direct_failure_detector::clock::timepoint_t timeout, abort_source& as, direct_failure_detector::clock& c) override;
+    future<bool> ping(direct_failure_detector::pinger::endpoint_id id, abort_source& as) override;
 };
 
 // XXX: find a better place to put this?
@@ -211,7 +207,6 @@ struct direct_fd_clock : public direct_failure_detector::clock {
 
     direct_failure_detector::clock::timepoint_t now() noexcept override;
     future<> sleep_until(direct_failure_detector::clock::timepoint_t tp, abort_source& as) override;
-    std::chrono::milliseconds to_milliseconds(direct_failure_detector::clock::timepoint_t tp) const override;
 };
 
 } // end of namespace service

service/storage_proxy.cc

@@ -1138,7 +1138,8 @@ private:
             topology_mutation_builder builder(guard.write_timestamp());
             topology_request_tracking_mutation_builder trbuilder(global_request_id, _sp._features.topology_requests_type_column);
             trbuilder.set_truncate_table_data(table_id)
-                     .set("done", false);
+                     .set("done", false)
+                     .set("start_time", db_clock::now());
 
             if (!_sp._features.topology_global_request_queue) {
                 builder.set_global_topology_request(global_topology_request::truncate_table)
@@ -6687,11 +6688,10 @@ storage_proxy::do_query_with_paxos(schema_ptr s,
         }
     };
 
-    auto request = std::make_unique<read_cas_request>();
-    auto* request_ptr = request.get();
+    auto request = seastar::make_shared<read_cas_request>();
 
-    return cas(std::move(s), std::move(cas_shard), *request_ptr, cmd, std::move(partition_ranges), std::move(query_options),
-            cl, db::consistency_level::ANY, timeout, cas_timeout, false).then([request = std::move(request)] (bool is_applied) mutable {
+    return cas(std::move(s), std::move(cas_shard), request, cmd, std::move(partition_ranges), std::move(query_options),
+            cl, db::consistency_level::ANY, timeout, cas_timeout, false).then([request] (bool is_applied) mutable {
         return make_ready_future<coordinator_query_result>(std::move(request->res));
     });
 }
@@ -6754,13 +6754,11 @@ static mutation_write_failure_exception read_failure_to_write(read_failure_excep
  * NOTE: `cmd` argument can be nullptr, in which case it's guaranteed that this function would not perform
  * any reads of committed values (in case user of the function is not interested in them).
  *
- * NOTE: The `request` object must be guaranteed to be alive until the returned future is resolved.
- *
  * WARNING: the function must be called on a shard that owns the key cas() operates on.
  * The cas_shard must be created *before* selecting the shard, to protect against
  * concurrent tablet migrations.
  */
-future<bool> storage_proxy::cas(schema_ptr schema, cas_shard cas_shard, cas_request& request, lw_shared_ptr<query::read_command> cmd,
+future<bool> storage_proxy::cas(schema_ptr schema, cas_shard cas_shard, shared_ptr<cas_request> request, lw_shared_ptr<query::read_command> cmd,
         dht::partition_range_vector partition_ranges, storage_proxy::coordinator_query_options query_options,
         db::consistency_level cl_for_paxos, db::consistency_level cl_for_learn,
         clock_type::time_point write_timeout, clock_type::time_point cas_timeout, bool write, cdc::per_request_options cdc_opts) {
@@ -6861,7 +6859,7 @@ future<bool> storage_proxy::cas(schema_ptr schema, cas_shard cas_shard, cas_requ
                 qr = std::move(cqr.query_result);
             }
 
-            auto mutation = request.apply(std::move(qr), cmd->slice, utils::UUID_gen::micros_timestamp(ballot), cdc_opts);
+            auto mutation = request->apply(std::move(qr), cmd->slice, utils::UUID_gen::micros_timestamp(ballot), cdc_opts);
             condition_met = true;
             if (!mutation) {
                 if (write) {

service/storage_proxy.hh

@@ -829,7 +829,7 @@ public:
         clock_type::time_point timeout,
         tracing::trace_state_ptr trace_state = nullptr);
 
-    future<bool> cas(schema_ptr schema, cas_shard cas_shard, cas_request& request, lw_shared_ptr<query::read_command> cmd,
+    future<bool> cas(schema_ptr schema, cas_shard cas_shard, shared_ptr<cas_request> request, lw_shared_ptr<query::read_command> cmd,
             dht::partition_range_vector partition_ranges, coordinator_query_options query_options,
             db::consistency_level cl_for_paxos, db::consistency_level cl_for_learn,
             clock_type::time_point write_timeout, clock_type::time_point cas_timeout, bool write = true, cdc::per_request_options cdc_opts = {});

service/storage_service.cc

@@ -4940,6 +4940,7 @@ future<> storage_service::do_clusterwide_vnodes_cleanup() {
             builder.queue_global_topology_request_id(request_id);
             topology_request_tracking_mutation_builder rtbuilder(request_id, _feature_service.topology_requests_type_column);
             rtbuilder.set("done", false)
+                     .set("start_time", db_clock::now())
                      .set("request_type", global_topology_request::cleanup);
             muts.push_back(rtbuilder.build());
         } else {
@@ -5264,6 +5265,7 @@ future<> storage_service::raft_check_and_repair_cdc_streams() {
                 topology_request_tracking_mutation_builder rtbuilder(request_id, _feature_service.topology_requests_type_column);
                 builder.queue_global_topology_request_id(request_id);
                 rtbuilder.set("done", false)
+                         .set("start_time", db_clock::now())
                          .set("request_type", global_topology_request::new_cdc_generation);
                 muts.push_back(rtbuilder.build());
             } else {

service/task_manager_module.cc

@@ -13,7 +13,6 @@
 #include "service/task_manager_module.hh"
 #include "tasks/task_handler.hh"
 #include "tasks/virtual_task_hint.hh"
-#include "utils/UUID_gen.hh"
 #include <seastar/coroutine/maybe_yield.hh>
 
 namespace service {
@@ -58,14 +57,9 @@ static std::optional<tasks::task_stats> maybe_make_task_stats(const locator::tab
         .kind = tasks::task_kind::cluster,
         .scope = get_scope(task_info.request_type),
         .state = tasks::task_manager::task_state::running,
-        .sequence_number = 0,
         .keyspace = schema->ks_name(),
         .table = schema->cf_name(),
-        .entity = "",
-        .shard = 0,
-        .creation_time = task_info.request_time,
-        .start_time = task_info.sched_time,
-        .end_time = db_clock::time_point{}
+        .start_time = task_info.request_time
     };
 }
 
@@ -231,8 +225,7 @@ static void update_status(const locator::tablet_task_info& task_info, tasks::tas
     sched_nr += task_info.sched_nr;
     status.type = locator::tablet_task_type_to_string(task_info.request_type);
     status.scope = get_scope(task_info.request_type);
-    status.creation_time = task_info.request_time;
-    status.start_time = task_info.sched_time;
+    status.start_time = task_info.request_time;
 }
 
 future<std::optional<status_helper>> tablet_virtual_task::get_status_helper(tasks::task_id id, tasks::virtual_task_hint hint) {

service/topology_coordinator.cc

@@ -956,7 +956,6 @@ class topology_coordinator : public endpoint_lifecycle_subscriber {
             req_entry = co_await _sys_ks.get_topology_request_entry(req_id, true);
             req = std::get<global_topology_request>(req_entry.request_type);
         }
-        
         switch (req) {
         case global_topology_request::new_cdc_generation: {
             rtlogger.info("new CDC generation requested");
@@ -976,14 +975,9 @@ class topology_coordinator : public endpoint_lifecycle_subscriber {
                    .set_global_topology_request(req)
                    .set_global_topology_request_id(req_id)
                    .drop_first_global_topology_request_id(_topo_sm._topology.global_requests_queue, req_id);
-            
-            // Set start_time when we begin executing the request
-            topology_request_tracking_mutation_builder rtbuilder(req_id);
-            rtbuilder.set("start_time", db_clock::now());
-            
             auto reason = ::format(
                 "insert CDC generation data (UUID: {})", gen_uuid);
-            co_await update_topology_state(std::move(guard), {std::move(mutation), builder.build(), rtbuilder.build()}, reason);
+            co_await update_topology_state(std::move(guard), {std::move(mutation), builder.build()}, reason);
         }
         break;
         case global_topology_request::cleanup:
@@ -1074,9 +1068,7 @@ class topology_coordinator : public endpoint_lifecycle_subscriber {
                                                          .del_global_topology_request_id()
                                                          .drop_first_global_topology_request_id(_topo_sm._topology.global_requests_queue, req_id)
                                                          .build()));
-            // Set start_time when we begin executing the request and mark as done
             updates.push_back(canonical_mutation(topology_request_tracking_mutation_builder(req_id)
-                                                         .set("start_time", db_clock::now())
                                                          .done(error)
                                                          .build()));
 
@@ -1096,12 +1088,7 @@ class topology_coordinator : public endpoint_lifecycle_subscriber {
                    .set_global_topology_request_id(req_id)
                    .drop_first_global_topology_request_id(_topo_sm._topology.global_requests_queue, req_id)
                    .set_session(session_id(req_id));
-            
-            // Set start_time when we begin executing the request
-            topology_request_tracking_mutation_builder rtbuilder(req_id);
-            rtbuilder.set("start_time", db_clock::now());
-            
-            co_await update_topology_state(std::move(guard), {builder.build(), rtbuilder.build()}, "TRUNCATE TABLE requested");
+            co_await update_topology_state(std::move(guard), {builder.build()}, "TRUNCATE TABLE requested");
         }
         break;
         }
@@ -3292,11 +3279,6 @@ class topology_coordinator : public endpoint_lifecycle_subscriber {
             topology_mutation_builder builder(guard.write_timestamp());
             builder.del_global_topology_request();
             if (_feature_service.topology_global_request_queue) {
-                // Set start_time when we begin executing the request
-                topology_request_tracking_mutation_builder start_rtbuilder(*global_request_id);
-                start_rtbuilder.set("start_time", db_clock::now());
-                muts.emplace_back(start_rtbuilder.build());
-                
                 topology_request_tracking_mutation_builder rtbuilder(*global_request_id);
                 builder.del_global_topology_request_id()
                        .drop_first_global_topology_request_id(_topo_sm._topology.global_requests_queue, *global_request_id);

sstables/index_reader.hh

@@ -57,10 +57,7 @@ public:
     index_list indexes;
 
     index_consumer(logalloc::region& r, schema_ptr s)
-        : _s(s)
-        , _alloc_section(abstract_formatter([s] (fmt::format_context& ctx) {
-            fmt::format_to(ctx.out(), "index_consumer {}.{}", s->ks_name(), s->cf_name());
-        }))
+        : _s(std::move(s))
         , _region(r)
     { }
 
@@ -788,9 +785,6 @@ public:
                                                       _sstable->manager().get_cache_tracker().region(),
                                                       _sstable->manager().get_cache_tracker().get_partition_index_cache_stats()))
         , _index_cache(caching ? *_sstable->_index_cache : *_local_index_cache)
-        , _alloc_section(abstract_formatter([sst = _sstable] (fmt::format_context& ctx) {
-            fmt::format_to(ctx.out(), "index_reader {}", sst->get_filename());
-        }))
         , _region(_sstable->manager().get_cache_tracker().region())
         , _use_caching(caching)
         , _single_page_read(single_partition_read) // all entries for a given partition are within a single page

sstables/mx/bsearch_clustered_cursor.hh

@@ -284,9 +284,6 @@ public:
         , _clustering_parser(s, permit, _ctr.clustering_column_value_fix_legths(), true)
         , _block_parser(s, permit, _ctr.clustering_column_value_fix_legths())
         , _permit(std::move(permit))
-        , _as(abstract_formatter([s] (fmt::format_context& ctx) {
-            fmt::format_to(ctx.out(), "cached_promoted_index {}.{}", s.ks_name(), s.cf_name());
-        }))
     { }
 
     ~cached_promoted_index() {

tasks/task_handler.cc

@@ -10,7 +10,6 @@
 #include "tasks/task_handler.hh"
 #include "tasks/virtual_task_hint.hh"
 #include "utils/overloaded_functor.hh"
-#include "utils/UUID_gen.hh"
 
 #include <seastar/core/with_timeout.hh>
 
@@ -20,11 +19,6 @@ namespace tasks {
 
 using task_status_variant = std::variant<tasks::task_manager::foreign_task_ptr, tasks::task_manager::task::task_essentials>;
 
-static db_clock::time_point get_creation_time_from_task_id(task_id id) {
-    // Task IDs are timeuuids (version 1 UUIDs), so we can extract the timestamp from them
-    return db_clock::time_point(utils::UUID_gen::unix_timestamp(id.uuid()));
-}
-
 static future<task_status> get_task_status(task_manager::task_ptr task) {
     auto host_id = task->get_module()->get_task_manager().get_host_id();
     auto local_task_status = task->get_status();
@@ -35,7 +29,6 @@ static future<task_status> get_task_status(task_manager::task_ptr task) {
         .scope = local_task_status.scope,
         .state = local_task_status.state,
         .is_abortable = task->is_abortable(),
-        .creation_time = get_creation_time_from_task_id(local_task_status.id),
         .start_time = local_task_status.start_time,
         .end_time = local_task_status.end_time,
         .error = local_task_status.error,
@@ -180,7 +173,6 @@ future<utils::chunked_vector<task_status>> task_handler::get_status_recursively(
                     .scope = task.task_status.scope,
                     .state = task.task_status.state,
                     .is_abortable = task.abortable,
-                    .creation_time = get_creation_time_from_task_id(task.task_status.id),
                     .start_time = task.task_status.start_time,
                     .end_time = task.task_status.end_time,
                     .error = task.task_status.error,

tasks/task_handler.hh

@@ -26,7 +26,6 @@ struct task_status {
     std::string scope;
     task_manager::task_state state;
     is_abortable is_abortable;
-    db_clock::time_point creation_time;
     db_clock::time_point start_time;
     db_clock::time_point end_time;
     std::string error;
@@ -52,7 +51,6 @@ struct task_stats {
     std::string table;
     std::string entity;
     unsigned shard;
-    db_clock::time_point creation_time;
     db_clock::time_point start_time;
     db_clock::time_point end_time;
 };

tasks/task_manager.cc

@@ -21,7 +21,6 @@
 #include "utils/assert.hh"
 #include "utils/chunked_vector.hh"
 #include "utils/overloaded_functor.hh"
-#include "utils/UUID_gen.hh"
 #include "service/storage_service.hh"
 #include "tasks/task_handler.hh"
 #include "task_manager.hh"
@@ -560,7 +559,6 @@ future<utils::chunked_vector<task_stats>> task_manager::module::get_stats(is_int
                 .table = task->get_status().table,
                 .entity = task->get_status().entity,
                 .shard = task->get_status().shard,
-                .creation_time = db_clock::time_point(utils::UUID_gen::unix_timestamp(task->id().uuid())),
                 .start_time = task->get_status().start_time,
                 .end_time = task->get_status().end_time,
             });

test/alternator/test_batch.py

@@ -205,7 +205,7 @@ def test_batch_write_invalid_operation(test_table_s):
 
 # In test_item.py we have a bunch of test_empty_* tests on different ways to
 # create an empty item (which in Scylla requires the special CQL row marker
-# to be supported correctly). BatchWriteItem provides yet another way of
+# to be supported correctly). BatchWriteItems provides yet another way of
 # creating items, so check the empty case here too:
 def test_empty_batch_write(test_table):
     p = random_string()
@@ -214,7 +214,7 @@ def test_empty_batch_write(test_table):
         batch.put_item({'p': p, 'c': c})
     assert test_table.get_item(Key={'p': p, 'c': c}, ConsistentRead=True)['Item'] == {'p': p, 'c': c}
 
-# Test that BatchWriteItem allows writing to multiple tables in one operation
+# Test that BatchWriteItems allows writing to multiple tables in one operation
 def test_batch_write_multiple_tables(test_table_s, test_table):
     p1 = random_string()
     c1 = random_string()

test/cluster/conftest.py

@@ -13,8 +13,7 @@ import ssl
 import tempfile
 import platform
 import urllib.parse
-from concurrent.futures.thread import ThreadPoolExecutor
-from multiprocessing import Event
+from multiprocessing import Event, Process
 from pathlib import Path
 from typing import TYPE_CHECKING
 from test.pylib.runner import testpy_test_fixture_scope
@@ -187,14 +186,15 @@ async def manager_api_sock_path(request: pytest.FixtureRequest, testpy_test: Tes
                 await asyncio.get_running_loop().run_in_executor(None, stop_event.wait)
             finally:
                 await mgr.stop()
-        with ThreadPoolExecutor(max_workers=1) as executor:
-            future = executor.submit(asyncio.run, run_manager())
-            start_event.wait()
 
-            yield sock_path
+        manager_process = Process(target=lambda: asyncio.run(run_manager()))
+        manager_process.start()
+        start_event.wait()
 
-            stop_event.set()
-            future.result()
+        yield sock_path
+
+        stop_event.set()
+        manager_process.join()
 
 
 @pytest.fixture(scope=testpy_test_fixture_scope)

test/cluster/tasks/task_manager_types.py

@@ -38,7 +38,6 @@ class TaskStats(NamedTuple):
     entity: str
     sequence_number: SequenceNum
     shard: int
-    creation_time: str
     start_time: str
     end_time: str
 
@@ -55,7 +54,6 @@ class TaskStatus(NamedTuple):
     entity: str
     sequence_number: SequenceNum
     is_abortable: bool
-    creation_time: str
     start_time: str
     end_time: str
     error: str

test/lib/cql_test_env.cc

@@ -881,7 +881,7 @@ private:
             _fd.start(
                 std::ref(_fd_pinger), std::ref(fd_clock),
                 service::direct_fd_clock::base::duration{std::chrono::milliseconds{100}}.count(),
-                service::direct_fd_clock::base::duration{std::chrono::milliseconds{600}}.count(), gcfg.gossip_scheduling_group).get();
+                service::direct_fd_clock::base::duration{std::chrono::milliseconds{600}}.count()).get();
 
             auto stop_fd = defer_verbose_shutdown("direct failure detector", [this] {
                 _fd.stop().get();

test/perf/perf_row_cache_update.cc

@@ -30,7 +30,7 @@ static const int cell_size = 128;
 static bool cancelled = false;
 
 template<typename MutationGenerator>
-void run_test(const sstring& name, schema_ptr s, MutationGenerator&& gen, std::function<mutation()> before_flush = {}) {
+void run_test(const sstring& name, schema_ptr s, MutationGenerator&& gen) {
     tests::reader_concurrency_semaphore_wrapper semaphore;
     cache_tracker tracker;
     row_cache cache(s, make_empty_snapshot_source(), tracker, is_continuous::yes);
@@ -58,10 +58,6 @@ void run_test(const sstring& name, schema_ptr s, MutationGenerator&& gen, std::f
                     return;
                 }
             }
-            if (before_flush) {
-                mutation m = before_flush();
-                mt->apply(m);
-            }
         });
         memtable_slm.stop();
         std::cout << format("Memtable fill took {:.6f} [ms], {}", fill_d.count() * 1000, memtable_slm) << std::endl;
@@ -185,43 +181,6 @@ static void test_partition_with_lots_of_small_rows() {
     });
 }
 
-static void test_partition_with_lots_of_small_rows_covered_by_tombstone() {
-    auto s = schema_builder("ks", "cf")
-        .with_column("pk", uuid_type, column_kind::partition_key)
-        .with_column("ck", int32_type, column_kind::clustering_key)
-        .with_column("v1", bytes_type, column_kind::regular_column)
-        .with_column("v2", bytes_type, column_kind::regular_column)
-        .with_column("v3", bytes_type, column_kind::regular_column)
-        .build();
-
-    auto pk = dht::decorate_key(*s, partition_key::from_single_value(*s,
-        serialized(utils::UUID_gen::get_time_UUID())));
-    int ck_idx = 0;
-    int flush_ck_idx = 0;
-
-    run_test("Large partition, lots of small rows covered by single tombstone", s, [&] {
-        mutation m(s, pk);
-        auto val = data_value(bytes(bytes::initialized_later(), cell_size));
-        auto ck = clustering_key::from_single_value(*s, serialized(ck_idx++));
-        auto ts = api::new_timestamp();
-        m.set_clustered_cell(ck, "v1", val, ts);
-        m.set_clustered_cell(ck, "v2", val, ts);
-        m.set_clustered_cell(ck, "v3", val, ts);
-        return m;
-    }, [&] { // before_flush
-        // Delete key range [-inf, flush_ck_idx)
-        std::cout << "Generated " << (ck_idx - flush_ck_idx) << " rows\n";
-        auto m = mutation(s, pk);
-        auto ck = clustering_key::from_single_value(*s, serialized(flush_ck_idx));
-        m.partition().apply_row_tombstone(*s, range_tombstone(
-                position_in_partition_view::before_all_clustered_rows(),
-                position_in_partition_view::before_key(ck),
-                tombstone(api::new_timestamp(), gc_clock::now())));
-        flush_ck_idx = ck_idx;
-        return m;
-    });
-}
-
 static void test_partition_with_few_small_rows() {
     auto s = schema_builder("ks", "cf")
         .with_column("pk", uuid_type, column_kind::partition_key)
@@ -316,7 +275,6 @@ int scylla_row_cache_update_main(int argc, char** argv) {
                 cancelled = true;
             });
             logalloc::prime_segment_pool(memory::stats().total_memory(), memory::min_free_memory()).get();
-            test_partition_with_lots_of_small_rows_covered_by_tombstone();
             test_small_partitions();
             test_partition_with_few_small_rows();
             test_partition_with_lots_of_small_rows();

test/raft/failure_detector_test.cc

@@ -31,7 +31,7 @@ struct test_pinger: public direct_failure_detector::pinger {
     std::unordered_map<endpoint_id, size_t> _pings;
     bool _block = false;
 
-    virtual future<bool> ping(endpoint_id ep, direct_failure_detector::clock::timepoint_t timeout, abort_source& as, direct_failure_detector::clock& c) override {
+    virtual future<bool> ping(endpoint_id ep, abort_source& as) override {
         bool ret = false;
         co_await invoke_abortable_on(0, [this, ep, &ret] (abort_source& as) -> future<> {
             ++_pings[ep];
@@ -91,9 +91,6 @@ struct test_clock : public direct_failure_detector::clock {
             throw sleep_aborted{};
         }
     }
-    virtual std::chrono::milliseconds to_milliseconds(timepoint_t tp) const override {
-        throw std::logic_error("to_milliseconds is not implemented");
-    }
 };
 
 struct test_listener : public direct_failure_detector::listener {
@@ -132,7 +129,7 @@ SEASTAR_TEST_CASE(failure_detector_test) {
     test_pinger pinger;
     test_clock clock;
     sharded<direct_failure_detector::failure_detector> fd;
-    co_await fd.start(std::ref(pinger), std::ref(clock), 10, 30, seastar::current_scheduling_group());
+    co_await fd.start(std::ref(pinger), std::ref(clock), 10, 30);
 
     test_listener l1, l2;
     auto sub1 = co_await fd.local().register_listener(l1, 95);

test/raft/randomized_nemesis_test.cc

@@ -1065,7 +1065,7 @@ public:
     }
 
     // Can be called on any shard.
-    future<bool> ping(direct_failure_detector::pinger::endpoint_id id, direct_failure_detector::clock::timepoint_t timeout, abort_source& as, direct_failure_detector::clock& c) override {
+    future<bool> ping(direct_failure_detector::pinger::endpoint_id id, abort_source& as) override {
         try {
             co_await invoke_abortable_on(0, [this, id] (abort_source& as) {
                 return _rpc.ping(raft::server_id{id}, as);
@@ -1127,10 +1127,6 @@ public:
             throw sleep_aborted{};
         }
     }
-
-    virtual std::chrono::milliseconds to_milliseconds(timepoint_t tp) const override {
-        throw std::logic_error("to_milliseconds is not implemented");
-    }
 };
 
 class direct_fd_listener : public raft::failure_detector, public direct_failure_detector::listener {
@@ -1440,7 +1436,7 @@ public:
         // _fd_service must be started before raft server,
         // because as soon as raft server is started, it may start adding endpoints to the service.
         // _fd_service is using _server's RPC, but not until the first endpoint is added.
-        co_await _fd_service->start(std::ref(*_fd_pinger), std::ref(*_fd_clock), fd_ping_period.count(), fd_ping_timeout.count(), seastar::current_scheduling_group());
+        co_await _fd_service->start(std::ref(*_fd_pinger), std::ref(*_fd_clock), fd_ping_period.count(), fd_ping_timeout.count());
         _fd_subscription.emplace(co_await _fd_service->local().register_listener(*_fd_listener, _fd_convict_threshold.count()));
         co_await _server->start();
     }

tools/scylla-nodetool.cc

@@ -3174,7 +3174,7 @@ void tasks_print_status(const rjson::value& res) {
     auto status = res.GetObject();
     for (const auto& x: status) {
         if (x.value.IsString()) {
-            if (strcmp(x.name.GetString(), "creation_time") == 0 || strcmp(x.name.GetString(), "start_time") == 0 || strcmp(x.name.GetString(), "end_time") == 0) {
+            if (strcmp(x.name.GetString(), "start_time") == 0 || strcmp(x.name.GetString(), "end_time") == 0) {
                 fmt::print("{}: {}\n", x.name.GetString(), get_time(x.value.GetString()));
             } else {
                 fmt::print("{}: {}\n", x.name.GetString(), x.value.GetString());
@@ -3226,7 +3226,6 @@ void tasks_add_tree_to_statuses_lists(Tabulate& table, const rjson::value& res)
                 rjson::to_string_view(status["scope"]),
                 rjson::to_string_view(status["state"]),
                 status["is_abortable"].GetBool(),
-                get_time(rjson::to_string_view(status["creation_time"])),
                 get_time(rjson::to_string_view(status["start_time"])),
                 get_time(rjson::to_string_view(status["end_time"])),
                 rjson::to_string_view(status["error"]),
@@ -3246,7 +3245,7 @@ void tasks_add_tree_to_statuses_lists(Tabulate& table, const rjson::value& res)
 void tasks_print_trees(const std::vector<rjson::value>& res) {
     Tabulate table;
     table.add("id", "type", "kind", "scope", "state",
-        "is_abortable", "creation_time", "start_time", "end_time", "error", "parent_id",
+        "is_abortable", "start_time", "end_time", "error", "parent_id",
         "sequence_number", "shard", "keyspace", "table", "entity",
         "progress_units", "total", "completed", "children_ids");
 
@@ -3260,7 +3259,7 @@ void tasks_print_trees(const std::vector<rjson::value>& res) {
 void tasks_print_stats_list(const rjson::value& res) {
     auto stats = res.GetArray();
     Tabulate table;
-    table.add("task_id", "type", "kind", "scope", "state", "sequence_number", "keyspace", "table", "entity", "shard", "creation_time", "start_time", "end_time");
+    table.add("task_id", "type", "kind", "scope", "state", "sequence_number", "keyspace", "table", "entity", "shard", "start_time", "end_time");
     for (auto& element : stats) {
         const auto& s = element.GetObject();
 
@@ -3274,7 +3273,6 @@ void tasks_print_stats_list(const rjson::value& res) {
                 rjson::to_string_view(s["table"]),
                 rjson::to_string_view(s["entity"]),
                 s["shard"].GetUint(),
-                get_time(rjson::to_string_view(s["creation_time"])),
                 get_time(rjson::to_string_view(s["start_time"])),
                 get_time(rjson::to_string_view(s["end_time"])));
     }

utils/abstract_formatter.hh

@@ -1,41 +0,0 @@
-/*
- * Copyright (C) 2025-present ScyllaDB
- */
-
-/*
- * SPDX-License-Identifier: LicenseRef-ScyllaDB-Source-Available-1.0
- */
-
-#pragma once
-
-#include <fmt/format.h>
-#include <functional>
-
-/// Type-erased formatter.
-/// Allows passing formattable objects without exposing their types.
-class abstract_formatter {
-    std::function<void(fmt::format_context&)> _formatter;
-public:
-    abstract_formatter() = default;
-
-    template<typename Func>
-    requires std::is_invocable_v<Func, fmt::format_context&>
-    explicit abstract_formatter(Func&& f) : _formatter(std::forward<Func>(f)) {}
-
-    fmt::format_context::iterator format_to(fmt::format_context& ctx) const {
-        if (_formatter) {
-            _formatter(ctx);
-        }
-        return ctx.out();
-    }
-
-    explicit operator bool() const noexcept { return bool(_formatter); }
-};
-
-template <> struct fmt::formatter<abstract_formatter> {
-    constexpr auto parse(format_parse_context& ctx) { return ctx.begin(); }
-
-    auto format(const abstract_formatter& formatter, fmt::format_context& ctx) const {
-        return formatter.format_to(ctx);
-    }
-};

utils/cached_file.hh

@@ -461,9 +461,6 @@ public:
         , _metrics(m)
         , _lru(l)
         , _region(reg)
-        , _as(abstract_formatter([this] (fmt::format_context& ctx) {
-            fmt::format_to(ctx.out(), "cached_file {}", _file_name);
-        }))
         , _cache(page_idx_less_comparator())
         , _size(size)
     {

utils/logalloc.cc

@@ -2948,10 +2948,10 @@ void allocating_section::on_alloc_failure(logalloc::region& r) {
     r.allocator().invalidate_references();
     if (r.get_tracker().get_impl().segment_pool().allocation_failure_flag()) {
         _lsa_reserve *= 2;
-        llogger.info("LSA allocation failure, increasing reserve in section {} ({}) to {} segments; trace: {}", fmt::ptr(this), _name, _lsa_reserve, current_backtrace());
+        llogger.info("LSA allocation failure, increasing reserve in section {} to {} segments; trace: {}", fmt::ptr(this), _lsa_reserve, current_backtrace());
     } else {
         _std_reserve *= 2;
-        llogger.info("Standard allocator failure, increasing head-room in section {} ({}) to {} [B]; trace: {}", fmt::ptr(this), _name, _std_reserve, current_backtrace());
+        llogger.info("Standard allocator failure, increasing head-room in section {} to {} [B]; trace: {}", fmt::ptr(this), _std_reserve, current_backtrace());
     }
     reserve(r.get_tracker().get_impl());
 }

utils/logalloc.hh

@@ -17,7 +17,6 @@
 #include "utils/assert.hh"
 #include "utils/entangled.hh"
 #include "utils/memory_limit_reached.hh"
-#include "utils/abstract_formatter.hh"
 
 namespace logalloc {
 
@@ -443,7 +442,6 @@ class allocating_section {
     size_t _minimum_lsa_emergency_reserve = 0;
     int64_t _remaining_std_bytes_until_decay = s_bytes_per_decay;
     int _remaining_lsa_segments_until_decay = s_segments_per_decay;
-    abstract_formatter _name;
 private:
     struct guard {
         tracker::impl& _tracker;
@@ -455,8 +453,6 @@ private:
     void maybe_decay_reserve() noexcept;
     void on_alloc_failure(logalloc::region&);
 public:
-    allocating_section() = default;
-    explicit allocating_section(abstract_formatter name) : _name(std::move(name)) {}
 
     void set_lsa_reserve(size_t) noexcept;
     void set_std_reserve(size_t) noexcept;