Struct pallet_gear::Limits

pub struct Limits {

    pub stack_height: Option<u32>,
    pub globals: u32,
    pub locals: u32,
    pub parameters: u32,
    pub memory_pages: u16,
    pub table_size: u32,
    pub table_number: u32,
    pub br_table_size: u32,
    pub subject_len: u32,
    pub call_depth: u32,
    pub payload_len: u32,
    pub code_len: u32,
    pub data_segments_amount: u32,
}

Describes the upper limits on various metrics.

Note

The values in this struct should never be decreased. The reason is that decreasing those values will break existing programs which are above the new limits when a re-instrumentation is triggered.

Fields

stack_height: Option<u32>

Maximum allowed stack height in number of elements.

See https://wiki.parity.io/WebAssembly-StackHeight to find out how the stack frame cost is calculated. Each element can be of one of the wasm value types. This means the maximum size per element is 64bit.

Note

It is safe to disable (pass None) the stack_height when the execution engine is part of the runtime and hence there can be no indeterminism between different client resident execution engines.

globals: u32

Maximum number of globals a module is allowed to declare.

Globals are not limited through the linear memory limit memory_pages.

locals: u32

Maximum number of locals a function can have.

As wasm engine initializes each of the local, we need to limit their number to confine execution costs.

parameters: u32

Maximum numbers of parameters a function can have.

Those need to be limited to prevent a potentially exploitable interaction with the stack height instrumentation: The costs of executing the stack height instrumentation for an indirectly called function scales linearly with the amount of parameters of this function. Because the stack height instrumentation itself is is not weight metered its costs must be static (via this limit) and included in the costs of the instructions that cause them (call, call_indirect).

memory_pages: u16

Maximum number of memory pages allowed for a program.

table_size: u32

Maximum number of elements allowed in a table.

Currently, the only type of element that is allowed in a table is funcref.

table_number: u32

Maximum number of tables allowed for a program. The same limit also imposed by wasmparser, see https://github.com/bytecodealliance/wasm-tools/blob/main/crates/wasmparser/src/limits.rs

br_table_size: u32

Maximum number of elements that can appear as immediate value to the br_table instruction.

subject_len: u32

The maximum length of a subject in bytes used for PRNG generation.

call_depth: u32

The maximum nesting level of the call stack.

payload_len: u32

The maximum size of a message payload in bytes.

code_len: u32

The maximum length of a program code in bytes. This limit applies to the instrumented version of the code. Therefore instantiate_with_code can fail even when supplying a wasm binary below this maximum size.

data_segments_amount: u32

The maximum number of wasm data segments allowed for a program.

Trait Implementations

impl Clone for Limits

fn clone(&self) -> Limits

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Limits

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Decode for Limits

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self>, ) -> Result<DecodeFinished, Error>

where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>

where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl Default for Limits

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Limits

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encode for Limits

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

Convert self to a slice and append it to the destination.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl PartialEq for Limits

fn eq(&self, other: &Limits) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Limits

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TypeInfo for Limits

type Identity = Limits

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl EncodeLike for Limits

impl Eq for Limits

impl StructuralPartialEq for Limits