Line data    Source code

       1             : #include "fd_exec_txn_ctx.h"
       2             : #include "fd_exec_slot_ctx.h"
       3             : #include "../fd_acc_mgr.h"
       4             : #include "../fd_executor.h"
       5             : #include "../../vm/fd_vm.h"
       6             : #include "../fd_account.h"
       7             : 
       8             : void *
       9      108786 : fd_exec_txn_ctx_new( void * mem ) {
      10      108786 :   if( FD_UNLIKELY( !mem ) ) {
      11           0 :     FD_LOG_WARNING(( "NULL mem" ));
      12           0 :     return NULL;
      13           0 :   }
      14             : 
      15      108786 :   if( FD_UNLIKELY( !fd_ulong_is_aligned( (ulong)mem, FD_EXEC_TXN_CTX_ALIGN ) ) ) {
      16           0 :     FD_LOG_WARNING(( "misaligned mem" ));
      17           0 :     return NULL;
      18           0 :   }
      19             : 
      20      108786 :   fd_exec_txn_ctx_t * self = (fd_exec_txn_ctx_t *) mem;
      21             : 
      22      108786 :   FD_COMPILER_MFENCE();
      23      108786 :   self->magic = FD_EXEC_TXN_CTX_MAGIC;
      24      108786 :   FD_COMPILER_MFENCE();
      25             : 
      26      108786 :   return mem;
      27      108786 : }
      28             : 
      29             : fd_exec_txn_ctx_t *
      30       97416 : fd_exec_txn_ctx_join( void * mem ) {
      31       97416 :   if( FD_UNLIKELY( !mem ) ) {
      32           0 :     FD_LOG_WARNING(( "NULL block" ));
      33           0 :     return NULL;
      34           0 :   }
      35             : 
      36       97416 :   fd_exec_txn_ctx_t * ctx = (fd_exec_txn_ctx_t *) mem;
      37             : 
      38       97416 :   if( FD_UNLIKELY( ctx->magic!=FD_EXEC_TXN_CTX_MAGIC ) ) {
      39           0 :     FD_LOG_WARNING(( "bad magic" ));
      40           0 :     return NULL;
      41           0 :   }
      42             : 
      43       97416 :   return ctx;
      44       97416 : }
      45             : 
      46             : void *
      47           0 : fd_exec_txn_ctx_leave( fd_exec_txn_ctx_t * ctx) {
      48           0 :   if( FD_UNLIKELY( !ctx ) ) {
      49           0 :     FD_LOG_WARNING(( "NULL block" ));
      50           0 :     return NULL;
      51           0 :   }
      52             : 
      53           0 :   if( FD_UNLIKELY( ctx->magic!=FD_EXEC_TXN_CTX_MAGIC ) ) {
      54           0 :     FD_LOG_WARNING(( "bad magic" ));
      55           0 :     return NULL;
      56           0 :   }
      57             : 
      58           0 :   return (void *) ctx;
      59           0 : }
      60             : 
      61             : void *
      62           0 : fd_exec_txn_ctx_delete( void * mem ) {
      63           0 :   if( FD_UNLIKELY( !mem ) ) {
      64           0 :     FD_LOG_WARNING(( "NULL mem" ));
      65           0 :     return NULL;
      66           0 :   }
      67             : 
      68           0 :   if( FD_UNLIKELY( !fd_ulong_is_aligned( (ulong)mem, FD_EXEC_TXN_CTX_ALIGN) ) )  {
      69           0 :     FD_LOG_WARNING(( "misaligned mem" ));
      70           0 :     return NULL;
      71           0 :   }
      72             : 
      73           0 :   fd_exec_txn_ctx_t * hdr = (fd_exec_txn_ctx_t *)mem;
      74           0 :   if( FD_UNLIKELY( hdr->magic!=FD_EXEC_TXN_CTX_MAGIC ) ) {
      75           0 :     FD_LOG_WARNING(( "bad magic" ));
      76           0 :     return NULL;
      77           0 :   }
      78             : 
      79           0 :   FD_COMPILER_MFENCE();
      80           0 :   FD_VOLATILE( hdr->magic ) = 0UL;
      81           0 :   FD_COMPILER_MFENCE();
      82             : 
      83           0 :   return mem;
      84           0 : }
      85             : 
      86             : int
      87             : fd_txn_borrowed_account_view_idx( fd_exec_txn_ctx_t * ctx,
      88             :                                   uchar idx,
      89      137412 :                                   fd_borrowed_account_t * * account ) {
      90      137412 :   if( FD_UNLIKELY( idx>=ctx->accounts_cnt ) ) {
      91           0 :     return FD_ACC_MGR_ERR_UNKNOWN_ACCOUNT;
      92           0 :   }
      93             : 
      94      137412 :   fd_borrowed_account_t * txn_account = &ctx->borrowed_accounts[idx];
      95      137412 :   *account = txn_account;
      96             : 
      97      137412 :   if( FD_UNLIKELY( !fd_acc_exists( txn_account->const_meta ) ) ) {
      98        1443 :     return FD_ACC_MGR_ERR_UNKNOWN_ACCOUNT;
      99        1443 :   }
     100             : 
     101      135969 :   return FD_ACC_MGR_SUCCESS;
     102      137412 : }
     103             : 
     104             : int
     105             : fd_txn_borrowed_account_view_idx_allow_dead( fd_exec_txn_ctx_t * ctx,
     106             :                                              uchar idx,
     107         900 :                                              fd_borrowed_account_t * * account ) {
     108         900 :   if( FD_UNLIKELY( idx>=ctx->accounts_cnt ) ) {
     109         108 :     return FD_ACC_MGR_ERR_UNKNOWN_ACCOUNT;
     110         108 :   }
     111             : 
     112         792 :   fd_borrowed_account_t * txn_account = &ctx->borrowed_accounts[idx];
     113         792 :   *account = txn_account;
     114             : 
     115         792 :   return FD_ACC_MGR_SUCCESS;
     116         900 : }
     117             : 
     118             : int
     119             : fd_txn_borrowed_account_view( fd_exec_txn_ctx_t * ctx,
     120             :                               fd_pubkey_t const *      pubkey,
     121           0 :                               fd_borrowed_account_t * * account ) {
     122           0 :   for( ulong i = 0; i < ctx->accounts_cnt; i++ ) {
     123           0 :     if( memcmp( pubkey->uc, ctx->accounts[i].uc, sizeof(fd_pubkey_t) )==0 ) {
     124             :       // TODO: check if readable???
     125           0 :       fd_borrowed_account_t * txn_account = &ctx->borrowed_accounts[i];
     126           0 :       *account = txn_account;
     127             : 
     128           0 :       if( FD_UNLIKELY( !fd_acc_exists( txn_account->const_meta ) ) ) {
     129           0 :         return FD_ACC_MGR_ERR_UNKNOWN_ACCOUNT;
     130           0 :       }
     131             : 
     132           0 :       return FD_ACC_MGR_SUCCESS;
     133           0 :     }
     134           0 :   }
     135             : 
     136           0 :   return FD_ACC_MGR_ERR_UNKNOWN_ACCOUNT;
     137           0 : }
     138             : 
     139             : int
     140             : fd_txn_borrowed_account_executable_view( fd_exec_txn_ctx_t * ctx,
     141             :                                          fd_pubkey_t const *      pubkey,
     142         909 :                                          fd_borrowed_account_t * * account ) {
     143        1059 :   for( ulong i = 0; i < ctx->executable_cnt; i++ ) {
     144        1053 :     if( memcmp( pubkey->uc, ctx->executable_accounts[i].pubkey->uc, sizeof(fd_pubkey_t) )==0 ) {
     145             :       // TODO: check if readable???
     146         903 :       fd_borrowed_account_t * txn_account = &ctx->executable_accounts[i];
     147         903 :       *account = txn_account;
     148             : 
     149         903 :       if( FD_UNLIKELY( !fd_acc_exists( txn_account->const_meta ) ) )
     150           0 :         return FD_ACC_MGR_ERR_UNKNOWN_ACCOUNT;
     151             : 
     152         903 :       return FD_ACC_MGR_SUCCESS;
     153         903 :     }
     154        1053 :   }
     155             : 
     156           6 :   return FD_ACC_MGR_ERR_UNKNOWN_ACCOUNT;
     157         909 : }
     158             : 
     159             : int
     160             : fd_txn_borrowed_account_modify_idx( fd_exec_txn_ctx_t *        ctx,
     161             :                                     uchar                      idx,
     162             :                                     ulong                      min_data_sz,
     163        6111 :                                     fd_borrowed_account_t * *  account ) {
     164        6111 :   if( idx >= ctx->accounts_cnt ) {
     165           0 :     return FD_ACC_MGR_ERR_UNKNOWN_ACCOUNT;
     166           0 :   }
     167             : 
     168        6111 :   fd_borrowed_account_t * txn_account = &ctx->borrowed_accounts[idx];
     169        6111 :   if( FD_UNLIKELY( !fd_txn_account_is_writable_idx( ctx, (int)idx ) ) ) {
     170           0 :     return FD_ACC_MGR_ERR_WRITE_FAILED;
     171           0 :   }
     172             : 
     173        6111 :   if( min_data_sz > txn_account->const_meta->dlen ) {
     174           0 :     fd_borrowed_account_resize( txn_account, min_data_sz );
     175           0 :   }
     176             : 
     177        6111 :   *account = txn_account;
     178        6111 :   return FD_ACC_MGR_SUCCESS;
     179        6111 : }
     180             : 
     181             : int
     182             : fd_txn_borrowed_account_modify( fd_exec_txn_ctx_t *       ctx,
     183             :                                 fd_pubkey_t const *       pubkey,
     184             :                                 ulong                     min_data_sz,
     185           0 :                                 fd_borrowed_account_t * * account ) {
     186           0 :   for( ulong i = 0; i < ctx->accounts_cnt; i++ ) {
     187           0 :     if( memcmp( pubkey->uc, ctx->accounts[i].uc, sizeof(fd_pubkey_t) )==0 ) {
     188             :       // TODO: check if writable???
     189           0 :       fd_borrowed_account_t * txn_account = &ctx->borrowed_accounts[i];
     190           0 :       if( min_data_sz > txn_account->const_meta->dlen ) {
     191           0 :         fd_borrowed_account_resize( txn_account, min_data_sz );
     192           0 :       }
     193           0 :       *account = txn_account;
     194           0 :       return FD_ACC_MGR_SUCCESS;
     195           0 :     }
     196           0 :   }
     197             : 
     198           0 :   return FD_ACC_MGR_ERR_UNKNOWN_ACCOUNT;
     199           0 : }
     200             : 
     201             : void
     202             : fd_exec_txn_ctx_setup( fd_exec_txn_ctx_t   * txn_ctx,
     203             :                        fd_txn_t      const * txn_descriptor,
     204       11370 :                        fd_rawtxn_b_t const * txn_raw ) {
     205       11370 :   txn_ctx->compute_unit_limit = 200000;
     206       11370 :   txn_ctx->compute_unit_price = 0;
     207       11370 :   txn_ctx->compute_meter      = 200000;
     208       11370 :   txn_ctx->prioritization_fee_type = FD_COMPUTE_BUDGET_PRIORITIZATION_FEE_TYPE_DEPRECATED;
     209       11370 :   txn_ctx->custom_err         = UINT_MAX;
     210             : 
     211       11370 :   txn_ctx->instr_stack_sz     = 0;
     212       11370 :   txn_ctx->accounts_cnt       = 0;
     213       11370 :   txn_ctx->executable_cnt     = 0;
     214       11370 :   txn_ctx->paid_fees          = 0;
     215       11370 :   txn_ctx->heap_size          = FD_VM_HEAP_DEFAULT;
     216       11370 :   txn_ctx->loaded_accounts_data_size_limit = FD_VM_LOADED_ACCOUNTS_DATA_SIZE_LIMIT;
     217       11370 :   txn_ctx->accounts_resize_delta = 0;
     218       11370 :   txn_ctx->collected_rent     = 0UL;
     219             : 
     220       11370 :   txn_ctx->txn_descriptor = txn_descriptor;
     221       11370 :   txn_ctx->_txn_raw->raw = txn_raw->raw;
     222       11370 :   txn_ctx->_txn_raw->txn_sz = txn_raw->txn_sz;
     223             : 
     224       11370 :   txn_ctx->num_instructions = 0;
     225       11370 :   memset( txn_ctx->return_data.program_id.key, 0, sizeof(fd_pubkey_t) );
     226       11370 :   txn_ctx->return_data.len = 0;
     227             : 
     228       11370 :   txn_ctx->dirty_vote_acc  = 0;
     229       11370 :   txn_ctx->dirty_stake_acc = 0;
     230       11370 :   txn_ctx->failed_instr    = NULL;
     231       11370 :   txn_ctx->instr_err_idx   = INT_MAX;
     232       11370 :   txn_ctx->capture_ctx     = NULL;
     233             : 
     234       11370 :   txn_ctx->instr_info_cnt     = 0;
     235       11370 :   txn_ctx->instr_trace_length = 0;
     236             : 
     237       11370 :   txn_ctx->exec_err      = 0;
     238       11370 :   txn_ctx->exec_err_kind = FD_EXECUTOR_ERR_KIND_EBPF;
     239       11370 : }
     240             : 
     241             : void
     242           0 : fd_exec_txn_ctx_teardown( fd_exec_txn_ctx_t * txn_ctx ) {
     243           0 :   (void)txn_ctx;
     244           0 : }
     245             : 
     246             : void
     247             : fd_exec_txn_ctx_from_exec_slot_ctx( fd_exec_slot_ctx_t * slot_ctx,
     248       11370 :                                     fd_exec_txn_ctx_t * txn_ctx ) {
     249       11370 :   txn_ctx->slot_ctx = slot_ctx;
     250       11370 :   txn_ctx->epoch_ctx = slot_ctx->epoch_ctx;
     251       11370 :   txn_ctx->valloc = slot_ctx->valloc;
     252       11370 :   txn_ctx->funk_txn = NULL;
     253       11370 :   txn_ctx->acc_mgr = slot_ctx->acc_mgr;
     254       11370 : }
     255             : 
     256             : void
     257       93645 : fd_exec_txn_ctx_reset_return_data( fd_exec_txn_ctx_t * txn_ctx ) {
     258       93645 :   txn_ctx->return_data.len = 0;
     259       93645 : }