Merge branch 'main' of https://github.com/firedancer-io/firedancer

Author: ibhatt-jumptrading

agave

@@ -104,6 +104,16 @@ FD_STATIC_ASSERT( sizeof(fd_entry_batch_meta_t)==56UL, poh_shred_mtu );
 
 #define FD_SHRED_ADD_SHRED_EXTRA_RETVAL_CNT 2
 
+/* Number of entries in the block_ids table. Each entry is 32 byte.
+   This table is used to keep track of block ids that we create
+   when we're leader, so that we can access them whenever we need
+   a *parent* block id for a new block. Larger table allows to
+   retrieve older parent block ids. Currently it's set for worst
+   case parent offset of USHORT_MAX (max allowed in a shred),
+   making the total table 2MiB.
+   See also comment on chained_merkle_root. */
+#define BLOCK_IDS_TABLE_CNT USHORT_MAX
+
 /* See note on parallelization above. Currently we process all batches in tile 0. */
 #if 1
 #define SHOULD_PROCESS_THESE_SHREDS ( ctx->round_robin_id==0 )
@@ -236,7 +246,8 @@ typedef struct {
   /* too large to be left in the stack */
   fd_shred_dest_idx_t scratchpad_dests[ FD_SHRED_DEST_MAX_FANOUT*(FD_REEDSOL_DATA_SHREDS_MAX+FD_REEDSOL_PARITY_SHREDS_MAX) ];
 
-  uchar chained_merkle_root[ FD_SHRED_MERKLE_ROOT_SZ ];
+  uchar * chained_merkle_root;
+  uchar block_ids[ BLOCK_IDS_TABLE_CNT ][ FD_SHRED_MERKLE_ROOT_SZ ];
 } fd_shred_ctx_t;
 
 FD_FN_CONST static inline ulong
@@ -449,16 +460,46 @@ during_frag( fd_shred_ctx_t * ctx,
         ctx->batch_cnt = 0UL;
         ctx->slot      = target_slot;
 
-        /* Only copy parent_block_id to chained_merkle_root at the beginning
-           of a new slot*/
+        /* At the beginning of a new slot, prepare chained_merkle_root.
+           chained_merkle_root is initialized at the block_id of the parent
+           block, there's two cases:
+
+           1. block_id is passed in by the poh tile:
+              - it's always passed when parent block had a different leader
+              - it may be passed when we were leader for parent block (there
+                are race conditions when it's not passed)
+
+           2. block_id is taken from block_ids table if we were the leader
+              for the parent block (when we were NOT the leader, because of
+              equivocation, we can't store block_id in the table)
+
+           chained_merkle_root is stored in block_ids table at target_slot
+           and it's progressively updated as more microblocks are received.
+           As a result, when we move to a new slot, the block_ids table at
+           the old slot will contain the block_id.
+
+           The block_ids table is designed to protect against the race condition
+           case in 1., therefore the table may not be set in some cases, e.g. if
+           a validator (re)starts, but in those cases we don't expect the race
+           condition to apply. */
+        ctx->chained_merkle_root = ctx->block_ids[ target_slot % BLOCK_IDS_TABLE_CNT ];
         if( FD_UNLIKELY( SHOULD_PROCESS_THESE_SHREDS ) ) {
-          /* chained_merkle_root is set as the merkle root of the last FEC set
-            of the parent block (and passed in by POH tile) */
           if( FD_LIKELY( entry_meta->parent_block_id_valid ) ) {
+            /* 1. Initialize chained_merkle_root sent from poh tile */
             memcpy( ctx->chained_merkle_root, entry_meta->parent_block_id, FD_SHRED_MERKLE_ROOT_SZ );
           } else {
-            ctx->metrics->invalid_block_id_cnt++;
-            memset( ctx->chained_merkle_root, 0, FD_SHRED_MERKLE_ROOT_SZ );
+            ulong parent_slot = target_slot - entry_meta->parent_offset;
+            fd_epoch_leaders_t const * lsched = fd_stake_ci_get_lsched_for_slot( ctx->stake_ci, parent_slot );
+            fd_pubkey_t const * slot_leader = fd_epoch_leaders_get( lsched, parent_slot );
+
+            if( lsched && slot_leader && fd_memeq( slot_leader, ctx->identity_key, sizeof(fd_pubkey_t) ) ) {
+              /* 2. Initialize chained_merkle_root from block_ids table, if we were the leader */
+              memcpy( ctx->chained_merkle_root, ctx->block_ids[ parent_slot % BLOCK_IDS_TABLE_CNT ], FD_SHRED_MERKLE_ROOT_SZ );
+            } else {
+              /* This should never happen, log a metric and set chained_merkle_root to 0 */
+              ctx->metrics->invalid_block_id_cnt++;
+              memset( ctx->chained_merkle_root, 0, FD_SHRED_MERKLE_ROOT_SZ );
+            }
           }
         }
       }
@@ -921,7 +962,7 @@ after_frag( fd_shred_ctx_t *    ctx,
 
       long shacq_start, shacq_end, shrel_end;
       FD_STORE_SHACQ_TIMED( ctx->store, shacq_start, shacq_end );
-      fd_store_fec_t * fec = fd_store_insert( ctx->store, (uint)ctx->round_robin_id, (fd_hash_t *)fd_type_pun( &out_merkle_root ) );
+      fd_store_fec_t * fec = fd_store_insert( ctx->store, ctx->round_robin_id, (fd_hash_t *)fd_type_pun( &out_merkle_root ) );
       FD_STORE_SHREL_TIMED( ctx->store, shrel_end );
 
       for( ulong i=0UL; i<set->data_shred_cnt; i++ ) {
@@ -1303,6 +1344,8 @@ unprivileged_init( fd_topo_t *      topo,
   ulong scratch_top = FD_SCRATCH_ALLOC_FINI( l, 1UL );
   if( FD_UNLIKELY( scratch_top > (ulong)scratch + scratch_footprint( tile ) ) )
     FD_LOG_ERR(( "scratch overflow %lu %lu %lu", scratch_top - (ulong)scratch - scratch_footprint( tile ), scratch_top, (ulong)scratch + scratch_footprint( tile ) ));
+
+  memset( ctx->block_ids, 0, sizeof(ctx->block_ids) );
 }
 
 static ulong

src/disco/shred/fd_shred_tile.c

@@ -190,8 +190,6 @@
 #define STEM_LAZY (0L)
 #endif
 
-#define STEM_SHUTDOWN_SEQ (ULONG_MAX-1UL)
-
 static inline void
 STEM_(in_update)( fd_stem_tile_in_t * in ) {
   fd_fseq_update( in->fseq, in->seq );
@@ -433,10 +431,6 @@ STEM_(run1)( ulong                        in_cnt,
             ulong out_idx = cons_out[ cons_idx ];
             ulong cons_cr_avail = (ulong)fd_long_max( (long)out_depth[ out_idx ]-fd_long_max( fd_seq_diff( out_seq[ out_idx ], cons_seq[ cons_idx ] ), 0L ), 0L );
 
-            /* If a reliable consumer exits, they can set the credit
-               return fseq to STEM_SHUTDOWN_SEQ to indicate they are no
-               longer actively consuming. */
-            cons_cr_avail = fd_ulong_if( cons_seq[ cons_idx ]==STEM_SHUTDOWN_SEQ, out_depth[ out_idx ], cons_cr_avail );
             slowest_cons = fd_ulong_if( cons_cr_avail<min_cr_avail, cons_idx, slowest_cons );
 
             cr_avail[ out_idx ] = fd_ulong_min( cr_avail[ out_idx ], cons_cr_avail );
@@ -789,7 +783,7 @@ STEM_(run)( fd_topo_t *      topo,
       ulong fseq_id = tile->in_link_fseq_obj_id[ i ];
       ulong * fseq = fd_fseq_join( fd_topo_obj_laddr( topo, fseq_id ) );
       FD_TEST( fseq );
-      fd_fseq_update( fseq, STEM_SHUTDOWN_SEQ );
+      fd_fseq_update( fseq, ULONG_MAX );
     }
   }
 }

src/disco/stem/fd_stem.c

@@ -38,7 +38,6 @@ fd_store_new( void * shmem, ulong fec_max, ulong part_cnt ) {
   }
 
   fd_memset( shmem, 0, footprint );
-  fec_max = fd_ulong_pow2_up( fec_max ); /* required by map_chain */
 
   /* This seed value is very important. We have fec_max chains in the
      map, which means the size of each partition of buckets should be
@@ -66,6 +65,10 @@ fd_store_new( void * shmem, ulong fec_max, ulong part_cnt ) {
   store->root     = null;
 
   fd_store_pool_t pool = fd_store_pool( store );
+  if( FD_UNLIKELY( !fd_store_pool_new( shpool ) ) ) {
+    FD_LOG_WARNING(( "fd_store_pool_new failed" ));
+    return NULL;
+  }
   fd_store_pool_reset( &pool, 0 );
 
   FD_COMPILER_MFENCE();
@@ -115,7 +118,8 @@ fd_store_leave( fd_store_t const * store ) {
 }
 
 void *
-fd_store_delete( void * store ) {
+fd_store_delete( void * shstore ) {
+  fd_store_t * store = shstore;
 
   if( FD_UNLIKELY( !store ) ) {
     FD_LOG_WARNING(( "NULL store" ));
@@ -127,6 +131,15 @@ fd_store_delete( void * store ) {
     return NULL;
   }
 
+  if( FD_UNLIKELY( store->magic!=FD_STORE_MAGIC ) ) {
+    FD_LOG_WARNING(( "bad magic" ));
+    return NULL;
+  }
+
+  FD_COMPILER_MFENCE();
+  FD_VOLATILE( store->magic ) = 0UL;
+  FD_COMPILER_MFENCE();
+
   return store;
 }
 
@@ -207,14 +220,14 @@ fd_store_publish( fd_store_t  * store,
      any descendants of those ancestors. */
 
   while( FD_LIKELY( head ) ) {
-    fd_store_fec_t * child = fd_store_pool_ele( &pool, head->child );          /* left-child */
+    fd_store_fec_t * child = fd_store_pool_ele( &pool, head->child );         /* left-child */
     while( FD_LIKELY( child ) ) {                                             /* iterate over children */
       if( FD_LIKELY( child != newr ) ) {                                      /* stop at new root */
         tail->next = fd_store_map_idx_remove( map, &child->key, null, fec0 ); /* remove node from map to reuse `.next` */
-        tail       = fd_store_pool_ele( &pool, tail->next );                   /* push onto BFS queue (so descendants can be pruned) */
+        tail       = fd_store_pool_ele( &pool, tail->next );                  /* push onto BFS queue (so descendants can be pruned) */
         tail->next = null;                                                    /* clear map next */
       }
-      child = fd_store_pool_ele( &pool, child->sibling );                      /* right-sibling */
+      child = fd_store_pool_ele( &pool, child->sibling );                     /* right-sibling */
     }
     fd_store_fec_t * next = fd_store_pool_ele( &pool, head->next ); /* pophead */
     int err = fd_store_pool_release( &pool, head, BLOCKING );       /* release */
@@ -231,12 +244,18 @@ fd_store_publish( fd_store_t  * store,
 
 fd_store_t *
 fd_store_clear( fd_store_t * store ) {
+
   fd_store_map_t * map  = fd_store_map( store );
   fd_store_pool_t  pool = fd_store_pool( store );
   fd_store_fec_t * fec0 = fd_store_fec0( store );
 
   fd_store_fec_t * head = fd_store_root( store );
   fd_store_fec_t * tail = head;
+
+# if FD_STORE_USE_HANDHOLDING
+  if ( FD_UNLIKELY( !head ) ) { FD_LOG_WARNING(( "calling clear on an empty store" )); return store; }
+# endif
+
   for( fd_store_map_iter_t iter = fd_store_map_iter_init( map, fec0 );
        !fd_store_map_iter_done( iter, map, fec0 );
        iter = fd_store_map_iter_next( iter, map, fec0 ) ) {
@@ -283,6 +302,8 @@ fd_store_verify( fd_store_t * store ) {
       return -1;
     }
   }
+  fd_store_pool_t pool = fd_store_pool_const( store );
+  if( FD_UNLIKELY( fd_store_pool_verify( &pool )==-1 ) ) return -1;
   return fd_store_map_verify( map, store->fec_max, fec0 );
 }
 
@@ -296,7 +317,7 @@ print( fd_store_t const * store, fd_store_fec_t const * fec, int space, const ch
 
   if( space > 0 ) printf( "\n" );
   for( int i = 0; i < space; i++ ) printf( " " );
-  printf( "%s%s", prefix, FD_BASE58_ENC_32_ALLOCA( &fec->key ) );
+  printf( "%s%s", prefix, FD_BASE58_ENC_32_ALLOCA( &fec->key.mr ) );
 
   fd_store_fec_t const * curr = fd_store_pool_ele_const( &pool, fec->child );
   char new_prefix[1024]; /* FIXME size this correctly */

src/disco/store/fd_store.c

@@ -94,7 +94,7 @@
    #define MAP_KEY_HASH(key,seed) ((ulong)key->mr.ul[0]%seed + (key)->part*seed)
    ```
    where `key` is a key type that includes the merkle root (32 bytes)
-   and the partition index (4 bytes) that is equivalent to the Shred
+   and the partition index (8 bytes) that is equivalent to the Shred
    tile index doing the insertion.  seed, on initialization, is the
    number of chains/buckets in the map_chain divided by the number of
    partitions.  In effect, seed is the size of each partition.  For
@@ -126,7 +126,7 @@
    hash chain within that slot (which modifies what the head of the
    chain points to as well as the now-previous head in the hash chain's
    `.next` field, but does not touch application data).  With fencing
-   enabled (FD_MAP_INSERT_FENCING), it is guaranteed the consumer either
+   enabled (MAP_INSERT_FENCE), it is guaranteed the consumer either
    reads the head before or after the update.  If it reads before, that
    is safe, it would just check the key (if no match, iterate down the
    chain etc.)  If it reads after, it is also safe because the new
@@ -171,15 +171,15 @@
 #define FD_STORE_DATA_MAX (63985UL) /* TODO fixed-32 */
 
 /* fd_store_fec describes a store element (FEC set).  The pointer fields
-   implement a left-child, right-sibling n-ary tree. */
+   implement a left-child, right-sibling n-ary tree. */
 
 struct __attribute__((packed)) fd_store_key {
    fd_hash_t mr;
    ulong     part; /* partition index of the inserter */
 };
 typedef struct fd_store_key fd_store_key_t;
 
-struct __attribute__((aligned(128UL))) fd_store_fec {
+struct __attribute__((aligned(FD_STORE_ALIGN))) fd_store_fec {
 
   /* Keys */
 
@@ -233,7 +233,7 @@ FD_PROTOTYPES_BEGIN
 
 /* fd_store_{align,footprint} return the required alignment and
    footprint of a memory region suitable for use as store with up to
-   fec_max elements. */
+   fec_max elements.  fec_max is an integer power-of-two. */
 
 FD_FN_CONST static inline ulong
 fd_store_align( void ) {
@@ -242,6 +242,7 @@ fd_store_align( void ) {
 
 FD_FN_CONST static inline ulong
 fd_store_footprint( ulong fec_max ) {
+  if( FD_UNLIKELY( !fd_ulong_is_pow2( fec_max ) ) ) return 0UL;
   return FD_LAYOUT_FINI(
     FD_LAYOUT_APPEND(
     FD_LAYOUT_APPEND(
@@ -257,7 +258,8 @@ fd_store_footprint( ulong fec_max ) {
 
 /* fd_store_new formats an unused memory region for use as a store.
    mem is a non-NULL pointer to this region in the local address space
-   with the required footprint and alignment. */
+   with the required footprint and alignment.  fec_max is an integer
+   power-of-two. */
 
 void *
 fd_store_new( void * shmem, ulong fec_max, ulong part_cnt );
@@ -286,7 +288,7 @@ fd_store_leave( fd_store_t const * store );
    caller. */
 
 void *
-fd_store_delete( void * store );
+fd_store_delete( void * shstore );
 
 /* Accessors */
 
@@ -451,7 +453,9 @@ fd_store_publish( fd_store_t * store,
                   fd_hash_t  * merkle_root );
 
 /* fd_store_clear clears the store.  All elements are removed from the
-   map and released back into the pool.  Does not zero-out fields. */
+   map and released back into the pool.  Does not zero-out fields.
+
+   IMPORTANT SAFETY TIP!  the store must be non-empty. */
 
 fd_store_t *
 fd_store_clear( fd_store_t * store );

src/disco/store/fd_store.h

@@ -1255,8 +1255,6 @@ fd_ext_poh_reset( ulong         completed_bank_slot, /* The slot that successful
   if( FD_LIKELY( parent_block_id!=NULL ) ) {
     ctx->parent_slot = completed_bank_slot;
     memcpy( ctx->parent_block_id, parent_block_id, 32UL );
-  } else {
-    FD_LOG_WARNING(( "fd_ext_poh_reset(block_id=null,reset_slot=%lu,parent_slot=%lu) - ignored", completed_bank_slot, ctx->parent_slot ));
   }
   ctx->slot         = completed_bank_slot+1UL;
   ctx->hashcnt      = 0UL;

src/discof/poh/fd_poh_tile.c

@@ -16,6 +16,7 @@ $(call make-unit-test,test_ssmanifest_parser,utils/test_ssmanifest_parser,fd_dis
 ifdef FD_HAS_HOSTED
 $(call make-fuzz-test,fuzz_snapshot_parser,utils/fuzz_snapshot_parser,fd_discof fd_flamenco fd_ballet fd_util)
 $(call make-fuzz-test,fuzz_ssmanifest_parser,utils/fuzz_ssmanifest_parser,fd_discof fd_flamenco fd_ballet fd_util)
+$(call make-fuzz-test,fuzz_ssarchive_parser,utils/fuzz_ssarchive_parser,fd_discof fd_flamenco fd_ballet fd_util)
 endif
 
 endif

src/discof/restore/Local.mk

@@ -0,0 +1,38 @@
+#include "fd_ssarchive.h"
+
+#if !FD_HAS_HOSTED
+#error "This target requires FD_HAS_HOSTED"
+#endif
+
+#include <stdlib.h>
+#include <assert.h>
+
+int
+LLVMFuzzerInitialize( int  *   argc,
+                      char *** argv ) {
+  /* Set up shell without signal handlers */
+  putenv( "FD_LOG_BACKTRACE=0" );
+  fd_boot( argc, argv );
+  atexit( fd_halt );
+  fd_log_level_core_set   ( 4 );
+  fd_log_level_logfile_set( 4 );
+
+  return 0;
+}
+
+int
+LLVMFuzzerTestOneInput( uchar const * data,
+                        ulong         size ) {
+  ulong full_slot;
+  ulong incremental_slot;
+  uchar decoded_hash[ FD_HASH_FOOTPRINT ];
+
+  char* name_cstr = (char *)malloc( size + 1UL );
+  assert( name_cstr );
+  fd_cstr_fini( fd_cstr_append_text( fd_cstr_init( name_cstr ), (char const *)data, size ) );
+
+  fd_ssarchive_parse_filename( name_cstr, &full_slot, &incremental_slot, decoded_hash );
+
+  free( name_cstr );
+  return 0;
+}

src/discof/restore/utils/fuzz_ssarchive_parser.c

@@ -1259,8 +1259,6 @@ fd_ext_poh_reset( ulong         completed_bank_slot, /* The slot that successful
   if( FD_LIKELY( parent_block_id!=NULL ) ) {
     ctx->parent_slot = completed_bank_slot;
     memcpy( ctx->parent_block_id, parent_block_id, 32UL );
-  } else {
-    FD_LOG_WARNING(( "fd_ext_poh_reset(block_id=null,reset_slot=%lu,parent_slot=%lu) - ignored", completed_bank_slot, ctx->parent_slot ));
   }
   ctx->slot         = completed_bank_slot+1UL;
   ctx->hashcnt      = 0UL;

src/discoh/poh/fd_poh_tile.c

@@ -150,6 +150,7 @@ fd_epoch_leaders_delete( void * shleaders );
 FD_FN_PURE static inline fd_pubkey_t const *
 fd_epoch_leaders_get( fd_epoch_leaders_t const * leaders,
                       ulong                      slot ) {
+  if( FD_UNLIKELY( leaders==NULL ) ) return NULL;
   ulong slot_delta = slot - leaders->slot0;
   if( FD_UNLIKELY( slot      < leaders->slot0    ) ) return NULL;
   if( FD_UNLIKELY( slot_delta>=leaders->slot_cnt ) ) return NULL;