LCOV - code coverage report
Current view: top level - flamenco/vm - fd_vm_base.h (source / functions) Hit Total Coverage
Test: cov.lcov Lines: 70 139 50.4 %
Date: 2025-09-19 04:41:14 Functions: 13 1008 1.3 %

          Line data    Source code
       1             : #ifndef HEADER_fd_src_flamenco_vm_fd_vm_base_h
       2             : #define HEADER_fd_src_flamenco_vm_fd_vm_base_h
       3             : 
       4             : /* FIXME: Headers included from other modules need cleanup.  As it
       5             :    stands, flamenco_base brings in types/custom, types/meta,
       6             :    types/bincode, ballet/base58, ballet/sha256, ballet/sha512,
       7             :    ballet/ed25519, ballet/txnthis also brings in util, flamenco_base,
       8             :    ballet/base58, util and the optional util/net/ipv4 ballet/sha256,
       9             :    most of which is probably not necessary to use this module in a
      10             :    somewhat haphazard fashion (include no-no things that are only
      11             :    available in hosted environments like stdio and stdlib) */
      12             : 
      13             : #include "../fd_flamenco_base.h"
      14             : #include "../../ballet/sbpf/fd_sbpf_loader.h" /* FIXME: functionality needed from here probably should be moved here */
      15             : #include "../features/fd_features.h"
      16             : 
      17             : /* Defines the different VM access types */
      18         102 : #define FD_VM_ACCESS_TYPE_LD (1)
      19          48 : #define FD_VM_ACCESS_TYPE_ST (2)
      20             : 
      21             : /* FD_VM_SUCCESS is zero and returned to indicate that an operation
      22             :    completed successfully.  FD_VM_ERR_* are negative integers and
      23             :    returned to indicate an operation that failed and why. */
      24             : 
      25             : /* "Standard" Firedancer error codes (FIXME: harmonize and consolidate) */
      26             : 
      27    56254437 : #define FD_VM_SUCCESS   ( 0) /* success */
      28     1891752 : #define FD_VM_ERR_INVAL (-1) /* invalid request */
      29           3 : #define FD_VM_ERR_UNSUP (-3) /* unsupported request */
      30           6 : #define FD_VM_ERR_FULL  (-5) /* storage full */
      31           3 : #define FD_VM_ERR_EMPTY (-6) /* nothing to do */
      32           3 : #define FD_VM_ERR_IO    (-7) /* input-output error */
      33             : 
      34             : /* VM exec error codes:  These are only produced by the VM itself. */
      35             : 
      36          60 : #define FD_VM_ERR_SIGFPE      (-18) /* divide by zero */
      37             : 
      38             : /* sBPF validation error codes.  These are only produced by
      39             :    fd_vm_validate.  FIXME: Consider having fd_vm_validate return
      40             :    standard error codes and then provide detail like this through an
      41             :    info arg.  FIXME: Are these exact matches to Solana?  If so, provide
      42             :    link, if not, document and refine name / consolidate further. */
      43             : 
      44        1179 : #define FD_VM_ERR_INVALID_OPCODE    (-25) /* detected an invalid opcode */
      45         393 : #define FD_VM_ERR_INVALID_SRC_REG   (-26) /* detected an invalid source register */
      46         585 : #define FD_VM_ERR_INVALID_DST_REG   (-27) /* detected an invalid destination register */
      47         141 : #define FD_VM_ERR_JMP_OUT_OF_BOUNDS (-29) /* detected an out of bounds jump */
      48           3 : #define FD_VM_ERR_JMP_TO_ADDL_IMM   (-30) /* detected a jump to an addl imm */
      49          21 : #define FD_VM_ERR_INVALID_END_IMM   (-31) /* detected an invalid immediate for an endianness conversion instruction */
      50           3 : #define FD_VM_ERR_INCOMPLETE_LDQ    (-32) /* detected an incomplete ldq at program end */
      51           3 : #define FD_VM_ERR_LDQ_NO_ADDL_IMM   (-33) /* detected a ldq without an addl imm following it */
      52          18 : #define FD_VM_ERR_INVALID_REG       (-35) /* detected an invalid register */
      53           0 : #define FD_VM_ERR_BAD_TEXT          (-36) /* detected a bad text section (overflow, outside rodata boundary, etc.,)*/
      54          72 : #define FD_VM_SH_OVERFLOW           (-37) /* detected a shift overflow, equivalent to VeriferError::ShiftWithOverflow */
      55           0 : #define FD_VM_TEXT_SZ_UNALIGNED     (-38) /* detected a text section that is not a multiple of 8 */
      56           0 : #define FD_VM_INVALID_FUNCTION      (-39) /* detected an invalid function */
      57           0 : #define FD_VM_INVALID_SYSCALL       (-40) /* detected an invalid syscall */
      58             : 
      59             : /* Syscall Errors
      60             :    https://github.com/anza-xyz/agave/blob/v2.0.7/programs/bpf_loader/src/syscalls/mod.rs#L81 */
      61             : 
      62           0 : #define FD_VM_SYSCALL_ERR_INVALID_STRING                          (-1)
      63           0 : #define FD_VM_SYSCALL_ERR_ABORT                                   (-2)
      64           0 : #define FD_VM_SYSCALL_ERR_PANIC                                   (-3)
      65           0 : #define FD_VM_SYSCALL_ERR_INVOKE_CONTEXT_BORROW_FAILED            (-4)
      66           0 : #define FD_VM_SYSCALL_ERR_MALFORMED_SIGNER_SEED                   (-5)
      67           0 : #define FD_VM_SYSCALL_ERR_BAD_SEEDS                               (-6)
      68           0 : #define FD_VM_SYSCALL_ERR_PROGRAM_NOT_SUPPORTED                   (-7)
      69           0 : #define FD_VM_SYSCALL_ERR_UNALIGNED_POINTER                       (-8)
      70           0 : #define FD_VM_SYSCALL_ERR_TOO_MANY_SIGNERS                        (-9)
      71           0 : #define FD_VM_SYSCALL_ERR_INSTRUCTION_TOO_LARGE                   (-10)
      72           0 : #define FD_VM_SYSCALL_ERR_TOO_MANY_ACCOUNTS                       (-11)
      73          36 : #define FD_VM_SYSCALL_ERR_COPY_OVERLAPPING                        (-12)
      74           0 : #define FD_VM_SYSCALL_ERR_RETURN_DATA_TOO_LARGE                   (-13)
      75           0 : #define FD_VM_SYSCALL_ERR_TOO_MANY_SLICES                         (-14)
      76           3 : #define FD_VM_SYSCALL_ERR_INVALID_LENGTH                          (-15)
      77           0 : #define FD_VM_SYSCALL_ERR_MAX_INSTRUCTION_DATA_LEN_EXCEEDED       (-16)
      78           0 : #define FD_VM_SYSCALL_ERR_MAX_INSTRUCTION_ACCOUNTS_EXCEEDED       (-17)
      79           0 : #define FD_VM_SYSCALL_ERR_MAX_INSTRUCTION_ACCOUNT_INFOS_EXCEEDED  (-18)
      80           3 : #define FD_VM_SYSCALL_ERR_INVALID_ATTRIBUTE                       (-19)
      81           0 : #define FD_VM_SYSCALL_ERR_INVALID_POINTER                         (-20)
      82           0 : #define FD_VM_SYSCALL_ERR_ARITHMETIC_OVERFLOW                     (-21)
      83             : 
      84             : /* These syscall errors are unique to Firedancer and do not have an Agave equivalent. */
      85           0 : #define FD_VM_SYSCALL_ERR_INSTR_ERR                               (-22)
      86           0 : #define FD_VM_SYSCALL_ERR_INVALID_PDA                             (-23) /* the computed pda was not a valid ed25519 point */
      87           0 : #define FD_VM_SYSCALL_ERR_COMPUTE_BUDGET_EXCEEDED                 (-24) /* compute unit limit exceeded in syscall */
      88          72 : #define FD_VM_SYSCALL_ERR_SEGFAULT                                (-25) /* illegal memory address (e.g. read/write to an address not backed by any memory) in syscall */
      89           0 : #define FD_VM_SYSCALL_ERR_OUTSIDE_RUNTIME                         (-26) /* syscall called with vm not running in solana runtime */
      90             : 
      91             : /* Poseidon returns custom errors for some reason */
      92           0 : #define FD_VM_SYSCALL_ERR_POSEIDON_INVALID_PARAMS                 (1)
      93           0 : #define FD_VM_SYSCALL_ERR_POSEIDON_INVALID_ENDIANNESS             (2)
      94             : 
      95             : /* EbpfError
      96             :    https://github.com/solana-labs/rbpf/blob/v0.8.5/src/error.rs#L17 */
      97             : 
      98           0 : #define FD_VM_ERR_EBPF_ELF_ERROR                                  (-1)
      99           0 : #define FD_VM_ERR_EBPF_FUNCTION_ALREADY_REGISTERED                (-2)
     100           0 : #define FD_VM_ERR_EBPF_CALL_DEPTH_EXCEEDED                        (-3)
     101           0 : #define FD_VM_ERR_EBPF_EXIT_ROOT_CALL_FRAME                       (-4)
     102         138 : #define FD_VM_ERR_EBPF_DIVIDE_BY_ZERO                             (-5)
     103          36 : #define FD_VM_ERR_EBPF_DIVIDE_OVERFLOW                            (-6)
     104          78 : #define FD_VM_ERR_EBPF_EXECUTION_OVERRUN                          (-7)
     105          42 : #define FD_VM_ERR_EBPF_CALL_OUTSIDE_TEXT_SEGMENT                  (-8)
     106         681 : #define FD_VM_ERR_EBPF_EXCEEDED_MAX_INSTRUCTIONS                  (-9)
     107           0 : #define FD_VM_ERR_EBPF_JIT_NOT_COMPILED                           (-10)
     108           0 : #define FD_VM_ERR_EBPF_INVALID_VIRTUAL_ADDRESS                    (-11)
     109           0 : #define FD_VM_ERR_EBPF_INVALID_MEMORY_REGION                      (-12)
     110         183 : #define FD_VM_ERR_EBPF_ACCESS_VIOLATION                           (-13)
     111           0 : #define FD_VM_ERR_EBPF_STACK_ACCESS_VIOLATION                     (-14)
     112          18 : #define FD_VM_ERR_EBPF_INVALID_INSTRUCTION                        (-15)
     113        1182 : #define FD_VM_ERR_EBPF_UNSUPPORTED_INSTRUCTION                    (-16)
     114           0 : #define FD_VM_ERR_EBPF_EXHAUSTED_TEXT_SEGMENT                     (-17)
     115           0 : #define FD_VM_ERR_EBPF_LIBC_INVOCATION_FAILED                     (-18)
     116           0 : #define FD_VM_ERR_EBPF_VERIFIER_ERROR                             (-19)
     117           0 : #define FD_VM_ERR_EBPF_SYSCALL_ERROR                              (-20)
     118             : 
     119             : 
     120             : FD_PROTOTYPES_BEGIN
     121             : 
     122             : /* fd_vm_strerror converts an FD_VM_SUCCESS / FD_VM_ERR_* code into
     123             :    a human readable cstr.  The lifetime of the returned pointer is
     124             :    infinite.  The returned pointer is always to a non-NULL cstr. */
     125             : 
     126             : FD_FN_CONST char const * fd_vm_strerror( int err );
     127             : 
     128             : FD_PROTOTYPES_END
     129             : 
     130             : /* fd_vm_limits API ***************************************************/
     131             : 
     132             : /* FIXME: pretty good case these actually belong in ballet/sbpf */
     133             : /* FIXME: DOCUMENT THESE / LINK TO SOLANA CODE / ETC */
     134             : 
     135             : /* VM register constants */
     136             : 
     137         330 : #define FD_VM_REG_CNT (11UL)
     138        7878 : #define FD_VM_REG_MAX (16UL) /* Actual number of SBPF instruction src/dst register indices */
     139             : 
     140             : #define FD_VM_SHADOW_REG_CNT (4UL)
     141             : 
     142             : /* VM stack constants */
     143             : 
     144       28011 : #define FD_VM_STACK_FRAME_MAX (64UL)
     145       32055 : #define FD_VM_STACK_FRAME_SZ  FD_VM_STACK_FRAME_SIZE
     146        7842 : #define FD_VM_STACK_GUARD_SZ  (0x1000UL)
     147       20232 : #define FD_VM_STACK_MAX       (FD_VM_STACK_FRAME_MAX*(FD_VM_STACK_FRAME_SZ))
     148             : 
     149             : /* VM heap constants */
     150             : 
     151         192 : #define FD_VM_HEAP_DEFAULT ( 32UL*1024UL) /* FIXME: SHOULD THIS MATCH FD_VM_HEAP_SIZE LIMIT BELOW? */
     152           0 : #define FD_VM_HEAP_MAX     (256UL*1024UL)
     153             : 
     154             : /* VM log constants */
     155             : 
     156          27 : #define FD_VM_LOG_MAX  (10000UL)
     157             : #define FD_VM_LOG_TAIL (128UL)   /* Large enough to cover the worst case syscall log tail clobbering in string parsing */
     158             : 
     159             : /* VM memory map constants */
     160             : 
     161             : #define FD_VM_LO_REGION    (0UL)
     162       24174 : #define FD_VM_PROG_REGION  (1UL)
     163       24174 : #define FD_VM_STACK_REGION (2UL)
     164       24174 : #define FD_VM_HEAP_REGION  (3UL)
     165       24978 : #define FD_VM_INPUT_REGION (4UL)
     166         822 : #define FD_VM_HIGH_REGION  (5UL)
     167             : 
     168          54 : #define FD_VM_MEM_MAP_PROGRAM_REGION_START  (0x100000000UL)
     169        8061 : #define FD_VM_MEM_MAP_STACK_REGION_START    (0x200000000UL)
     170         180 : #define FD_VM_MEM_MAP_HEAP_REGION_START     (0x300000000UL)
     171        7953 : #define FD_VM_MEM_MAP_INPUT_REGION_START    (0x400000000UL)
     172             : #define FD_VM_MEM_MAP_REGION_SZ             (0x0FFFFFFFFUL)
     173             : #define FD_VM_MEM_MAP_REGION_MASK           (~FD_VM_MEM_MAP_REGION_SZ)
     174         822 : #define FD_VM_MEM_MAP_REGION_VIRT_ADDR_BITS (32)
     175             : 
     176             : /* VM compute budget.  Note: these names should match exactly the names
     177             :    used in existing Solana validator.  See:
     178             :    https://github.com/anza-xyz/agave/blob/v1.18.5/program-runtime/src/compute_budget.rs#L19
     179             :    https://github.com/anza-xyz/agave/blob/v1.18.5/program-runtime/src/compute_budget.rs#L133 */
     180             : /* FIXME: DOUBLE CHECK THESE */
     181             : 
     182             : /* FD_VM_COMPUTE_UNIT_LIMIT is the number of compute units that a
     183             :    transaction or individual instruction is allowed to consume.  Compute
     184             :    units are consumed by program execution, resources they use, etc ... */
     185             : 
     186         186 : #define FD_VM_COMPUTE_UNIT_LIMIT                        (         1400000UL)
     187             : 
     188             : /* FD_VM_LOG_64_UNITS is the number of compute units consumed by a
     189             :    log_64 call */
     190             : 
     191             : #define FD_VM_LOG_64_UNITS                              (             100UL)
     192             : 
     193             : /* FD_VM_CREATE_PROGRAM_ADDRESS_UNITS is the number of compute units
     194             :    consumed by a create_program_address call and a try_find_program_address_call */
     195             : 
     196             : #define FD_VM_CREATE_PROGRAM_ADDRESS_UNITS              (            1500UL)
     197             : 
     198             : /* FD_VM_INVOKE_UNITS is the number of compute units consumed by an
     199             :    invoke call (not including the cost incurred by the called program) */
     200             : 
     201             : #define FD_VM_INVOKE_UNITS                              (            1000UL)
     202             : 
     203             : /* FD_VM_MAX_INVOKE_STACK_HEIGHT is the maximum program instruction
     204             :    invocation stack height. Invocation stack height starts at 1 for
     205             :    transaction instructions and the stack height is incremented each
     206             :    time a program invokes an instruction and decremented when a program
     207             :    returns */
     208             : 
     209             : #define FD_VM_MAX_INVOKE_STACK_HEIGHT                   (               5UL)
     210             : 
     211             : /* FD_VM_MAX_INSTRUCTION_TRACE_LENGTH is the maximum cross-program
     212             :    invocation and instructions per transaction */
     213             : 
     214             : #define FD_VM_MAX_INSTRUCTION_TRACE_LENGTH              (              64UL)
     215             : 
     216             : /* FD_VM_SHA256_BASE_COST is the base number of compute units consumed
     217             :    to call SHA256 */
     218             : 
     219           0 : #define FD_VM_SHA256_BASE_COST                          (              85UL)
     220             : 
     221             : /* FD_VM_SHA256_BYTE_COST is the incremental number of units consumed by
     222             :    SHA256 (based on bytes) */
     223             : 
     224           0 : #define FD_VM_SHA256_BYTE_COST                          (               1UL)
     225             : 
     226             : /* FD_VM_SHA256_MAX_SLICES is the maximum number of slices hashed per
     227             :    syscall */
     228             : 
     229           0 : #define FD_VM_SHA256_MAX_SLICES                         (           20000UL)
     230             : 
     231             : /* FD_VM_MAX_CALL_DEPTH is the maximum SBF to BPF call depth */
     232             : 
     233          27 : #define FD_VM_MAX_CALL_DEPTH                            (              64UL)
     234             : 
     235             : /* FD_VM_STACK_FRAME_SIZE is the size of a stack frame in bytes, must
     236             :    match the size specified in the LLVM SBF backend */
     237             : 
     238       32055 : #define FD_VM_STACK_FRAME_SIZE                          (            4096UL)
     239             : 
     240             : /* FD_VM_LOG_PUBKEY_UNITS is the number of compute units consumed by
     241             :    logging a `Pubkey` */
     242             : 
     243             : #define FD_VM_LOG_PUBKEY_UNITS                          (             100UL)
     244             : 
     245             : /* FD_VM_MAX_CPI_INSTRUCTION_SIZE is the maximum cross-program
     246             :    invocation instruction size */
     247             : 
     248             : #define FD_VM_MAX_CPI_INSTRUCTION_SIZE                  (            1280UL) /* IPv6 Min MTU size */
     249             : 
     250             : /* FD_VM_CPI_BYTES_PER_UNIT is the number of account data bytes per
     251             :    compute unit charged during a cross-program invocation */
     252             : 
     253           0 : #define FD_VM_CPI_BYTES_PER_UNIT                        (             250UL) /* ~50MB at 200,000 units */
     254             : 
     255             : /* FD_VM_SYSVAR_BASE_COST is the base number of compute units consumed
     256             :    to get a sysvar */
     257             : 
     258             : #define FD_VM_SYSVAR_BASE_COST                          (             100UL)
     259             : 
     260             : /* FD_VM_SECP256K1_RECOVER_COST is the number of compute units consumed
     261             :    to call secp256k1_recover */
     262             : 
     263             : #define FD_VM_SECP256K1_RECOVER_COST                    (           25000UL)
     264             : 
     265             : /* FD_VM_SYSCALL_BASE_COST is the number of compute units consumed to do
     266             :    a syscall without any work */
     267             : 
     268           0 : #define FD_VM_SYSCALL_BASE_COST                         (             100UL)
     269             : 
     270             : /* FD_VM_CURVE25519_EDWARDS_VALIDATE_POINT_COST is the number of compute
     271             :    units consumed to validate a curve25519 edwards point */
     272             : 
     273             : #define FD_VM_CURVE25519_EDWARDS_VALIDATE_POINT_COST    (             159UL)
     274             : 
     275             : /* FD_VM_CURVE25519_EDWARDS_ADD_COST is the number of compute units
     276             :    consumed to add two curve25519 edwards points */
     277             : 
     278           0 : #define FD_VM_CURVE25519_EDWARDS_ADD_COST               (             473UL)
     279             : 
     280             : /* FD_VM_CURVE25519_EDWARDS_SUBTRACT_COST is the number of compute units
     281             :    consumed to subtract two curve25519 edwards points */
     282             : 
     283           0 : #define FD_VM_CURVE25519_EDWARDS_SUBTRACT_COST          (             475UL)
     284             : 
     285             : /* FD_VM_CURVE25519_EDWARDS_MULTIPLY_COST is the number of compute units
     286             :    consumed to multiply a curve25519 edwards point */
     287             : 
     288           0 : #define FD_VM_CURVE25519_EDWARDS_MULTIPLY_COST          (            2177UL)
     289             : 
     290             : /* FD_VM_CURVE25519_EDWARDS_MSM_BASE_COST is the number of compute units
     291             :    consumed for a multiscalar multiplication (msm) of edwards points.
     292             :    The total cost is calculated as
     293             :      `msm_base_cost + (length - 1) * msm_incremental_cost` */
     294             : 
     295           6 : #define FD_VM_CURVE25519_EDWARDS_MSM_BASE_COST          (            2273UL)
     296             : 
     297             : /* FD_VM_CURVE25519_EDWARDS_MSM_INCREMENTAL_COST is the number of
     298             :    compute units consumed for a multiscalar multiplication (msm) of
     299             :    edwards points.  The total cost is calculated as
     300             :      `msm_base_cost + (length - 1) * msm_incremental_cost` */
     301             : 
     302           6 : #define FD_VM_CURVE25519_EDWARDS_MSM_INCREMENTAL_COST   (             758UL)
     303             : 
     304             : /* FD_VM_CURVE25519_RISTRETTO_VALIDATE_POINT_COST is the number of
     305             :    compute units consumed to validate a curve25519 ristretto point */
     306             : 
     307             : #define FD_VM_CURVE25519_RISTRETTO_VALIDATE_POINT_COST  (             169UL)
     308             : 
     309             : /* FD_VM_CURVE25519_RISTRETTO_ADD_COST is the number of compute units
     310             :    consumed to add two curve25519 ristretto points */
     311             : 
     312           6 : #define FD_VM_CURVE25519_RISTRETTO_ADD_COST             (             521UL)
     313             : 
     314             : /* FD_VM_CURVE25519_RISTRETTO_SUBTRACT_COST is the number of compute
     315             :    units consumed to subtract two curve25519 ristretto points */
     316             : 
     317           3 : #define FD_VM_CURVE25519_RISTRETTO_SUBTRACT_COST        (             519UL)
     318             : 
     319             : /* FD_VM_CURVE25519_RISTRETTO_MULTIPLY_COST is the number of compute
     320             :    units consumed to multiply a curve25519 ristretto point */
     321             : 
     322           3 : #define FD_VM_CURVE25519_RISTRETTO_MULTIPLY_COST        (            2208UL)
     323             : 
     324             : /* FD_VM_CURVE25519_RISTRETTO_MSM_BASE_COST is the number of compute
     325             :    units consumed for a multiscalar multiplication (msm) of ristretto
     326             :    points.  The total cost is calculated as
     327             :      `msm_base_cost + (length - 1) * msm_incremental_cost` */
     328             : 
     329           3 : #define FD_VM_CURVE25519_RISTRETTO_MSM_BASE_COST        (            2303UL)
     330             : 
     331             : /* FD_VM_CURVE25519_RISTRETTO_MSM_INCREMENTAL_COST is the number of
     332             :    compute units consumed for a multiscalar multiplication (msm) of
     333             :    ristretto points.  The total cost is calculated as
     334             :      `msm_base_cost + (length - 1) * msm_incremental_cost` */
     335             : 
     336           3 : #define FD_VM_CURVE25519_RISTRETTO_MSM_INCREMENTAL_COST (             788UL)
     337             : 
     338             : /* FD_VM_HEAP_SIZE is the program heap region size, default:
     339             :    solana_sdk::entrypoint::HEAP_LENGTH */
     340             : 
     341             : #define FD_VM_HEAP_SIZE                                 (           32768UL)
     342             : 
     343             : /* FD_VM_HEAP_COST is the number of compute units per additional 32k
     344             :    heap above the default (~.5 us per 32k at 15 units/us rounded up) */
     345             : 
     346           0 : #define FD_VM_HEAP_COST                                 (               8UL) /* DEFAULT_HEAP_COST */
     347             : 
     348             : /* FD_VM_MEM_OP_BASE_COST is the memory operation syscall base cost */
     349             : 
     350           0 : #define FD_VM_MEM_OP_BASE_COST                          (              10UL)
     351             : 
     352             : /* FD_VM_ALT_BN128_ADDITION_COST is the number of compute units consumed
     353             :    to call alt_bn128_addition */
     354             : 
     355           0 : #define FD_VM_ALT_BN128_ADDITION_COST                   (             334UL)
     356             : 
     357             : /* FD_VM_ALT_BN128_MULTIPLICATION_COST is the number of compute units
     358             :    consumed to call alt_bn128_multiplication */
     359             : 
     360           0 : #define FD_VM_ALT_BN128_MULTIPLICATION_COST             (            3840UL)
     361             : 
     362             : /* FD_VM_ALT_BN128_PAIRING_ONE_PAIR_COST_FIRST
     363             :    FD_VM_ALT_BN128_PAIRING_ONE_PAIR_COST_OTHER give the total cost as
     364             :      alt_bn128_pairing_one_pair_cost_first + alt_bn128_pairing_one_pair_cost_other * (num_elems - 1) */
     365             : 
     366           0 : #define FD_VM_ALT_BN128_PAIRING_ONE_PAIR_COST_FIRST     (           36364UL)
     367           0 : #define FD_VM_ALT_BN128_PAIRING_ONE_PAIR_COST_OTHER     (           12121UL)
     368             : 
     369             : /* FD_VM_BIG_MODULAR_EXPONENTIATION_COST is the big integer modular
     370             :    exponentiation cost */
     371             : 
     372             : #define FD_VM_BIG_MODULAR_EXPONENTIATION_COST           (              33UL)
     373             : 
     374             : /* FD_VM_POSEIDON_COST_COEFFICIENT_A is the coefficient `a` of the
     375             :    quadratic function which determines the number of compute units
     376             :    consumed to call poseidon syscall for a given number of inputs */
     377             : 
     378           0 : #define FD_VM_POSEIDON_COST_COEFFICIENT_A               (              61UL)
     379             : 
     380             : /* FD_VM_POSEIDON_COST_COEFFICIENT_C is the coefficient `c` of the
     381             :    quadratic function which determines the number of compute units
     382             :    consumed to call poseidon syscall for a given number of inputs */
     383             : 
     384           0 : #define FD_VM_POSEIDON_COST_COEFFICIENT_C               (             542UL)
     385             : 
     386             : /* FD_VM_GET_REMAINING_COMPUTE_UNITS_COST is the number of compute units
     387             :    consumed for reading the remaining compute units */
     388             : 
     389             : #define FD_VM_GET_REMAINING_COMPUTE_UNITS_COST          (             100UL)
     390             : 
     391             : /* FD_VM_ALT_BN128_G1_COMPRESS is the number of compute units consumed
     392             :    to call alt_bn128_g1_compress */
     393             : 
     394           0 : #define FD_VM_ALT_BN128_G1_COMPRESS                     (              30UL)
     395             : 
     396             : /* FD_VM_ALT_BN128_G1_DECOMPRESS is the number of compute units consumed
     397             :    to call alt_bn128_g1_decompress */
     398             : 
     399           0 : #define FD_VM_ALT_BN128_G1_DECOMPRESS                   (             398UL)
     400             : 
     401             : /* FD_VM_ALT_BN128_G2_COMPRESS is the number of compute units consumed
     402             :    to call alt_bn128_g2_compress */
     403             : 
     404           0 : #define FD_VM_ALT_BN128_G2_COMPRESS                     (              86UL)
     405             : 
     406             : /* FD_VM_ALT_BN128_G2_DECOMPRESS is the number of compute units consumed
     407             :    to call alt_bn128_g2_decompress */
     408             : 
     409           0 : #define FD_VM_ALT_BN128_G2_DECOMPRESS                   (           13610UL)
     410             : 
     411             : /* FD_VM_LOADED_ACCOUNTS_DATA_SIZE_LIMIT is the maximum accounts data
     412             :    size, in bytes, that a transaction is allowed to load */
     413             : 
     414           0 : #define FD_VM_LOADED_ACCOUNTS_DATA_SIZE_LIMIT           (64UL*1024UL*1024UL) /* 64MiB */
     415             : 
     416             : /* fd_vm_disasm API ***************************************************/
     417             : 
     418             : /* FIXME: pretty good case this actually belongs in ballet/sbpf */
     419             : /* FIXME: fd_sbpf_instr_t is nominally a ulong but implemented using
     420             :    bit-fields.  Compilers tend to generate notoriously poor asm for bit
     421             :    fields ... check ASM here. */
     422             : 
     423             : FD_PROTOTYPES_BEGIN
     424             : 
     425             : /* fd_vm_disasm_{instr,program} appends to the *_out_len (in strlen
     426             :    sense) cstr in the out_max byte buffer out a pretty printed cstr of
     427             :    the {instruction,program}.  If syscalls is non-NULL, syscalls will be
     428             :    annotated with the names from the provided syscall mapping.
     429             : 
     430             :    On input, *_out_len should be strlen(out) and in [0,out_max).  For
     431             :    instr, pc is the program counter corresponding to text[0] (as such
     432             :    text_cnt should be positive) and text_cnt is the number of words
     433             :    available at text to support safely printing multiword instructions.
     434             : 
     435             :    Given a valid out on input, on output, *_out_len will be strlen(out)
     436             :    and in [0,out_max), even if there was an error.
     437             : 
     438             :    Returns:
     439             : 
     440             :    FD_VM_SUCCESS - out buffer and *_out_len updated.
     441             : 
     442             :    FD_VM_ERR_INVAL - Invalid input.  For instr, out buffer and *_out_len
     443             :    are unchanged.  For program, out buffer and *_out_len will have been
     444             :    updated up to the point where the error occurred.
     445             : 
     446             :    FD_VM_ERR_UNSUP - For program, too many functions and/or labels for
     447             :    the current implementation.  out buffer and *_out_len unchanged.
     448             : 
     449             :    FD_VM_ERR_FULL - Not enough room in out to hold the result so output
     450             :    was truncated.  out buffer and *_out_len updated.
     451             : 
     452             :    FD_VM_ERR_IO - An error occurred formatting the string to append.  For
     453             :    instr, out_buffer and *_out_len unchanged.  For program, out buffer
     454             :    and *_out_len will have been updated up to the point where the error
     455             :    occurred.  In both cases, trailing bytes of out might have been
     456             :    clobbered. */
     457             : 
     458             : int
     459             : fd_vm_disasm_instr( ulong const *              text,      /* Indexed [0,text_cnt) */
     460             :                     ulong                      text_cnt,
     461             :                     ulong                      pc,
     462             :                     fd_sbpf_syscalls_t const * syscalls,
     463             :                     char *                     out,       /* Indexed [0,out_max) */
     464             :                     ulong                      out_max,
     465             :                     ulong *                    _out_len );
     466             : 
     467             : int
     468             : fd_vm_disasm_program( ulong const *              text,       /* Indexed [0,text_cnt) */
     469             :                       ulong                      text_cnt,
     470             :                       fd_sbpf_syscalls_t const * syscalls,
     471             :                       char *                     out,        /* Indexed [0,out_max) */
     472             :                       ulong                      out_max,
     473             :                       ulong *                    _out_len );
     474             : 
     475             : FD_PROTOTYPES_END
     476             : 
     477             : /* fd_vm_trace API ****************************************************/
     478             : 
     479             : /* FIXME: pretty good case this actually belongs in ballet/sbpf */
     480             : 
     481             : /* A FD_VM_TRACE_EVENT_TYPE_* indicates how a fd_vm_trace_event_t should
     482             :    be interpreted. */
     483             : 
     484          30 : #define FD_VM_TRACE_EVENT_TYPE_EXE   (0)
     485          24 : #define FD_VM_TRACE_EVENT_TYPE_READ  (1)
     486          24 : #define FD_VM_TRACE_EVENT_TYPE_WRITE (2)
     487             : 
     488             : struct fd_vm_trace_event_exe {
     489             :   /* This point is aligned 8 */
     490             :   ulong info;                 /* Event info bit field */
     491             :   ulong pc;                   /* pc */
     492             :   ulong ic;                   /* ic */
     493             :   ulong cu;                   /* cu */
     494             :   ulong ic_correction;        /* ic_correction */
     495             :   ulong frame_cnt;            /* frame_cnt */
     496             :   ulong reg[ FD_VM_REG_CNT ]; /* registers */
     497             :   ulong text[ 2 ];            /* If the event has valid clear, this is actually text[1] */
     498             :   /* This point is aligned 8 */
     499             : };
     500             : 
     501             : typedef struct fd_vm_trace_event_exe fd_vm_trace_event_exe_t;
     502             : 
     503             : struct fd_vm_trace_event_mem {
     504             :   /* This point is aligned 8 */
     505             :   ulong info;  /* Event info bit field */
     506             :   ulong vaddr; /* VM address range associated with event */
     507             :   ulong sz;
     508             :   /* This point is aligned 8
     509             :      If event has valid set:
     510             :        min(sz,event_data_max) bytes user data bytes
     511             :        padding to aligned 8 */
     512             : };
     513             : 
     514             : typedef struct fd_vm_trace_event_mem fd_vm_trace_event_mem_t;
     515             : 
     516           3 : #define FD_VM_TRACE_MAGIC (0xfdc377ace3a61c00UL) /* FD VM TRACE MAGIC version 0 */
     517             : 
     518             : struct fd_vm_trace {
     519             :   /* This point is aligned 8 */
     520             :   ulong magic;          /* ==FD_VM_TRACE_MAGIC */
     521             :   ulong event_max;      /* Number bytes of event storage */
     522             :   ulong event_data_max; /* Max bytes to capture per data event */
     523             :   ulong event_sz;       /* Used bytes of event storage */
     524             :   /* This point is aligned 8
     525             :      event_max bytes storage
     526             :      padding to aligned 8 */
     527             : };
     528             : 
     529             : typedef struct fd_vm_trace fd_vm_trace_t;
     530             : 
     531             : FD_PROTOTYPES_BEGIN
     532             : 
     533             : /* trace object structors */
     534             : /* FIXME: DOCUMENT (USUAL CONVENTIONS) */
     535             : 
     536             : FD_FN_CONST ulong
     537             : fd_vm_trace_align( void );
     538             : 
     539             : FD_FN_CONST ulong
     540             : fd_vm_trace_footprint( ulong event_max,        /* Maximum amount of event storage (<=1 EiB) */
     541             :                        ulong event_data_max ); /* Maximum number of bytes that can be captured in an event (<=1 EiB) */
     542             : 
     543             : void *
     544             : fd_vm_trace_new( void * shmem,
     545             :                  ulong  event_max,
     546             :                  ulong  event_data_max );
     547             : 
     548             : fd_vm_trace_t *
     549             : fd_vm_trace_join( void * _trace );
     550             : 
     551             : void *
     552             : fd_vm_trace_leave( fd_vm_trace_t * trace );
     553             : 
     554             : void *
     555             : fd_vm_trace_delete( void * _trace );
     556             : 
     557             : /* Given a current local join, fd_vm_trace_event returns the location in
     558             :    the caller's address space where trace events are stored and
     559             :    fd_vm_trace_event_sz returns number of bytes of trace events stored
     560             :    at that location.  event_max is the number of bytes of event storage
     561             :    (value used to construct the trace) and event_data_max is the maximum
     562             :    number of data bytes that can be captured per event (value used to
     563             :    construct the trace).  event will be aligned 8 and event_sz will be a
     564             :    multiple of 8 in [0,event_max].  The lifetime of the returned pointer
     565             :    is the lifetime of the current join.  The first 8 bytes of an event
     566             :    are an info field used by trace inspection tools how to interpret the
     567             :    event. */
     568             : 
     569           6 : FD_FN_CONST static inline void const * fd_vm_trace_event         ( fd_vm_trace_t const * trace ) { return (void *)(trace+1);     }
     570           6 : FD_FN_CONST static inline ulong        fd_vm_trace_event_sz      ( fd_vm_trace_t const * trace ) { return trace->event_sz;       }
     571           3 : FD_FN_CONST static inline ulong        fd_vm_trace_event_max     ( fd_vm_trace_t const * trace ) { return trace->event_max;      }
     572           6 : FD_FN_CONST static inline ulong        fd_vm_trace_event_data_max( fd_vm_trace_t const * trace ) { return trace->event_data_max; }
     573             : 
     574             : /* fd_vm_trace_event_info returns the event info corresponding to the
     575             :    given (type,valid) tuple.  Assumes type is a FD_VM_TRACE_EVENT_TYPE_*
     576             :    and that valid is in [0,1].  fd_vm_trace_event_info_{type,valid}
     577             :    extract from the given info {type,valid}.  Assumes info is valid. */
     578             : 
     579          45 : FD_FN_CONST static inline ulong fd_vm_trace_event_info( int type, int valid ) { return (ulong)((valid<<2) | type); }
     580             : 
     581          45 : FD_FN_CONST static inline int fd_vm_trace_event_info_type ( ulong info ) { return (int)(info & 3UL); } /* EVENT_TYPE_* */
     582          45 : FD_FN_CONST static inline int fd_vm_trace_event_info_valid( ulong info ) { return (int)(info >> 2);  } /* In [0,1] */
     583             : 
     584             : /* fd_vm_trace_reset frees all events in the trace.  Returns
     585             :    FD_VM_SUCCESS (0) on success or FD_VM_ERR code (negative) on failure.
     586             :    Reasons for failure include NULL trace. */
     587             : 
     588             : static inline int
     589           0 : fd_vm_trace_reset( fd_vm_trace_t * trace ) {
     590           0 :   if( FD_UNLIKELY( !trace ) ) return FD_VM_ERR_INVAL;
     591           0 :   trace->event_sz = 0UL;
     592           0 :   return FD_VM_SUCCESS;
     593           0 : }
     594             : 
     595             : /* fd_vm_trace_event_exe records the current pc, ic, cu and
     596             :    register file of the VM and the instruction about to execute.  Text
     597             :    points to the first word of the instruction about to execute and
     598             :    text_cnt points to the number of words available at that point.
     599             :    Returns FD_VM_SUCCESS (0) on success and a FD_VM_ERR code (negative)
     600             :    on failure.  Reasons for failure include INVAL (trace NULL, reg NULL,
     601             :    text NULL, and/or text_cnt 0) and FULL (insufficient trace event
     602             :    storage available). */
     603             : 
     604             : int
     605             : fd_vm_trace_event_exe( fd_vm_trace_t * trace,
     606             :                        ulong           pc,
     607             :                        ulong           ic,
     608             :                        ulong           cu,
     609             :                        ulong           reg[ FD_VM_REG_CNT ],
     610             :                        ulong const *   text,       /* Indexed [0,text_cnt) */
     611             :                        ulong           text_cnt,
     612             :                        ulong           ic_correction,
     613             :                        ulong           frame_cnt );
     614             : 
     615             : /* fd_vm_trace_event_mem records an attempt to access the VM address
     616             :    range [vaddr,vaddr+sz).  If write==0, it was a read attempt,
     617             :    otherwise, it was a write attempt.  Data points to the location of
     618             :    the memory range in host memory or NULL if the range is invalid.  If
     619             :    data is not NULL and sz is non-zero, this will record
     620             :    min(sz,event_data_max) of data for the event and mark the event has
     621             :    having valid data.  Returns FD_VM_SUCCESS (0) on success and a
     622             :    FD_VM_ERR code (negative) on failure.  Reasons for failure include
     623             :    INVAL (trace NULL) and FULL (insufficient trace event storage
     624             :    available to store the event). */
     625             : 
     626             : int
     627             : fd_vm_trace_event_mem( fd_vm_trace_t * trace,
     628             :                        int             write,
     629             :                        ulong           vaddr,
     630             :                        ulong           sz,
     631             :                        void *          data );
     632             : 
     633             : /* fd_vm_trace_printf pretty prints the current trace to stdout.  If
     634             :    syscalls is non-NULL, the trace will annotate syscalls in its
     635             :    disassembly according the syscall mapping.  Returns FD_VM_SUCCESS (0)
     636             :    on success and a FD_VM_ERR code (negative) on failure.  Reasons for
     637             :    failure include INVAL (NULL trace) and IO (corruption detected while
     638             :    parsing the trace events).  FIXME: REVAMP THIS API FOR MORE GENERAL
     639             :    USE CASES. */
     640             : 
     641             : int
     642             : fd_vm_trace_printf( fd_vm_trace_t      const * trace,
     643             :                     fd_sbpf_syscalls_t const * syscalls );
     644             : 
     645             : /* fd_vm_syscall API **************************************************/
     646             : 
     647             : /* FIXME: fd_sbpf_syscalls_t and fd_sbpf_syscall_func_t probably should
     648             :    be moved from ballet/sbpf to here. */
     649             : 
     650             : /* Note: the syscall map is kept separate from the fd_vm_t itself to
     651             :    support, for example, multiple fd_vm_t executing transactions
     652             :    concurrently for a slot.  They could use the same syscalls for setup,
     653             :    memory and cache efficiency. */
     654             : 
     655             : /* fd_vm_syscall_register inserts the syscall with the given cstr name
     656             :    into the given syscalls.  The VM syscall implementation to use is
     657             :    given by func (NULL is fine though a VM itself may not accept such as
     658             :    valid).  The caller promises there is room in the syscall map.
     659             :    Returns FD_VM_SUCCESS (0) on success or a FD_VM_ERR code (negative)
     660             :    on failure.  Reasons for failure include INVAL (NULL syscalls, NULL
     661             :    name, name or the hash of name already in the map).  On success,
     662             :    syscalls retains a read-only interest in name (e.g. use an infinite
     663             :    lifetime cstr here).  (This function is exposed to allow VM users to
     664             :    add custom syscalls but most use cases probably should just call
     665             :    fd_vm_syscall_register_slot below.)
     666             : 
     667             :    IMPORTANT SAFETY TIP!  See notes in syscall/fd_vm_syscall.h on what a
     668             :    syscall should expect to see and what to return. */
     669             : 
     670             : int
     671             : fd_vm_syscall_register( fd_sbpf_syscalls_t *   syscalls,
     672             :                         char const *           name,
     673             :                         fd_sbpf_syscall_func_t func );
     674             : 
     675             : /* fd_vm_syscall_register_slot unmaps all syscalls in the current map
     676             :    (also ending any interest in the corresponding name cstr) and
     677             :    registers all syscalls appropriate for the slot described by
     678             :    slot_ctx.  Returns FD_VM_SUCCESS (0) on success and FD_VM_ERR code
     679             :    (negative) on failure.  Reasons for failure include INVAL (NULL
     680             :    syscalls) and FULL (tried to register too many system calls ...
     681             :    compile time map size needs to be adjusted).  If slot_ctx is NULL,
     682             :    will register all fd_vm syscall implementations (whether or not that
     683             :    makes sense ... may change between Firedancer versions without
     684             :    warning).  FIXME: probably better to pass the features for a slot
     685             :    than pass the whole slot_ctx.
     686             : 
     687             :    is_deploy should be 1 if the set of syscalls registered should be that
     688             :    used to verify programs before they are deployed, and 0 if it
     689             :    should be the set used to execute programs. */
     690             : 
     691             : int
     692             : fd_vm_syscall_register_slot( fd_sbpf_syscalls_t *  syscalls,
     693             :                              ulong                 slot,
     694             :                              fd_features_t const * features,
     695             :                              uchar                 is_deploy );
     696             : 
     697             : /* fd_vm_syscall_register_all is a shorthand for registering all
     698             :    syscalls (see register slot). */
     699             : 
     700             : static inline int
     701           0 : fd_vm_syscall_register_all( fd_sbpf_syscalls_t * syscalls, uchar is_deploy ) {
     702             :   return fd_vm_syscall_register_slot( syscalls, 0UL, NULL, is_deploy );
     703           0 : }
     704             : 
     705             : FD_PROTOTYPES_END
     706             : 
     707             : #endif /* HEADER_fd_src_flamenco_vm_fd_vm_base_h */

Generated by: LCOV version 1.14