Now Reading
a deep dive contained in the know-how powering AWS Lambda · Tal Hoffman

a deep dive contained in the know-how powering AWS Lambda · Tal Hoffman

2023-02-27 18:37:11

You’re most definitely conversant in AWS Lambda and Fargate — Amazon’s serverless computing engines. At its nature, serverless computing introduces fairly a difficult activity requiring each tight safety and nice efficiency. For precisely that matter Amazon got here up with its microVM resolution referred to as Firecracker.

Micro what?

MicroVMs are merely a elaborate title for minimal, light-weight Digital Machines. They’re spawned by light-weight Digital Machine Screens (VMMs), stripped out of redundant & nice-to-have options. Very similar to good-old long-established VMs, they supply hardware-level virtualization for isolation & safety.

MicroVM in regard to this weblog put up is principally a virtualization know-how which is tailored for container workloads.

Again to Firecracker

Firecracker is a VMM which makes use of Linux Kernel-based Digital Machine (KVM). It’s created by Amazon to unravel their container workloads wants. It’s open source, written in (the extremely superior) Rust, and utilized in manufacturing since 2018.

Up till lately, Lambda was being run on high of normal Linux containers remoted inside separate digital machines. Every container served a distinct Lambda operate whereas every VM served a distinct tenant. Though extremely efficient by way of safety, this set-up meant restricted efficiency and has confirmed to be laborious to pack variable-size workloads onto fixed-size VMs.

Amazon determined to come-up with a greater resolution for its serverless workloads requiring:

  • Constant, close-to-native efficiency, which can be not being affected by different capabilities operating on the identical node
  • Capabilities should be strongly remoted and guarded in opposition to data disclosure, privilege escalation, and different safety dangers
  • Full compatibility so capabilities are in a position to run arbitrary libraries and binaries with none re-compilation or code adjustments
  • Excessive and versatile scalability permitting 1000’s of capabilities to run on a single machine
  • Capabilities should be capable of over-commit sources, solely utilizing the minimal quantity of sources they want
  • Startup & tear-down needs to be very fast in order that capabilities’ cold-start occasions stay small

And so, it was efficiently in a position to take action reaching impressing boot-times of “as little as 125ms” and supporting creation charges of “as much as 150 microVMs per second per host” (supply:

Going deeper…

Every Firecracker course of is sure to a single MicroVM and consists of the next threads: an API Server, a VMM, and vCPU(s) threads — one per every visitor CPU core.

Firecracker at present helps x86_64 and aarch64 architectures operating kernel model 4.14 or later. Help for aarch64 isn’t characteristic full but and is taken into account an alpha stage launch. All architecture-specific data on this put up regards to the x86_64 implementation.

API Server

The API Server is the management aircraft of every Firecracker course of. It’s, per the official docs, “by no means within the quick path of the digital machine”, and might be turned-off by passing the no-api flag given {that a} config-file is offered as an alternative.

It’s began by an ApiServerAdapter in a devoted thread and exposes a REST API operating on high of a unix socket. Endpoints exist for configuring visitor kernel, boot arguments, web configuration, block system configuration, visitor machine configuration and cpuid, logging, metrics, charge limiting, and the metadata service. Operations might be despatched to the API server pre-boot and post-boot.

The communication between the API server thread and the VMM thread (mentioned later) which runs & controls the precise VM is finished utilizing Rust channels.

Channels are notified about API requests arriving on the API server utilizing an epoll occasion loop, which FC makes use of in varied locations to deal with occasions:

// FD to inform of API occasions. This can be a blocking eventfd by design.
// It's used within the config/pre-boot loop which is an easy blocking loop
// which solely consumes API occasions.
let api_event_fd = EventFd::new(0).anticipate("Can't create API Eventfd.");

// Channels for each instructions between Vmm and Api threads.
let (to_vmm, from_api) = channel();
let (to_api, from_vmm) = channel();

      .spawn(transfer || {
            match ApiServer::new(mmds_info, to_vmm, from_vmm, to_vmm_event_fd).bind_and_run(
              ) {
                   // ...
    }).anticipate("API thread spawn failed.");

Supply: firecracker/src/firecracker/src/

As soon as the API server is spawned, the ApiServerAdapter would go on and name build_microvm_from_requests() which loops utilizing successive API calls, as a way to pre-boot the VM:

 pub fn build_microvm_from_requests<F, G>(
        seccomp_filters: &BpfThreadMap,
        event_manager: &mut EventManager,
        instance_info: InstanceInfo,
        recv_req: F,
        reply: G,
        boot_timer_enabled: bool,
    ) -> end result::Consequence<(VmResources, Arc<Mutex<Vmm>>), ExitCode>
    the place
        F: Fn() -> VmmAction,
        G: Fn(ActionResult),

        // Configure and begin microVM by way of successive API calls.
        // Iterate by way of API calls to configure microVm.
        // The loop breaks when a microVM is efficiently began, and a operating Vmm is constructed.
        whereas preboot_controller.built_vmm.is_none() {
            // Get request, course of it, ship again the response.
            // If any deadly errors had been encountered, break the loop.
            if let Some(exit_code) = preboot_controller.fatal_error {
                return Err(exit_code);

        // ...

Supply: firecracker/src/vmm/src/

After efficiently pre-booting the VM the ApiServerAdapter would run it calling ApiServerAdapter::run_microvm().

FC’s API Server specification might be discovered here

Boot Sequence and Linux Boot Protocol

A conventional PC boot sequence with a BIOS is consisted of the next steps:

Upon beginning, the CPU  —  operating in actual mode  —  executes an instruction positioned on the {hardware} reset vector which jumps to a ROM location. That firmware code in flip hundreds the start-up program — BIOS in that case. The startup program executes a POST (power-on self check) integrity test to make it possible for all {hardware} units that it depends on are working correctly.

Afterwards, it begins searching for a bootable system (CD drive, HDD, NIC) — failing in addition if none discovered. In case of an HDD, the bootable system could be the Grasp Boot Document (MBR) whose accountability is to seek for an energetic partition and execute its boot sector code. The boot sector code is principally the first-stage boot loader which is liable for loading the kernel onto bodily reminiscence and transferring management to the OS.

Boot loader techniques are available varied kinds. Totally different boot loaders implement a distinct variety of levels, designed for coping with varied useful resource limitations, just like the first-stage boot loader’s 512 bytes dimension restrict. Grub, for example, is a 3-layer boot loader.

Nevertheless, the Linux Kernel doesn’t essentially require loading with a BIOS and a boot loader. As an alternative Firecracker takes benefit of the 64-bit Linux Boot Protocol, which specifies how the kernel picture needs to be loaded and run. FC immediately boots the Kernel on the protected-mode entry level relatively than beginning off from the 16-bit actual mode.

Because the official docs of the Linux Boot Protocol state, the entry for the protected-mode is positioned at 0x100000, as seen within the following schema:

For a contemporary bzImage kernel with boot protocol model >= 2.02, a
reminiscence structure like the next is usually recommended:

    ~                        ~
        |  Protected-mode kernel |
100000  +------------------------+
    |  I/O reminiscence gap     |
0A0000    +------------------------+
    |  Reserved for BIOS     |    Depart as a lot as attainable unused
    ~                        ~
    |  Command line         |    (May also be under the X+10000 mark)
X+10000    +------------------------+
    |  Stack/heap         |    To be used by the kernel real-mode code.
X+08000    +------------------------+    
    |  Kernel setup         |    The kernel real-mode code.
    |  Kernel boot sector     |    The kernel legacy boot sector.
X       +------------------------+
    |  Boot loader         |    <- Boot sector entry level 0000:7C00
001000    +------------------------+
    |  Reserved for MBR/BIOS |
000800    +------------------------+
    |  Sometimes utilized by MBR |
000600    +------------------------+
    |  BIOS use solely     |
000000    +------------------------+

... the place the deal with X is as little as the design of the boot loader

Therefore, Firecracker sets HIMEM_START to 0x0010_0000 and in the end passes it because the start_address when calling load_kernel(). load_kernel() in flip runs sanity checks in opposition to the offered picture, reads in its segments, and eventually returns the visitor reminiscence’s entry level.

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
pub fn load_kernel<F>(
    guest_mem: &GuestMemoryMmap,
    kernel_image: &mut F,
    start_address: u64,
) -> Consequence<GuestAddress>
the place
    F: Learn + Search,
        .map_err(|_| Error::SeekKernelImage)?;
    let mut ehdr = elf::Elf64_Ehdr::default();
        .read_from(0, kernel_image, mem::size_of::<elf::Elf64_Ehdr>())
        .map_err(|_| Error::ReadKernelDataStruct("Didn't learn ELF header"))?;

    // Sanity checks
    // ...

        .map_err(|_| Error::SeekProgramHeader)?;
    let phdr_sz = mem::size_of::<elf::Elf64_Phdr>();
    let mut phdrs: Vec<elf::Elf64_Phdr> = vec![];
    for _ in 0udimension..ehdr.e_phnum as usize _

    // Learn in every part pointed to by this system headers.
    for phdr in &phdrs {
        if (phdr.p_type & elf::PT_LOAD) == 0 || phdr.p_filesz == 0 {

            .map_err(|_| Error::SeekKernelStart)?;

        let mem_offset = GuestAddress(phdr.p_paddr);
        if mem_offset.raw_value() < start_address {
            return Err(Error::InvalidProgramHeaderAddress);

            .read_from(mem_offset, kernel_image, phdr.p_filesz as usize)
            .map_err(|_| Error::ReadKernelImage)?;


Supply: firecracker/src/kernel/src/loader/

Firecracker immediately makes use of the uncompressed kernel picture vmlinux, saving extra prices of going by way of the normal boot sequence by which the kernel decompresses itself at startup. All of this particular FC boot sequence described above allows a serious efficiency increase in the end leading to what AWS Lambda buyer expertise as quick chilly begins.

Machine mannequin & VirtIO

Virtio is a tool virtualization customary written by Rusty Russell (the identical genius who wrote iptables!) as a part of his work on the x86 Linux para-virtualization hypervisor lguest. Versus full virtualization – the place the visitor is agnostic to the truth that it’s being run on a distinct host – para-virtualization know-how requires the visitor to implement drivers by itself and cooperate with its host. This in the end helps gaining higher efficiency for the reason that visitor speaks on to the host, as an alternative of being mediated by traps & {hardware} emulation drivers. Clearly, this requires modifications within the visitor OS to ensure that it to work. Firecracker is carried out utilizing a para-virtualized KVM that means higher efficiency over a standard VM.

Consider it because the distinction between speaking to a foreigner immediately in her/his native tongue (para-virtualization) vs speaking to them with the assistance of a translator (full virtualization).

Full Virtualization vs Para-Virtualization

The aim of Virtio is to supply an abstraction and a unified customary for the front-end drivers (on the visitor), for the backend system drivers (on the host), and for the transport layer between the 2 ends.

The specification lays out the necessities wanted for implementing virtio-compatible techniques. Entrance-end drivers are shipped out-of-the-box with Linux >= 2.6.25, whereas the backend drivers (hereinafter known as “units”) should be carried out as per the docs.

Interplay between the visitor and the host for the aim of accessing the info aircraft relies on a ring-buffer struct referred to as virtqueue containing guest-allocated buffers. The host reads and writes to these visitor reminiscence areas. Every system can have a couple of virtqueues, whereas every buffer might be both a read-only or a write-only – however not each. Every system holds a standing discipline, characteristic bits, and configuration area along with the precise information written & learn by that particular system.

Notifications between the 2 ends are used as a way to notify the opposite finish of:

  1. a configuration change (system -> driver)
  2. a used buffer by the system (system -> driver)
  3. an obtainable buffer by the visitor (driver -> system)

A great case for the higher efficiency para-virtualization offers over full virtualization is Virtio’s ‘obtainable buffer’ notifications mechanism which saves us lots of pricey VMExits. For example, given NIC emulation on a full virtualization resolution, there can be a VMExit for every byte being written to the emulated system. With virtio, all the buffer can be written first and solely then will a single VMExit be dispatched for the aim of notifying the host of an obtainable buffer.

Word that there’s an excellent higher virtio backend implementation referred to as vhost, which introduces in-kernel virtio units for KVM that includes direct guest-kernel-to-host-kernel information aircraft, saving redundant host userspace to kernel area syscalls. Firecracker doesn’t at present use this implementation.

Virtio specifies 3 attainable transport layers providing barely totally different layouts & implementations of these drivers & units:

  1. PCI Bus primarily based transport
  2. Reminiscence Mapped IO primarily based transport (FC’s chosen transport)
  3. Channel I/O primarily based transport

One distinction between PCI primarily based transport and a MMIO one is that in contrast to PCI, MMIO offers no generic system discovery mechanism. Which means that for every system the visitor OS might want to know the placement of the registers and interrupts used.

Typically, notifications from the visitor to the host are simply writes to a particular register, which set off a sign caught by the hypervisor (ioeventfd & VMExits), while notifications from the host to the visitor are primary irqfd interruptions. Each ‘used buffer’ notifications & ‘obtainable buffer’ notifications are suppressible since they’ll usually be very costly operations.

Again to Firecracker – every hooked up system (web, block, and so on…) is being registered with its personal MMIO transport occasion, which is principally a struct implementing the MMIO specification + a BusDevice trait responding to reads or writes in an arbitrary deal with area.

When attaching a tool, FC subscribes it to the final occasion loop. Every system is implementing a MutEventSubscriber trait which implements occasion dealing with for the system’s queue_evts (that’s, ‘obtainable buffer’ notifications). These queue occasions maintain the index of the related virtqueue buffer, so for a balloon driver for instance these might be inflateq, deflateq, and statsq queues.

FC registers every file descriptor within the system’s queue_evts (that are particular to that system) to be signaled by the KVM itself every time deal with 0x050 (virtio::NOTIFY_REG_OFFSET) is written to contained in the visitor, utilizing a KVM_IOEVENTFD ioctl. The virtio::NOTIFY_REG_OFFSET is known as the Queue Notifier. As per the official MMIO spec “writing a worth to this register notifies the system that there are new buffers to course of in a queue”. Within the occasion of MMIO/PMIO visitor addresses which aren’t registered utilizing the KVM_IOEVENTFD ioctl, a write will set off an everyday VMexit.

This ioctl attaches or detaches an ioeventfd to a authorized pio/mmio deal with throughout the visitor. A visitor write within the registered deal with will sign the offered occasion as an alternative of triggering an exit.

Total, the move of registering a MMIO-based system is as follows:

  1. FC allocates a brand new slot for the MMIO system
  2. It subscribes to the guest-triggered ioevents
  3. It registers an irqfd so as to have the ability to ship interrupts to the visitor
  4. Inserts the system on the MMIO slot
  5. And at last units the kernel bootparams to incorporate the visitor driver:
pub fn register_mmio_virtio_for_boot(  
    &mut self,  
    vm: &VmFd,  
    device_id: String,  
    mmio_device: MmioTransport,  
    _cmdline: &mut kernel_cmdline::Cmdline,  
    ) -> Consequence {  
            let mmio_slot = self.allocate_new_slot(1)?;  
            self.register_mmio_virtio(vm, device_id, mmio_device, &mmio_slot)?;  
            #[cfg(target_arch = x86_64)]  
            Self::add_virtio_device_to_cmdline(_cmdline, &mmio_slot)?;  

Supply: firecracker/src/vmm/src/device_manager/

Being a minimal VMM, FC offers a relatively restricted set of emulated drivers: block storage (virtio-blk), community (virtio-net), vsock (virtio-vsock), balloon driver (virtio-balloon), a serial console, and a partial I8042 keyboard controller used solely to cease the VM.

Along with the above units, FC company additionally see each Programmable Interrupt Controllers (PICs) & the I/O Superior Programmable Interrupt Controller (IOAPIC), and the KVM’s Programmable Interval Timer (PIT).

Legacy units such because the serial console and the I8042 controller are primarily based on Port Mapped IO. Every began vcpu is being set with a MMIO bus for the virtio units and a PMIO bus for the legacy units:

pub fn start_vcpus(
        &mut self,
        mut vcpus: Vec<Vcpu>,
        vcpu_seccomp_filter: Arc<BpfProgram>,
    ) -> Consequence<()> {
        // ... redacted

        for mut vcpu in vcpus.drain(..) {
                #[cfg(target_arch = "x86_64")]

                // … redacted

        // ... redacted

Supply: firecracker/src/vmm/src/

MMIO reads and writes set off a VMExit that are dealt with, amongst different issues, in a operate named run_emulation() which runs the VCPU (can be mentioned afterward). These VmExits are used for accessing the system’s management aircraft (i.e, its configuration area):

/// Runs the vCPU in KVM context and handles the kvm exit cause.
/// Returns error or enum specifying whether or not emulation was dealt with or interrupted.
pub fn run_emulation(&self) -> Consequence<VcpuEmulation> {
    match self.emulate() {
        VcpuExit::MmioRead(addr, information) => {
            if let Some(mmio_bus) = &self.kvm_vcpu.mmio_bus {
                mmio_bus.learn(addr, information);
            Okay(VcpuEmulation::Dealt with)
        VcpuExit::MmioWrite(addr, information) => {
            if let Some(mmio_bus) = &self.kvm_vcpu.mmio_bus {
                mmio_bus.write(addr, information);
            Okay(VcpuEmulation::Dealt with)
        // ... redacted
        arch_specific_reason => {
            // run particular structure emulation.
        // ... redacted

Supply: firecracker/src/vmm/src/vstate/vcpu/

PMIO reads and writes are arch-specific and dealt with individually:

/// Runs the vCPU in KVM context and handles the kvm exit cause.
/// Returns error or enum specifying whether or not emulation was dealt with or interrupted.
pub fn run_arch_emulation(&self, exit: VcpuExit) -> tremendous::Consequence<VcpuEmulation> {
    match exit {
        VcpuExit::IoIn(addr, information) => {
            if let Some(pio_bus) = &self.pio_bus {
                pio_bus.learn(u64::from(addr), information);
            Okay(VcpuEmulation::Dealt with)
        VcpuExit::IoOut(addr, information) => {
            if let Some(pio_bus) = &self.pio_bus {
                pio_bus.write(u64::from(addr), information);
            Okay(VcpuEmulation::Dealt with)
    // ... redacted

Supply: firecracker/src/vmm/src/vstate/vcpu/


Visitors’ community units are backed by faucet units on the host:

impl Web {
    /// Create a brand new virtio community system with the given TAP interface.
    pub fn new_with_tap(
        id: String,
        tap_if_name: String,
        guest_mac: Choice<&MacAddr>,
        rx_rate_limiter: RateLimiter,
        tx_rate_limiter: RateLimiter,
        allow_mmds_requests: bool,
    ) -> Consequence<Self>  1 << VIRTIO_NET_F_GUEST_UFO
    // … redacted

Supply: firecracker/src/devices/src/virtio/net/


Vsock was launched as a way for a bi-directional host/visitor communication.
Another method could be utilizing virtio-console which offers such host/visitor interplay however is relatively restricted. To begin with, multiplexing N:1 connections over 1:1 serial ports is difficult and must be dealt with on the utility degree. As well as, the API relies on a personality system relatively than on a sockets API and the semantics is stream semantics and doesn’t match effectively with datagram protocols. On high and above that, there’s a fairly small, hardcoded port restrict on the host machine of round 512.

On the opposite finish, Vsock affords common unix area sockets API (join(), bind(), settle for(), learn(), write(), and so on…) and due to this fact helps each datagram and stream semantics. There’s a devoted deal with household referred to as AF_VSOCK for that objective. Supply and vacation spot addresses are fabricated from tuples of 32-bit context ids (cid’s) and 32-bit ports in a bunch byte order.

Firecracker helps host-initiated vsock connections the place the MicroVM should be began with a configured vsock driver. It additionally helps guest-initiated connections requiring the host to be listening on a vacation spot port, sending a VIRTIO_VSOCK_OP_RST message to the visitor in any other case.


For storage Firecracker implements virtio-block units backed by information on the host. It doesn’t use a filesystem passthrough resolution (virtio-fs) in the meanwhile (maybe as a consequence of safety issues?). Word that since there’s no hot-plug in FC, all the VM’s block units have to be hooked up previous to operating the VM. As well as, as a way to efficiently mount such units to the VM they need to all be pre-formatted with a filesystem that the visitor kernel helps.

All learn and write operations are served utilizing a single requestq virtio queue. Out of the official supported operations by the virtio specification:

#outline VIRTIO_BLK_T_IN           0
#outline VIRTIO_BLK_T_OUT          1
#outline VIRTIO_BLK_T_FLUSH        4
#outline VIRTIO_BLK_T_DISCARD      11

Firecracker solely helps IN, OUT, and FLUSH:

pub enum RequestType {

A rootfs block system should be configured previous to booting the VM, like so:

See Also

curl --unix-socket /tmp/firecracker.socket -i 
  -X PUT 'http://localhost/drives/rootfs' 
  -H 'Settle for: utility/json'           
  -H 'Content material-Sort: utility/json'     
  -d "{
        "drive_id": "rootfs",
        "path_on_host": "${rootfs_path}",
        "is_root_device": true,
        "is_read_only": false

An instance for how you can create a minimal rootfs picture might be discovered at Firecracker’s official docs.


Ballooning is an idea which is supposed to supply an answer for overcommitting reminiscence. It permits for host-controlled, on-demand allocation and reclaiming of visitor reminiscence.

A virtio-balloon system works in order that the balloon visitor driver allocates reminiscence till reaching its goal, specified by the host, and studies these new reminiscence addresses again. Equally the balloon driver frees reminiscence again to the visitor itself if it has greater than the host system asks for. It’s an unbiased “reminiscence client/allocator” contained in the visitor kernel, which competes for reminiscence with different processes, and operates throughout the pre-boot RAM limitations of the VM.

The host can take away balloon reminiscence pages at will and hand them over to different company. This permits the host to regulate and fine-tune every of its company’ reminiscence sources primarily based by itself obtainable sources, due to this fact enabling overcommitting.


Virtio-balloon holds three virtio queues: inflateq, deflateq, and statsq. Inflateq is utilized by the visitor driver to report about addresses it has provided to the host system (therefore the “balloon” is inflated), whereas deflateq is used for studies of reminiscence addresses utilized by the visitor (therefore the “balloon” is deflated). Statsq is optionally available and can be utilized by the visitor to ship out reminiscence statistics.

Firecracker’s implementation operates on a best-effort foundation and works in order that if a given VM fails to allocate extra reminiscence pages, it prompts an error, sleeps for 200ms, after which makes an attempt once more.

FC helps two of the three characteristic bits said within the official virtio specification:

  1. deflate_on_oom (aka VIRTIO_BALLOON_F_DEFLATE_ON_OOM) – deflates reminiscence from the balloon when processes which aren’t wanted for kernel’s actions go OOM as an alternative of killing them by OOM killer
  2. stats_polling_interval_s (aka VIRTIO_BALLOON_F_STATS_VQ) – specifies how typically in seconds to ship out statistics; disabled if set to 0.

The third (or first) characteristic bit, which FC doesn’t activate, is VIRTIO_BALLOON_F_MUST_TELL_HOST meant for telling the driving force that the host should be instructed earlier than pages from the balloon are used.

Please observe that the host should be monitored for any reminiscence stress by itself finish after which function the balloon accordingly. This isn’t a sensible factor to do manually and needs to be handled mechanically but fastidiously.

There just a few safety issues and pitfalls requiring additional caring as documented in FC’s Firecracker Ballooning documentation.

In case you’re within the implementation of the visitor balloon driver, which is fairly straight-forward, have a look here and here.

IO Throttling

Firecracker offers I/O charge limiting for its virtio-net and virtio-block units, permitting for each bandwidth (bytes/sec) and operations per second throttling. The implementation relies on token buckets, one per every rate-limiter kind.

It’s configurable through the api server and might be (optionally) configured per drive and per community interface. The configurable values are the refill time, the bucket dimension, and an optionally available one-time burst.

See: src/api_server/swagger/firecracker.yaml#L1086

Legacy units

As already talked about, Firecracker emulates just a few legacy units on high of a PIO bus. For one, Firecracker emulates serial COM ports generally seen on x86 as I/O ports 0x3f8/0x2f8/0x3e8/0x2e8. Extra particularly it makes use of port 0x3f8 whereas 0x2f8, 0x3e8, and 0x2e8 are used as sinks related nowhere. As well as, it additionally exposes an I8052 keyboard controller registered at port 0x060 and utilized by FC to regulate shutdowns and problem ctrl+alt+delete sequences used for that objective.

pub fn register_devices(&mut self, vm_fd: &VmFd) -> Consequence<()> e

Supply: firecracker/src/vmm/src/device_manager/

VCPU threads and VCPUID

Firecracker spawns and manages every KVM vCPU emulation in a separate POSIX thread. Every such vCPU is neither an OS thread nor a course of, however relatively an execution mode supported by {hardware}. Intel VT-x, for example, is a know-how meant for helping with operating virtualized company natively with out requiring any software program emulation. Intel’s know-how affords two operating modes: a. VMX root mode used for the host VMM, and b. VMX non-root mode used for executing visitor directions. It’s assisted by a per-guest construction named Digital Machine Management Construction, which is liable for saving all context data each host & visitor modes want. This know-how is utilized by KVM and thus by Firecracker to run vCPU.

Firecracker execution model

Firecracker screens every vCPU state, together with VMExits and ioeventfd interrupts, and handles them accordingly in a state machine.

Take a look right here:

One other characteristic offered by Firecracker is CPUID characteristic masking. On x86 the CPUID instruction helps you to question the processor for its capabilities, a a lot wanted functionality for some workloads. When operating inside a VM this instruction received’t work effectively and requires emulation. KVM helps emulating CPUID utilizing the KVM_SET_CPUID2 ioctl which FC leverages.

MicroVM Metadata Service (MMDS)

The MMDS is a Firecracker mutable information retailer which lets the visitor entry host-provided JSON metadata. A attainable use case of this characteristic is a credential rotation wanted contained in the visitor, managed by the host.

This characteristic is consisted of three parts:

  1. The backend which is solely an API server endpoint permitting (pre-boot) configuration of the MMDS, and insertion & retrieval of knowledge from it
  2. An in-memory information retailer holding JSON objects
  3. A minimal, customized made HTTP/TCP/IPv4 stack dealing with visitor requests heading to the MMDS IPv4 deal with named “Dumbo”

Every body coming on the virtio-net system from the visitor is examined for its vacation spot. If it’s discovered to be designated on the Metadata Service (and it’s turned on) then will probably be forwarded to Dumbo. Afterwards it’ll get checked for a response which can be despatched again to the visitor given that there’s sufficient room within the system’s ring buffer. If it’s not designated at MMDS, will probably be despatched to the faucet system as an alternative.

// Tries to detour the body to MMDS and if MMDS does not settle for it, sends it on the host TAP.
// `frame_buf` ought to comprise the body bytes in a slice of actual size.
// Returns whether or not MMDS consumed the body.
fn write_to_mmds_or_tap(
    mmds_ns: Choice<&mut MmdsNetworkStack>,
    rate_limiter: &mut RateLimiter,
    frame_buf: &[u8],
    faucet: &mut Faucet,
    guest_mac: Choice<MacAddr>,
) -> Consequence<bool> {
    let checked_frame = |frame_buf| {
        frame_bytes_from_buf(frame_buf).map_err(|e| {
            error!("VNET header lacking within the TX body.");
    if let Some(ns) = mmds_ns {
        if ns.detour_frame(checked_frame(frame_buf)?) {

            // MMDS frames should not accounted by the speed limiter.
            rate_limiter.manual_replenish(frame_buf.len() as u64, TokenType::Bytes);
            rate_limiter.manual_replenish(1, TokenType::Ops);

            // MMDS consumed the body.
            return Okay(true);

    // This body goes to the TAP.

    // Verify for visitor MAC spoofing.
    if let Some(mac) = guest_mac {
        let _ = EthernetFrame::from_bytes(checked_frame(frame_buf)?).map(|eth_frame| {
            if mac != eth_frame.src_mac() {

    match faucet.write(frame_buf) {
        Okay(_) => {
        Err(e) => {
            error!("Failed to put in writing to faucet: {:?}", e);

Supply: firecracker/src/devices/src/virtio/net/

For more information in regards to the design of MMDS and Dumbo checkout these design docs.

Jailer, Seccomp, and cgrouping

Further sandboxing is added by Firecracker for even higher safety & efficiency assurances:

  1. Seccomp filters are utilized by default to restrict syscalls for the host per every of its threads (VMM, API servers, VCPUs). The default ones are essentially the most restrictive, solely permitting a minimal set of syscalls and parameters. The opposite choices are having a customized filterset for superior customers, and having no seccomp filters in any respect which is very not really useful. Have a look here for the whole record of default filters.
  2. A Jailer course of which sets-up all required system sources: creating namespaces, calling pivot_root() & chroot(), cgrouping, mknod()ing particular paths like /dev/kvm contained in the jail, and extra. Afterwards it drops privileges and exec()’s into the Firecracker picture.
  3. The jailer offers help for utilizing cgroups utilizing the --cgroup flag.
  4. It additionally helps utilizing a devoted netns and/or pid namespace.

And Voila. That’s it for now.

It’s extremely really useful to learn the supply code of this superb mission and discover it yourselves –

Source Link

What's Your Reaction?
In Love
Not Sure
View Comments (0)

Leave a Reply

Your email address will not be published.

2022 Blinking Robots.
WordPress by Doejo

Scroll To Top