Line data    Source code

       1             : #ifndef HEADER_fd_src_flamenco_runtime_fd_runtime_h
       2             : #define HEADER_fd_src_flamenco_runtime_fd_runtime_h
       3             : 
       4             : #include "fd_runtime_helpers.h"
       5             : 
       6             : /* The general structure for executing transactions in Firedancer can
       7             :    be thought as a state maching where transaction execution is a
       8             :    deterministic state transition over various data structures.
       9             : 
      10             :    The starting and ending state before a transaction is executed is
      11             :    represented by the bank, accounts database, and status cache.  The
      12             :    bank holds Solana state not represented by accounts (see fd_bank.c/h
      13             :    for more details) and each bank is per-slot.  The latter two data
      14             :    structures are contained by the runtime.
      15             : 
      16             :    The runtime also owns valid joins to important data structures which
      17             :    are non-deterministically transitioned through execution such as the
      18             :    program cache which is a pure cache on top of the accounts database.
      19             :    The runtime also owns bounded out temporary memory regions used for
      20             :    transaction execution and valid joins to other scratch memory regions
      21             :    (e.g. acc_pool).
      22             : 
      23             :    So we expect the state of the runtime and the bank to change as a
      24             :    result of execution.
      25             : 
      26             :    The transaction, or the input to said state machine is represented by
      27             :    a fd_txn_in_t.  The fd_txn_in_t is just a parsed transaction message
      28             :    and any state that may have accrued as a result of bundle execution.
      29             : 
      30             :    Executing a transaction produces a set of results.  This is
      31             :    represented by a fd_txn_out_t.  The fd_txn_out_t consists of any
      32             :    information that needs to be applied to the bank and runtime.
      33             : 
      34             :    We can execute a fd_txn_in_t against a given fd_runtime_t and a
      35             :    fd_bank_t and expect to produce a fd_txn_out_t.  Then a fd_txn_out_t
      36             :    can be applied/committed on top of a fd_runtime_t and fd_bank_t.
      37             :    Execution is done via fd_runtime_prepare_and_execute_txn.  If a
      38             :    transaction is committable, it should be committed via
      39             :    fd_runtime_commit_txn.  If a transaction is not committable, it
      40             :    should be canceled via fd_runtime_cancel_txn.
      41             : 
      42             :    TLDR: The runtime is a state machine that executes transactions and
      43             :    produces results that are applied to various data structures
      44             :    including the bank, account database, and status cache.  The
      45             :    transaction is executed via a call to
      46             :    fd_runtime_prepare_and_execute_txn.  If the transaction is
      47             :    committable, it should be committed via fd_runtime_commit_txn.  If
      48             :    the transaction is not committable (txn_out->err.is_committable is 0),
      49             :    it should be canceled via fd_runtime_cancel_txn.  Two calls to
      50             :    fd_runtime_prepare_and_execute_txn without a call to
      51             :    fd_runtime_commit_txn or fd_runtime_cancel_txn in between are not
      52             :    allowed.
      53             : 
      54             :                input                                  output
      55             :    fd_runtime_t ->
      56             :    fd_txn_in_t  -> fd_runtime_prepare_and_execute_txn() -> fd_txn_out_t
      57             :    fd_bank_t    ->
      58             : 
      59             :    fd_txn_out_t is the state transition output of a transaction.
      60             : 
      61             :    txn_out (committable)     --> fd_runtime_commit_txn()
      62             :    txn_out (not committable) --> fd_runtime_cancel_txn()
      63             : */
      64             : 
      65             : struct fd_runtime {
      66             :   fd_accdb_user_t * accdb;
      67             :   fd_txncache_t *   status_cache;
      68             :   fd_progcache_t *  progcache;
      69             :   fd_acc_pool_t *   acc_pool;
      70             : 
      71             :   struct {
      72             :     uchar               stack_sz;                                /* Current depth of the instruction execution stack. */
      73             :     fd_exec_instr_ctx_t stack[ FD_MAX_INSTRUCTION_STACK_DEPTH ]; /* Instruction execution stack. */
      74             :     /* The memory for all of the instructions in the transaction
      75             :        (including CPI instructions) are preallocated.  However, the
      76             :        order in which the instructions are executed does not match the
      77             :        order in which they are allocated.  The instr_trace will instead
      78             :        be used to track the order in which the instructions are
      79             :        executed. We add a +1 to allow any instructions past the max
      80             :        instr trace limit to be safely allocated, so that we can fail
      81             :        out like Agave does later at the stack push step within
      82             :        fd_execute_instr.
      83             : 
      84             :        The caller is responsible for updating the trace_length for the
      85             :        callee. For CPI, the trace length is updated when preparing a
      86             :        new instruction within cpi_common. For top-level instructions,
      87             :        the trace length is updated within fd_execute_txn when preparing
      88             :        an instruction for execution. */
      89             :     fd_instr_info_t trace[ FD_MAX_INSTRUCTION_TRACE_LENGTH+1UL ];
      90             :     ulong           trace_length;
      91             :     /* The current instruction index being executed */
      92             :     int             current_idx;
      93             :   } instr;
      94             : 
      95             :   struct {
      96             :     /* The sysvar instructions account is a special account that is
      97             :        modified through the course of transaction execution, but its
      98             :        results are not committed to the bank or accounts database. */
      99             :     uchar                     sysvar_instructions_mem[ FD_ACC_TOT_SZ_MAX ] __attribute__((aligned(FD_ACCOUNT_REC_ALIGN)));
     100             : 
     101             :     /* The executable accounts are derived from the accounts in the
     102             :        transaction and are used by the bpf loader program to validate
     103             :        the program data account. */
     104             :     ulong                     executable_cnt;                            /* Number of BPF upgradeable loader accounts. */
     105             :     fd_accdb_ro_t             executable[ MAX_TX_ACCOUNT_LOCKS ];        /* Array of BPF upgradeable loader program data accounts */
     106             : 
     107             :     ulong                     starting_lamports[ MAX_TX_ACCOUNT_LOCKS ]; /* Starting lamports for each account */
     108             :     ulong                     starting_dlen[ MAX_TX_ACCOUNT_LOCKS ];     /* Starting data length for each account */
     109             :     ulong                     refcnt[ MAX_TX_ACCOUNT_LOCKS ];            /* Reference count for each account */
     110             :   } accounts;
     111             : 
     112             :   struct {
     113             :     int                   enable_log_collector;
     114             :     fd_log_collector_t *  log_collector; /* Log collector instance */
     115             :     fd_capture_ctx_t *    capture_ctx;
     116             :     fd_dump_proto_ctx_t * dump_proto_ctx;
     117             :     fd_txn_dump_ctx_t *   txn_dump_ctx;
     118             : 
     119             :     /* Pointer to buffer used for dumping instructions and transactions
     120             :        into protobuf files. */
     121             :     uchar *               dumping_mem;
     122             :     /* Pointer to buffer used for tracing instructions and transactions
     123             :        into protobuf files. */
     124             :     int                   enable_vm_tracing;
     125             :     uchar *               tracing_mem;
     126             :   } log;
     127             : 
     128             :   struct {
     129             :     uchar serialization_mem[ FD_MAX_INSTRUCTION_STACK_DEPTH ][ BPF_LOADER_SERIALIZATION_FOOTPRINT ] __attribute__((aligned(FD_RUNTIME_EBPF_HOST_ALIGN)));
     130             :   } bpf_loader_serialization;
     131             : 
     132             :   struct {
     133             :     uchar rodata        [ FD_RUNTIME_ACC_SZ_MAX     ] __attribute__((aligned(FD_SBPF_PROG_RODATA_ALIGN)));
     134             :     uchar sbpf_footprint[ FD_SBPF_PROGRAM_FOOTPRINT ] __attribute__((aligned(alignof(fd_sbpf_program_t))));
     135             :     uchar programdata   [ FD_RUNTIME_ACC_SZ_MAX     ] __attribute__((aligned(FD_ACCOUNT_REC_ALIGN)));
     136             :   } bpf_loader_program;
     137             : 
     138             :   union {
     139             :     struct {
     140             :       fd_vote_state_versioned_t vote_state;
     141             :     } authorize;
     142             : 
     143             :     struct {
     144             :       fd_vote_state_versioned_t vote_state;
     145             :     } update_validator_identity;
     146             : 
     147             :     struct {
     148             :       fd_vote_state_versioned_t vote_state;
     149             :     } update_commission;
     150             : 
     151             :     struct {
     152             :       fd_vote_state_versioned_t vote_state;
     153             :     } update_commission_bps;
     154             : 
     155             :     struct {
     156             :       fd_vote_state_versioned_t vote_state;
     157             :     } withdraw;
     158             : 
     159             :     struct {
     160             :       fd_vote_state_versioned_t vote_state;
     161             :     } init_account;
     162             : 
     163             :     struct {
     164             :       fd_vote_state_versioned_t vote_state;
     165             :       uchar                     tower_sync_landed_votes_mem[ FD_VOTE_INSTR_LANDED_VOTES_FOOTPRINT ] __attribute__((aligned(FD_VOTE_INSTR_LANDED_VOTES_ALIGN)));
     166             :     } tower_sync;
     167             : 
     168             :     struct {
     169             :       /* Deprecated instructions */
     170             :       fd_vote_state_versioned_t vote_state;
     171             :       uchar                     compact_vs_lockout_mem    [ FD_VOTE_INSTR_LOCKOUTS_FOOTPRINT     ] __attribute__((aligned(FD_VOTE_INSTR_LOCKOUTS_ALIGN)));
     172             :       uchar                     vs_update_landed_votes_mem[ FD_VOTE_INSTR_LANDED_VOTES_FOOTPRINT ] __attribute__((aligned(FD_VOTE_INSTR_LANDED_VOTES_ALIGN)));
     173             :     } process_vote;
     174             : 
     175             :   } vote_program;
     176             : 
     177             :   struct {
     178             : 
     179             :     /* Ticks spent spent preparing a txn-level VM (zeroing memory,
     180             :        copying account data, etc) */
     181             :     ulong vm_setup_cum_ticks;
     182             : 
     183             :     /* Ticks spent committing txn-level VM results (copying account
     184             :        data, etc) */
     185             :     ulong vm_commit_cum_ticks;
     186             : 
     187             :     /* Ticks spent in top-levl VM interpreter (includes CPI setup/commit
     188             :        ticks) */
     189             :     ulong vm_exec_cum_ticks;
     190             : 
     191             :     /* Ticks spent preparing/committing a cross-program invocation) */
     192             :     ulong cpi_setup_cum_ticks;
     193             :     ulong cpi_commit_cum_ticks;
     194             : 
     195             :     /* Number of user txn account transitions */
     196             : 
     197             : #   define FD_RUNTIME_SAVE_UNCHANGED_NONEXIST 0  /* non-existent account not modified */
     198             : #   define FD_RUNTIME_SAVE_CREATE             1  /* account previously non-existent, non-zero balance after txn */
     199             : #   define FD_RUNTIME_SAVE_DELETE             2  /* account previously existed,      non-existent     after txn */
     200             : #   define FD_RUNTIME_SAVE_MODIFY             3  /* existing account modified */
     201          12 : #   define FD_RUNTIME_SAVE_UNCHANGED          4  /* existing account not modified */
     202             : #   define FD_RUNTIME_SAVE_MAX                5  /* enum variant count */
     203             :     ulong txn_account_save[ FD_RUNTIME_SAVE_MAX ];
     204             : 
     205             :     ulong cu_cum;
     206             : 
     207             :   } metrics;
     208             : 
     209             :   struct {
     210             :     int enabled;
     211             :     int reclaim_accounts;
     212             :   } fuzz;
     213             : };
     214             : typedef struct fd_runtime fd_runtime_t;
     215             : 
     216             : struct fd_txn_in {
     217             :   fd_txn_p_t const * txn;
     218             : 
     219             :   struct {
     220             :     int            is_bundle;
     221             :     fd_txn_out_t * prev_txn_outs[ FD_PACK_MAX_TXN_PER_BUNDLE ];
     222             :     ulong          prev_txn_cnt;
     223             :   } bundle;
     224             : };
     225             : typedef struct fd_txn_in fd_txn_in_t;
     226             : 
     227             : struct fd_txn_out {
     228             :   struct {
     229             :     int  is_committable;
     230             :     int  is_fees_only;
     231             :     int  txn_err;
     232             :     /* These are error fields produced by instruction execution
     233             :        when txn_err == FD_RUNTIME_TXN_ERR_INSTRUCTION_ERROR (-9). */
     234             :     int  exec_err;
     235             :     int  exec_err_kind;
     236             :     int  exec_err_idx;
     237             :     uint custom_err;
     238             :   } err;
     239             : 
     240             :   struct {
     241             :     long                        load_start_ticks;
     242             :     long                        check_start_ticks;
     243             :     long                        exec_start_ticks;
     244             :     long                        commit_start_ticks;
     245             : 
     246             :     fd_compute_budget_details_t compute_budget;            /* Compute budget details */
     247             :     fd_transaction_cost_t       txn_cost;                  /* Transaction cost */
     248             :     ulong                       loaded_accounts_data_size; /* The actual transaction loaded data size */
     249             :     long                        accounts_resize_delta;     /* Transaction level tracking for account resizing */
     250             : 
     251             :     fd_txn_return_data_t        return_data;               /* Data returned from `return_data` syscalls */
     252             : 
     253             :     fd_hash_t                   blake_txn_msg_hash;        /* Hash of raw transaction message used by the status cache */
     254             :     fd_hash_t                   blockhash;                 /* Blockhash of the block that the transaction is being executed in */
     255             : 
     256             :     ulong                       execution_fee;             /* Execution fee paid by the fee payer in the transaction */
     257             :     ulong                       priority_fee;              /* Priority fee paid by the fee payer in the transaction */
     258             :     ulong                       tips;                      /* Jito tips paid during execution */
     259             : 
     260             :     ulong                       signature_count;           /* Number of signatures in the transaction */
     261             :     int                         is_simple_vote;            /* Whether the transaction is a simple vote */
     262             :   } details;
     263             : 
     264             :   /* During sanitization, v0 transactions are allowed to have up to 256 accounts:
     265             :      https://github.com/anza-xyz/agave/blob/838c1952595809a31520ff1603a13f2c9123aa51/sdk/program/src/message/versions/v0/mod.rs#L139
     266             :      Nonetheless, when Agave prepares a sanitized batch for execution and tries to lock accounts, a lower limit is enforced:
     267             :      https://github.com/anza-xyz/agave/blob/838c1952595809a31520ff1603a13f2c9123aa51/accounts-db/src/account_locks.rs#L118
     268             :      That is the limit we are going to use here. */
     269             :   struct {
     270             :     /* is_setup is set to 1 if account data buffer resources have been
     271             :        acquired for the transaction and 0 if they have not.  If the flag
     272             :        has been set, memory resources must be released. */
     273             :     int           is_setup;
     274             :     ulong         cnt;
     275             :     fd_pubkey_t   keys        [ MAX_TX_ACCOUNT_LOCKS ];
     276             :     fd_accdb_rw_t account     [ MAX_TX_ACCOUNT_LOCKS ]; /* FIXME use accdb_ref_t here for safety - some accounts are readonly */
     277             :     uchar         is_writable [ MAX_TX_ACCOUNT_LOCKS ];
     278             :     /* Flags to demarcate if an account is queued up to update the vote
     279             :        or stakes caches in the commit stage of a transaction. */
     280             :     uchar         stake_update[ MAX_TX_ACCOUNT_LOCKS ];
     281             :     uchar         vote_update [ MAX_TX_ACCOUNT_LOCKS ];
     282             :     uchar         new_vote    [ MAX_TX_ACCOUNT_LOCKS ];
     283             :     uchar         rm_vote     [ MAX_TX_ACCOUNT_LOCKS ];
     284             : 
     285             :     /* The fee payer and nonce accounts are treated differently than
     286             :        other accounts: if an on-transaction fails they are still
     287             :        committed to the accounts database.  However, they are saved at
     288             :        the point right after a fee is debited or the nonce is advanced
     289             :        respectively.  The rollback accounts store this state because a
     290             :        failed transaction could have potentially modified the state of
     291             :        these two accounts.
     292             : 
     293             :        The memory for the nonce and fee payer is always provisioned when
     294             :        the transaction is prepared, but isn't necessarily used. */
     295             :     uchar *             rollback_fee_payer_mem;
     296             :     uchar *             rollback_nonce_mem;
     297             : 
     298             :     ulong               nonce_idx_in_txn; /* !=ULONG_MAX if exists */
     299             :     fd_account_meta_t * rollback_nonce;
     300             :     fd_account_meta_t * rollback_fee_payer;
     301             :   } accounts;
     302             : };
     303             : typedef struct fd_txn_out fd_txn_out_t;
     304             : 
     305             : FD_PROTOTYPES_BEGIN
     306             : 
     307             : /* fd_runtime_block_execute_prepare kicks off the execution of a block.
     308             :    After this function is called, transactions can be executed and
     309             :    committed against the block.  This function handles epoch boundary
     310             :    and rewards updates if needed and updates sysvars.  It assumes that
     311             :    the bank and accounts database have been setup to execute against
     312             :    the bank: the bank has already been cloned from the parent bank and
     313             :    that the database has a transaction that is linked to the parent
     314             :    block's xid. */
     315             : 
     316             : void
     317             : fd_runtime_block_execute_prepare( fd_banks_t *         banks,
     318             :                                   fd_bank_t *          bank,
     319             :                                   fd_accdb_user_t  *   accdb,
     320             :                                   fd_runtime_stack_t * runtime_stack,
     321             :                                   fd_capture_ctx_t *   capture_ctx,
     322             :                                   int *                is_epoch_boundary );
     323             : 
     324             : /* fd_runtime_block_execute_finalize finishes the execution of the block
     325             :    by paying a fee out to the block leader, updating any sysvars, and
     326             :    updating the bank hash.  The required updates are made to the bank
     327             :    and the accounts database. */
     328             : 
     329             : void
     330             : fd_runtime_block_execute_finalize( fd_bank_t *        bank,
     331             :                                    fd_accdb_user_t  * accdb,
     332             :                                    fd_capture_ctx_t * capture_ctx );
     333             : 
     334             : /* fd_runtime_prepare_and_execute_txn is responsible for executing a
     335             :    fd_txn_in_t against a fd_runtime_t and a fd_bank_t.  The results of
     336             :    the transaction execution are set in the fd_txn_out_t.  The caller
     337             :    is responisble for correctly setting up the fd_txn_in_t and the
     338             :    fd_runtime_t handles.
     339             : 
     340             :    TODO: fd_runtime_t and fd_bank_t should be const here. */
     341             : 
     342             : void
     343             : fd_runtime_prepare_and_execute_txn( fd_runtime_t *      runtime,
     344             :                                     fd_bank_t *         bank,
     345             :                                     fd_txn_in_t const * txn_in,
     346             :                                     fd_txn_out_t *      txn_out );
     347             : 
     348             : /* fd_runtime_commit_txn commits the results of a transaction execution
     349             :    as represented by the fd_txn_out_t to the bank and the accounts
     350             :    database. */
     351             : 
     352             : void
     353             : fd_runtime_commit_txn( fd_runtime_t * runtime,
     354             :                        fd_bank_t *    bank,
     355             :                        fd_txn_out_t * txn_out );
     356             : 
     357             : /* fd_runtime_cancel_txn cancels the result of a transaction execution
     358             :    and frees any resources that may have been acquired.  A transaction
     359             :    should only be canceled when the transaction is not committable.
     360             :    1. An invalid transaction that causes a block to be rejected/
     361             :       considered invalid/'bad'.
     362             :    2. All transactions in a bundle with a failed transaction should be
     363             :       canceled as they will not be included in the block. */
     364             : 
     365             : void
     366             : fd_runtime_cancel_txn( fd_runtime_t * runtime,
     367             :                        fd_txn_out_t * txn_out );
     368             : 
     369             : FD_PROTOTYPES_END
     370             : 
     371             : #endif /* HEADER_fd_src_flamenco_runtime_fd_runtime_h */