repair: remove CMR block_id requests

Author: AshwinSekar

core/src/repair/malicious_repair_handler.rs

@@ -6,7 +6,7 @@ use {
         blockstore::Blockstore,
         shred::{Nonce, SIZE_OF_DATA_SHRED_HEADERS},
     },
-    solana_perf::packet::{Packet, PacketBatch, PacketBatchRecycler},
+    solana_perf::packet::Packet,
     std::{net::SocketAddr, sync::Arc},
 };
 
@@ -64,17 +64,4 @@ impl RepairHandler for MaliciousRepairHandler {
         }
         repair_response_packet_from_bytes(shred, dest, nonce)
     }
-
-    fn run_orphan(
-        &self,
-        _recycler: &PacketBatchRecycler,
-        _from_addr: &SocketAddr,
-        _slot: Slot,
-        _block_id: Option<Hash>,
-        _max_responses: usize,
-        _nonce: Nonce,
-    ) -> Option<PacketBatch> {
-        // Malicious orphan response will come later
-        None
-    }
 }

core/src/repair/repair_handler.rs

@@ -15,7 +15,6 @@ use {
     solana_ledger::{
         ancestor_iterator::{AncestorIterator, AncestorIteratorWithHash},
         blockstore::Blockstore,
-        blockstore_meta::BlockLocation,
         shred::Nonce,
     },
     solana_perf::packet::{Packet, PacketBatch, PacketBatchRecycler, PinnedPacketBatch},
@@ -61,30 +60,41 @@ pub trait RepairHandler {
         )
     }
 
+    fn run_window_request_for_block_id(
+        &self,
+        recycler: &PacketBatchRecycler,
+        from_addr: &SocketAddr,
+        slot: Slot,
+        shred_index: u64,
+        block_id: Hash,
+        nonce: Nonce,
+    ) -> Option<PacketBatch> {
+        self.run_window_request(
+            recycler,
+            from_addr,
+            slot,
+            shred_index,
+            Some(block_id),
+            nonce,
+        )
+    }
+
     fn run_highest_window_request(
         &self,
         recycler: &PacketBatchRecycler,
         from_addr: &SocketAddr,
         slot: Slot,
         highest_index: u64,
-        block_id: Option<Hash>,
         nonce: Nonce,
     ) -> Option<PacketBatch> {
-        let location = match block_id {
-            None => BlockLocation::Original,
-            Some(block_id) => self
-                .blockstore()
-                .get_block_location(slot, block_id)
-                .expect("Unable to fetch block location from blockstore")?,
-        };
         let meta = self
             .blockstore()
-            .meta_from_location(slot, location)
+            .meta(slot)
             .expect("Unable to fetch slot meta from blockstore")?;
         if meta.received > highest_index {
             // meta.received must be at least 1 by this point
             let packet =
-                self.repair_response_packet(slot, meta.received - 1, block_id, from_addr, nonce)?;
+                self.repair_response_packet(slot, meta.received - 1, None, from_addr, nonce)?;
             return Some(
                 PinnedPacketBatch::new_unpinned_with_recycler_data(
                     recycler,
@@ -102,10 +112,29 @@ pub trait RepairHandler {
         recycler: &PacketBatchRecycler,
         from_addr: &SocketAddr,
         slot: Slot,
-        block_id: Option<Hash>,
         max_responses: usize,
         nonce: Nonce,
-    ) -> Option<PacketBatch>;
+    ) -> Option<PacketBatch> {
+        let mut res =
+            PinnedPacketBatch::new_unpinned_with_recycler(recycler, max_responses, "run_orphan");
+        // Try to find the next "n" parent slots of the input slot
+        let packets = std::iter::successors(self.blockstore().meta(slot).ok()?, |meta| {
+            self.blockstore().meta(meta.parent_slot?).ok()?
+        })
+        .map_while(|meta| {
+            repair_response::repair_response_packet(
+                self.blockstore(),
+                meta.slot,
+                meta.received.checked_sub(1u64)?,
+                from_addr,
+                nonce,
+            )
+        });
+        for packet in packets.take(max_responses) {
+            res.push(packet);
+        }
+        (!res.is_empty()).then_some(res.into())
+    }
 
     fn run_ancestor_hashes(
         &self,

core/src/repair/repair_service.rs

@@ -162,9 +162,7 @@ pub struct RepairStats {
     pub shred: RepairStatsGroup,
     pub highest_shred: RepairStatsGroup,
     pub orphan: RepairStatsGroup,
-    pub orphan_for_block_id: RepairStatsGroup,
     pub shred_for_block_id: RepairStatsGroup,
-    pub highest_shred_for_block_id: RepairStatsGroup,
     pub get_best_orphans_us: u64,
     pub get_best_shreds_us: u64,
 }
@@ -174,18 +172,14 @@ impl RepairStats {
         let repair_total = self.shred.count
             + self.highest_shred.count
             + self.orphan.count
-            + self.orphan_for_block_id.count
-            + self.shred_for_block_id.count
-            + self.highest_shred_for_block_id.count;
+            + self.shred_for_block_id.count;
         let slot_to_count: Vec<_> = self
             .shred
             .slot_pubkeys
             .iter()
             .chain(self.highest_shred.slot_pubkeys.iter())
             .chain(self.orphan.slot_pubkeys.iter())
-            .chain(self.orphan_for_block_id.slot_pubkeys.iter())
             .chain(self.shred_for_block_id.slot_pubkeys.iter())
-            .chain(self.highest_shred_for_block_id.slot_pubkeys.iter())
             .map(|(slot, slot_repairs)| (slot, slot_repairs.pubkey_repairs.values().sum::<u64>()))
             .collect();
         info!("repair_stats: {slot_to_count:?}");
@@ -197,9 +191,7 @@ impl RepairStats {
                 ("shred-count", self.shred.count, i64),
                 ("highest-shred-count", self.highest_shred.count, i64),
                 ("orphan-count", self.orphan.count, i64),
-                ("orphan-for-block-id-count", self.orphan_for_block_id.count, i64),
                 ("shred-for-block-id-count", self.shred_for_block_id.count, i64),
-                ("highest-shred-for-block-id-count", self.highest_shred_for_block_id.count, i64),
                 ("shred-slot-max", nonzero_num(self.shred.max), Option<i64>),
                 ("shred-slot-min", nonzero_num(self.shred.min), Option<i64>),
                 ("repair-highest-slot", self.highest_shred.max, i64), // deprecated