/doca-devemu

license: Apache-2.0
name: doca-devemu
description: >
  Use this skill when the user is doing hands-on DOCA Device Emulation
  on a BlueField DPU — exposing a custom emulated PCIe device the host
  sees as a real peripheral while DPU-side code runs the backend,
  picking the sub-library (PCI Generic, virtio-net, virtio-fs), wiring
  the per-sub-library Core context plus doorbell / DMA primitives,
  querying `doca_devemu_*_cap_*`, or debugging DOCA_ERROR_* from a
  `doca_devemu_*` call. Trigger even when the user does not say "devemu"
  — typical implicit phrasings include "expose a custom PCIe device from
  BlueField to the host", "host should see a virtio NIC backed by my DPU
  code", "lspci does not show my emulated device", "device enumerated
  but no driver binds", "DPU sees nothing when host kicks the queue", or
  "virtio feature negotiation failed at bind". Refuse and route
  elsewhere for the packaged DOCA SNAP / Virtio-net Services, host-side
  virtio kernel drivers, backend body design, or standard BlueField NIC
  behavior — those belong to other skills.
metadata:
  author: NVIDIA <doca-feedback@nvidia.com>
  kind: library
  doca_version: "3.5"
  tags:
    - doca
    - devemu
    - virtio
compatibility: >
  Requires DOCA SDK installed at /opt/mellanox/doca on BOTH the host AND
  the BlueField DPU (Ubuntu 22.04/24.04 or RHEL/SLES), with firmware
  emulation (PCI Generic / virtio-net / virtio-fs) enabled and the host
  kernel shipping the matching driver (virtio_net / virtio_fs / generic
  PCIe). Reads pkg-config for the chosen sub-library and inspects
  /opt/mellanox/doca/{lib,include,samples/doca_devemu}. The validation
  steps require a live DOCA install.

DOCA Device Emulation

Examples

• **"Expose a custom PCIe device from BlueField to the host."**

— this is in scope. Pick PCI Generic / virtio-net / virtio-fs; do not stand up SNAP or Virtio-net Service here.

• **"lspci does not show my emulated device."** — confirm the

firmware emulation type and host driver before changing DPU-side code.

Instructions

Follow Loading order below. Open the tasks companion for configure / emulate / debug. Open the capabilities companion for sub-libraries and cap queries. Do not open every companion file.

**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 the tasks companion if the user wants to *do* something (configure / build / modify / run / test / debug); open the capabilities companion 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/SKILL.md` 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 the capabilities companion. 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/SKILL.md` 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 the capabilities companion). 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 the tasks companion 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