Doca Devemu

DOCA Device Emulation

Where to start: This skill assumes DOCA is already installed

on the host AND on the BlueField, the user is doing **hands-on

emulated-PCIe-device work** from the DPU side (writing the

backend that the host's kernel driver will talk to over the

emulated PCIe surface), and the user knows which CLASS of

emulated device they want to build. Open

TASKS.md if the user wants to *do* something

(configure / build / modify / run / test / debug); open

CAPABILITIES.md when the question is

*what can Device Emulation express* on this DOCA version + this

BlueField generation + this firmware. If the user has not

installed DOCA yet, route to

doca-setup first. **Before

anything else, the agent must route the user to the right

sub-library** — DOCA Device Emulation is an *umbrella* that

covers PCI Generic (raw PCIe device emulation), virtio-net

(emulated virtio network device), and virtio-fs (emulated

virtio filesystem device); each sub-library has its own

context, its own pkg-config module, and its own capability

surface. The sub-library selection rule lives in

CAPABILITIES.md ## Capabilities and modes.

If the user wants a packaged solution rather than a library

(e.g. *"I want NVMe SNAP on my host without writing the

backend myself"*, or *"I want a managed virtio-net daemon"*),

route via

doca-public-knowledge-map

to the DOCA SNAP Service / DOCA Virtio-net Service guides

— those services are *built on top of* this library and are a

different artifact than what this skill covers.

Audience

This skill serves **external developers building applications

that consume the DOCA Device Emulation library** — i.e., users

whose DPU-side code calls doca_devemu_pci_*,

doca_devemu_virtio_*, or doca_devemu_vfs_* (directly

in C / C++, or through FFI / bindings from another language)

to expose an emulated PCIe device to the host that the host's

existing kernel drivers can drive as if it were a real PCIe

peripheral. It is *not* for NVIDIA developers contributing to

DOCA Device Emulation itself, and it is *not* the right

artifact for users who want a packaged emulated-device daemon

they do not have to write the backend for (the DOCA SNAP

Service and the DOCA Virtio-net Service are the packaged

options that build on top of this library).

Language scope. DOCA Device Emulation ships as a C library;

this skill covers three sub-libraries end-to-end. Select the exact

installed pkg-config module for the user's emulation class (see

the sub-library selection table in

CAPABILITIES.md ## Capabilities and modes).

The shipped samples under

/opt/mellanox/doca/samples/doca_devemu/ are

written in C. C and C++ consumers are the canonical case and

the worked examples in TASKS.md assume that path.

Other-language consumers (Rust, Go, Python, …) consume the

same *.so files through FFI or language-specific bindings;

the skill's contribution in that case is to keep the

sub-library selection, umbrella lifecycle, capability-discovery,

permission, and error-taxonomy guidance language-neutral, and

to route the agent to the public C ABI as the authoritative

surface that any wrapper will eventually call.

When to load this skill

Load this skill when the user is doing hands-on DOCA Device

Emulation work from the DPU side, in any language. Concretely:

• Deciding which Device Emulation sub-library (PCI Generic,

virtio-net, virtio-fs) the user needs — the umbrella

selection question is *this skill's load-bearing first move*.

• Initializing the per-sub-library DOCA Core context on the

DPU (one context per emulated device per sub-library) and

configuring the doorbell / DMA primitives the host's PCIe

driver will interact with.

• Reading per-sub-library capability surface via the

doca_devemu_pci_cap_*, doca_devemu_virtio_cap_*, or

doca_devemu_vfs_cap_* query families against the

active doca_devinfo BEFORE assuming a particular feature

bit or device characteristic is available.

• Choosing between writing the backend with doca-devemu

yourself and adopting a packaged service (DOCA SNAP Service

/ DOCA Virtio-net Service) that already wraps this library.

• Debugging a DOCA_ERROR_* returned from a doca_devemu_*

call — in particular disambiguating *firmware-level

emulation type not enabled* from *BlueField generation does

not support this sub-library at all* from *DPU-side process

lacks privilege* from *host-side kernel driver did not bind*.

• Designing or extending non-C bindings (Rust, Go, Python, …)

that wrap one of the device-emulation sub-libraries — for

the sub-library selection, umbrella lifecycle, capability-

discovery, permission, and error-taxonomy rules the wrapper

must honor.

Do not load this skill for general DOCA orientation,

install of DOCA itself, the host-side kernel driver for the

emulated device class (virtio-net / virtio-blk / virtio-fs

kernel drivers ship with the host kernel and are not part of

DOCA), the packaged SNAP / Virtio-net services (they are

separate artifacts with their own service guides), or for

standard NIC behavior on the BlueField data path (use

doca-flow +

doca-eth instead — Device Emulation

is for *custom* emulated devices, not for shaping the

BlueField's built-in NIC personality).

What this skill provides

This is a thin loader. The body keeps only the orientation

needed to pick the right next file. The substantive Device

Emulation-specific material lives in two companion files:

• CAPABILITIES.md — what Device Emulation can express on

this version + this BlueField generation + this firmware:

the umbrella architecture (host sees an emulated PCIe

device; DPU runs the backend), the sub-library selection

rule (PCI Generic vs virtio-net vs virtio-fs), the per-

sub-library Core context shape, the doorbell / DMA

primitives that bridge host ↔ DPU, the per-sub-library

capability-query family (doca_devemu_*_cap_*), the

per-sub-library pkg-config module name, the Device

Emulation error taxonomy mapped onto the cross-library

DOCA_ERROR_* set, the observability surface, the

library-vs-packaged-service path-selection rule, and the

safety policy that gates env preconditions (DPU-side

privileges, BlueField firmware-level emulation type

enablement, BlueField generation actually supporting the

emulation class).

• TASKS.md — step-by-step workflows for the six in-scope

Device Emulation verbs: configure, build, modify,

run, test, debug. Plus a Deferred task verbs block

that points out-of-scope questions at the right next skill.

The skill assumes a host + BlueField pair where DOCA is

already installed at the standard location on both sides, the

BlueField firmware has the emulation type the user wants to

build enabled, the user has the privileges their public

install profile expects (in particular, sudo on the DPU side

to perform PCIe-level emulation), and the host kernel ships

the standard driver for the emulated device class the user is

building. It does not cover installing DOCA, flipping

firmware-level configuration, or installing host-side kernel

drivers — those paths go through

doca-setup.

Loading order

• Read this SKILL.md first to confirm the user's question

is in scope (custom emulated PCIe device built on the

doca-devemu library, not the packaged SNAP /

Virtio-net services, not the host-side kernel driver, not

standard NIC behavior).

• **For the umbrella architecture, the sub-library selection

rule (PCI Generic vs virtio-net vs virtio-fs), the per-

sub-library Core context shape, the doorbell / DMA

primitives, the per-sub-library capability-query rule,

the per-sub-library pkg-config modules, the library-vs-

packaged-service path-selection rule, the error taxonomy,

the observability surface, and the safety policy, see

CAPABILITIES.md.**

• **For step-by-step workflows — configure, build, modify,

run, test, debug — see TASKS.md.**

Both companion files cross-link to each other,

doca-version for the

canonical DOCA version-handling rules (with the Device

Emulation overlay that the chosen sub-library's pkg-config

module plus the firmware-level emulation slot plus the

doca_devemu_*_cap_* query are all part of *"is this

emulation supported here"*), and

doca-public-knowledge-map

whenever the right answer is "look it up in the public DOCA

Device Emulation umbrella guide, the per-sub-library guide

linked from it, the DOCA SNAP / Virtio-net Service guide, or

in the on-disk install layout" rather than "Device Emulation-

specific guidance".

Example questions this skill answers well

See references/details.md.

What this skill deliberately does not ship

See references/details.md.

Related skills

See references/details.md.