[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M69BWS8XZJH7G018FXMXR1QV":3,"skill-same:01M69BWS8XZJH7G018FXMXR1QV":72},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":23,"publishedAt":43,"linkOnly":44,"markdownContent":45,"markdownBody":46,"frontMatter":47,"refName":48,"commitSha":49,"skillDirectory":50,"forksCount":51,"repositoryHtmlUrl":52,"repositoryHomepageUrl":53,"ownerHtmlUrl":54,"ownerBlogUrl":55,"ownerDescription":56,"updatedAt":57,"install":58,"resources":71},"01M69BWS8XZJH7G018FXMXR1QV","fuzzing",null,"Run, optimize, and debug OpenVMM fuzzers. Covers cargo-fuzz targets, crash reproduction, lldb debugging, code coverage analysis, entropy optimization, and multi-target parallel campaigns.","microsoft\u002Fopenvmm","microsoft","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F6154722?v=4","01M698VYDXZ6JW5WH3CRV650R8","Microsoft","01M69BWP49YBS03WTCPVZB5TY8",1972,"MIT","https:\u002F\u002Fgithub.com\u002Fmicrosoft\u002Fopenvmm\u002Fblob\u002Fmain\u002F.github\u002Fskills\u002Ffuzzing\u002FSKILL.md",[18],{"categoryNo":19,"categoryName":20,"taxonomyType":21,"taxonomyTypeDesc":22},"01JBSEEDCAT000000000000030","开发工程师","PROFESSION","适用职业",[5,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42],"coverage","target","lldb","targets","multi","cargo","code coverage","campaigns","optimize","crash","parallel","analysis","entropy","Optimization","code","run","debugging","debug","coverage analysis","2026-11-10 10:12:30",false,"---\nname: fuzzing\ndescription: \"Run, optimize, and debug OpenVMM fuzzers. Covers cargo-fuzz targets, crash reproduction, lldb debugging, code coverage analysis, entropy optimization, and multi-target parallel campaigns.\"\n---\n\n# OpenVMM Fuzzer Guide\n\n## Scope and resource limits\n\nReproduce a supplied crash once before expanding the investigation. For\nexploratory fuzzing, use explicit time and worker limits. Before a multi-target\ncampaign, establish a total CPU and time budget; do not assume the machine's\nfull capacity is available.\n\nKeep runs attached by default. Follow the execution environment's process\nmanagement rules, and choose output paths appropriate to that environment.\n\n## Prerequisites\n\n- **Linux only** — libfuzzer-sys doesn't support Windows.\n- **cargo-fuzz**: `cargo install cargo-fuzz`\n- **lldb** (for debugging): `sudo apt-get install -y lldb`\n- **aarch64 RUSTFLAGS**: On aarch64, set `RUSTFLAGS=\"-Ctarget-feature=+lse,+neon\"` or builds fail with atomics errors. Not needed on x86_64.\n\n## Fuzz targets\n\nFuzz targets live in `\u003Ccrate>\u002Ffuzz\u002F` directories alongside the crate they test.\nEach has a `Cargo.toml` with `cargo-fuzz = true` metadata and a `fuzz_\u003Cname>.rs`\nbinary. Find all targets:\n\n```bash\ncargo xtask fuzz list\n```\n\nFor a crate without a `fuzz\u002F` directory, create a harness from a template:\n\n```bash\ncargo xtask fuzz init \u003CPACKAGE_NAME> basic\n```\n\nThe command also adds the generated fuzz crate to the workspace members.\nUse the `chipset-device` template for `ChipsetDevice` harnesses.\n\n## Running a fuzzer\n\n```bash\n# Reproduce a specific crash artifact\ncargo xtask fuzz run fuzz_ide path\u002Fto\u002Fcrash-artifact\n\n# Explore for 60 seconds with one worker\ncargo xtask fuzz run fuzz_ide -- -- -fork=1 -max_total_time=60\n```\n\nThe xtask wrapper sets `XTASK_FUZZ_REPRO=1` automatically when an artifact\npath is provided, which enables `init_tracing_if_repro()` in the fuzz target.\n\n## Build without running\n\n```bash\ncargo xtask fuzz build fuzz_ide\n```\n\nThe binary lands at `target\u002F\u003Ctriple>\u002Frelease\u002Ffuzz_ide` (e.g.,\n`target\u002Faarch64-unknown-linux-gnu\u002Frelease\u002Ffuzz_ide` or\n`target\u002Fx86_64-unknown-linux-gnu\u002Frelease\u002Ffuzz_ide`).\n\n## Reproducing a crash (direct binary)\n\nRunning the binary directly is faster for iteration than going through xtask:\n\n```bash\n# Without tracing (fast, quiet)\n.\u002Ftarget\u002F\u003Ctriple>\u002Frelease\u002Ffuzz_ide path\u002Fto\u002Fcrash-artifact\n\n# With tracing (verbose — shows device state at each poll)\nXTASK_FUZZ_REPRO=1 .\u002Ftarget\u002F\u003Ctriple>\u002Frelease\u002Ffuzz_ide path\u002Fto\u002Fcrash-artifact\n\n# With backtrace\nRUST_BACKTRACE=full .\u002Ftarget\u002F\u003Ctriple>\u002Frelease\u002Ffuzz_ide path\u002Fto\u002Fcrash-artifact\n```\n\n## Debugging with lldb\n\n### Key lessons\n\n1. **Use batch mode with a command file** — lldb's interactive prompt doesn't\n   work well from automated terminals. Write commands to a file and use\n   `lldb -b -s \u003Cfile>`.\n2. **Set `auto-confirm true`** — prevents lldb from blocking on \"Do you really\n   want to quit?\" prompts.\n3. **Breakpoint on `panic_fmt`** — `rust_begin_unwind` is often mangled and\n   won't resolve. Use `-r panic_fmt` instead.\n4. **Drop `XTASK_FUZZ_REPRO`** when using lldb — the tracing output from\n   repeated polls produces megabytes of spam that buries the debugger output.\n5. **Release builds have limited variable info** — `frame variable` may show\n   nothing. For richer inspection, build with `--dev` (see below).\n\n### Command file template\n\nCreate a file (e.g., `scratch\u002Flldb_fuzz.cmd`):\n\n```\nsettings set auto-confirm true\nbreakpoint set -r panic_fmt\nrun\nbt 20\nframe select 1\nsource list\nframe select 2\nsource list\nframe variable\nquit\n```\n\n### Run it\n\n```bash\nlldb -b -s scratch\u002Flldb_fuzz.cmd \\\n  -- .\u002Ftarget\u002F\u003Ctriple>\u002Frelease\u002Ffuzz_ide \\\n  path\u002Fto\u002Fcrash-artifact\n```\n\nKeep the full debugger output so that startup errors and crash details remain\nvisible.\n\n### Using rust-lldb\n\n`rust-lldb` adds Rust pretty-printers for `Vec`, `String`, etc. It requires\nlldb to be installed. Usage is the same but replace `lldb` with `rust-lldb`:\n\n```bash\nrust-lldb -b -s scratch\u002Flldb_fuzz.cmd \\\n  -- .\u002Ftarget\u002F\u003Ctriple>\u002Frelease\u002Ffuzz_ide \\\n  path\u002Fto\u002Fcrash-artifact\n```\n\n### Debug builds for variable inspection\n\nRelease builds have limited `frame variable` output. For full variable\ninspection, build with `--dev`:\n\n```bash\ncargo xtask fuzz build fuzz_ide -- --dev\n```\n\nThe debug binary lands at `target\u002F\u003Ctriple>\u002Fdebug\u002Ffuzz_ide`. It's slower but\nlldb can inspect all locals and struct fields.\n\n### Navigating Rust wrapper types in lldb\n\nReaching the actual data through Arc, Mutex, UnsafeCell etc. requires\nknowing the field path. Use `type lookup` to discover struct layouts:\n\n```\n(lldb) type lookup closeable_mutex::CloseableMutex\u003Cide::IdeDevice>\n```\n\nCommon wrapper-type traversal patterns:\n\n| Rust type | lldb field path |\n|-----------|----------------|\n| `Arc\u003CT>` | `var.ptr.pointer->data` (through `ArcInner`) |\n| `CloseableMutex\u003CT>` | `.value.value` (UnsafeCell inside Mutex) |\n| `UnsafeCell\u003CT>` | `.value` |\n| `Option\u003CT>` | `.$variants$.$variant$.value.__0` (check `$discr$` — 0 = None for most types) |\n| Rust enum | `.$variants$.$variant$N.value.__0` (N = variant index) |\n\nFull path example for IDE device state through `Arc\u003CCloseableMutex\u003CIdeDevice>>`:\n\n```\n(lldb) expr ide_device.ptr.pointer->data.value.value.channels[0].state\n(lldb) expr ide_device.ptr.pointer->data.value.value.channels[0].enlightened_write\n(lldb) expr ide_device.ptr.pointer->data.value.value.channels[0].bus_master_state\n```\n\nFor drive registers inside `Option\u003CDiskDrive>` containing an enum variant:\n\n```\n(lldb) expr ide_device.ptr.pointer->data.value.value.channels[0].drives[0].$variants$.$variant$.value.__0.$variants$.$variant$.value.__0.state.regs\n```\n\n### Setting breakpoint ignore counts\n\nTo skip the first N hits of a breakpoint (useful when a function is called\nhundreds of times during polling):\n\n```\n(lldb) breakpoint set -f lib.rs -l 1253\n(lldb) breakpoint modify -i 500 1\n(lldb) run\n```\n\nThis skips the first 500 hits, then stops on hit 501.\n\n### Reading Rust bitfield status registers\n\nStatus register values appear as `(__0 = 'X')` where `'X'` is the char at\nthat byte value. Decode manually: `0x58` = bits 3,4,6 set = `drq`, `dsc`,\n`drdy`.\n\n## Minimizing crash inputs\n\n```bash\ncargo xtask fuzz tmin fuzz_ide path\u002Fto\u002Fcrash-artifact\n```\n\n## Corpus management\n\n```bash\n# Minimize the corpus (remove redundant inputs)\ncargo xtask fuzz cmin fuzz_ide\n```\n\nCorpus files live in `\u003Ccrate>\u002Ffuzz\u002Fcorpus\u002F\u003Ctarget>\u002F`.\nCrash artifacts land in `\u003Ccrate>\u002Ffuzz\u002Fartifacts\u002F\u003Ctarget>\u002F`.\n\n## Fuzzer optimization principles\n\n### Entropy efficiency\nEvery byte of fuzzer input should drive meaningful behavior. Common wastes:\n- **Arbitrary setup parameters that don't affect coverage** — e.g., guest memory size, buffer counts. Use fixed values.\n- **`u.ratio()` calls for branching** — consumes entropy for each decision. Use `Arbitrary` enums instead (1 byte per decision vs 8+ for ratio).\n- **Redundant `arbitrary_data()` calls** — generate composite values with one call instead of field-by-field. E.g., a Guid from `[u8; 16]` instead of 11 separate calls.\n\n### Simplification\n- **Merge duplicated functions** that only differ in a small parameter. Use an enum variant to select behavior.\n- **Remove dead protocol negotiation** — if a device rejects all interesting operations without init, always negotiate. Raw packet paths can still exercise init state machines through mutation.\n- **Remove wrapper functions** that add no value over calling the underlying API directly.\n\n### Coverage gaps\n- **0-item\u002Fempty configurations** — fuzzers that always attach 1+ disks\u002Fdevices miss the empty-controller code paths. Use `0..=N` ranges.\n- **Hardcoded setup parameters** can hide code paths. E.g., fixed namespace IDs mean only one NVMe identify-namespace path is tested. Make setup params fuzzer-driven where they affect behavior.\n- **TODOs mark legitimate gaps** — don't remove TODOs unless you've verified the marked code path is either (a) implemented or (b) genuinely doesn't affect coverage.\n\n### Performance\n- **Smaller backing stores** — RAM disks used for fuzzing don't need to be large. 32KB is sufficient for most device fuzzers (was 4MB).\n- **Fixed guest memory** — varying guest memory size wastes entropy without affecting device logic.\n- **Always negotiate protocols** — skipping negotiation wastes 100% of remaining fuzz actions on a single error branch.\n- **`-fork=N`** for parallel fuzzing across CPUs. Allocate cores proportionally to fuzzer complexity.\n\n## Multi-target parallel fuzzing\n\nChoose the targets, total worker count, and duration before starting a\ncampaign. Each target's workers count toward the total CPU budget. For example,\nthis command gives one selected target one worker for 60 seconds:\n\n```bash\ncargo xtask fuzz run fuzz_storvsp -- -- \\\n  -fork=1 -max_total_time=60 -print_final_stats=1\n```\n\nRepeat the bounded command for other selected targets within the agreed budget.\nApply the aarch64 flags from the prerequisites only on aarch64. Keep each run's\nfull output, or save it to a caller-selected log path.\n\nCollect coverage afterward when the task includes gap analysis. Do not extend\nthe campaign beyond its budget without confirming the new scope.\n\n## Code coverage\n\n### Prerequisites\n\nEverything from the main prerequisites, plus:\n\n- **llvm-tools**: `rustup component add llvm-tools`\n- **lcov** (for HTML reports): `sudo apt-get install -y lcov`\n\n### Collecting coverage\n\nThe xtask has built-in coverage support. It runs each corpus entry through\na coverage-instrumented build and merges the results:\n\n```bash\n# Collect coverage data only\ncargo xtask fuzz coverage fuzz_ide\n\n# Collect + generate HTML report (requires lcov + genhtml)\ncargo xtask fuzz coverage fuzz_ide --with-html-report\n\n# Skip rebuild, just regenerate report from existing profdata\ncargo xtask fuzz coverage fuzz_ide --with-html-report --only-report\n```\n\nOn aarch64, set `RUSTFLAGS=\"-Ctarget-feature=+lse,+neon\"` as usual.\n\nCoverage artifacts land in:\n\n| Artifact | Path |\n|----------|------|\n| profdata | `\u003Ccrate>\u002Ffuzz\u002Fcoverage\u002F\u003Ctarget>\u002Fcoverage.profdata` |\n| HTML report | `target\u002F\u003Ctriple>\u002Fcoverage\u002F\u003Ctriple>\u002Frelease\u002Flcov_html_\u003Ctarget>\u002Findex.html` |\n\n### Filtering coverage to relevant crates\n\nThe raw HTML report covers *all* compiled code including dependencies — the\noverall percentage is meaningless (typically 4–6%). What matters is coverage\nof the **target crate itself** and its immediate domain dependencies.\n\nUse `llvm-cov report` with source path filtering:\n\n```bash\n# Find the llvm-cov binary from the toolchain\nSYSROOT=$(rustc --print sysroot)\nHOST=$(rustc -vV | awk '\u002F^host:\u002F { print $2 }')\nLLVM_COV=\"$SYSROOT\u002Flib\u002Frustlib\u002F$HOST\u002Fbin\u002Fllvm-cov\"\n\n# Full per-file report, excluding third-party code\n\"$LLVM_COV\" report \\\n  -instr-profile \u003Ccrate>\u002Ffuzz\u002Fcoverage\u002F\u003Ctarget>\u002Fcoverage.profdata \\\n  -object target\u002F\u003Ctriple>\u002Fcoverage\u002F\u003Ctriple>\u002Frelease\u002F\u003Ctarget> \\\n  --ignore-filename-regex='(rustc|\\.cargo|registry)' 2>&1 \\\n  | grep 'vm\u002Fdevices\u002Fstorage\u002Fide\u002Fsrc\u002F'\n```\n\nFor lcov-based per-file analysis, choose an output path in a writable directory,\nthen export to lcov and extract per-file stats:\n\n```bash\nCOVERAGE_LCOV=path\u002Fto\u002Fcoverage.lcov\n\"$LLVM_COV\" export \\\n  -instr-profile \u003Ccrate>\u002Ffuzz\u002Fcoverage\u002F\u003Ctarget>\u002Fcoverage.profdata \\\n  -object target\u002F\u003Ctriple>\u002Fcoverage\u002F\u003Ctriple>\u002Frelease\u002F\u003Ctarget> \\\n  --ignore-filename-regex='(rustc|\\.cargo|registry)' \\\n  -format=lcov > \"$COVERAGE_LCOV\"\n\n# Per-file function\u002Fline summary from lcov\nawk '\u002FSF:.*ide\\\u002Fsrc\\\u002Flib\\.rs$\u002F,\u002Fend_of_record\u002F' \"$COVERAGE_LCOV\" \\\n  | grep -E '^(FNF|FNH|LF|LH):'\n# FNF\u002FFNH = functions found\u002Fhit, LF\u002FLH = lines found\u002Fhit\n\n# Find uncovered line numbers\nawk '\u002FSF:.*ide\\\u002Fsrc\\\u002Flib\\.rs$\u002F,\u002Fend_of_record\u002F' \"$COVERAGE_LCOV\" \\\n  | grep '^DA:' | grep ',0$' | cut -d: -f2 | cut -d, -f1\n```\n\n## Coverage scope rules\n\nEach fuzzer has a **primary scope** (the crate it exists to test) and\n**secondary scope** (dependencies it exercises incidentally). Coverage\nimprovements should focus on primary scope first.\n\n### What coverage matters per fuzzer\n\n| Fuzzer | Primary scope | Secondary scope | Out of scope |\n|--------|--------------|-----------------|--------------|\n| fuzz_ide | `ide\u002Fsrc\u002F` | `scsidisk\u002Fsrc\u002Fscsidvd\u002F`, `scsidisk\u002Fsrc\u002Fatapi_scsi.rs`, `disk_backend\u002F`, `disklayer_ram\u002F` | `pci_core\u002F`, `vmcore\u002F`, `guestmem\u002F` (infrastructure) |\n| fuzz_storvsp | `storvsp\u002Fsrc\u002F` | `scsidisk\u002Fsrc\u002Flib.rs`, `vmbus_ring\u002F`, `vmbus_async\u002F`, `disk_backend\u002F` | `vmbus_channel\u002F`, `vmbus_core\u002F` (infrastructure) |\n| fuzz_nvme_driver | `nvme_driver\u002Fsrc\u002F` | `nvme\u002Fsrc\u002F`, `nvme_spec\u002F`, `user_driver\u002F` | `page_pool_alloc\u002F`, `vmcore\u002F` |\n| fuzz_firmware_uefi_nvram | `firmware_uefi\u002Fsrc\u002Fservice\u002Fnvram\u002F` | `uefi_nvram_specvars\u002F` | `crypto`, `openssl` (infrastructure) |\n| fuzz_firmware_uefi_diagnostics | `firmware_uefi\u002Fsrc\u002Fservice\u002Fdiagnostics\u002F` | — | `guestmem\u002F` |\n| fuzz_chipset_cmos_rtc | `chipset\u002Fsrc\u002Fcmos_rtc\u002F` | `chipset_device_fuzz\u002F` | `pal_async\u002F`, `vmcore\u002F` |\n| fuzz_scsi_buffers | `scsi_buffers\u002Fsrc\u002F` | — | `guestmem\u002F` |\n| fuzz_chipset_battery | `chipset\u002Fsrc\u002Fbattery\u002F` | `chipset_device_fuzz\u002F` | — |\n\n**Rules:**\n\n1. **Primary scope is the goal.** Line coverage of the target crate is the\n   metric to optimize. The fuzzer exists to find bugs in this code.\n\n2. **Secondary scope matters when it's a trust boundary.** `scsidisk` parsing\n   guest-supplied SCSI commands is a real attack surface — coverage there has\n   value. But `disklayer_ram` just storing bytes is infrastructure.\n\n3. **Out-of-scope code is noise.** `pci_core`, `vmcore`, `guestmem` get\n   exercised incidentally. Don't optimize the fuzzer to improve their coverage\n   — those crates deserve their own fuzzers if coverage matters.\n\n4. **Check the harness before excluding save\u002Frestore or resolver code.** If the\n   harness does not exercise serialization or resource resolution, exclude\n   those paths from its coverage target. Do not assume every harness omits them.\n\n5. **Inspect (`InspectMut`) implementations are low-value.** These debug\u002F\n   diagnostics paths aren't part of the attack surface. Low coverage is\n   acceptable.\n\n## Coverage-guided fuzzer improvement process\n\n### Step 1: Collect and filter\n\n```bash\n# Run coverage\ncargo xtask fuzz coverage \u003Ctarget> --with-html-report\n\n# Open the HTML report for visual inspection\n# target\u002F\u003Ctriple>\u002Fcoverage\u002F\u003Ctriple>\u002Frelease\u002Flcov_html_\u003Ctarget>\u002Findex.html\n```\n\n### Step 2: Identify gaps in primary scope\n\nLook at the HTML report or extract uncovered lines:\n\n```bash\nawk '\u002FSF:.*\u003Ccrate>\\\u002Fsrc\\\u002Flib\\.rs$\u002F,\u002Fend_of_record\u002F' \"$COVERAGE_LCOV\" \\\n  | grep '^DA:' | grep ',0$' | cut -d: -f2 | cut -d, -f1\n```\n\nRead the source at those lines. Classify each uncovered region:\n\n| Classification | Action |\n|---------------|--------|\n| **Reachable via fuzzer input** — the fuzzer *could* reach this code but hasn't found the right input sequence | Investigate why. Is the path gated by specific byte patterns the fuzzer struggles to generate? |\n| **Structurally unreachable** — the fuzzer harness doesn't wire up the code path (e.g., save\u002Frestore, PCI config reads the harness skips) | Extend the harness: add new `FuzzAction` variants, expose more device interfaces to the fuzzer. |\n| **Error-handling \u002F defensive code** — `unreachable!()`, error paths for invalid hardware states | Check guest\u002Froot reachability first. Investigate reachable panics and malformed-input paths; do not dismiss them as low priority. |\n| **Inspect \u002F debug only** — `InspectMut`, `Display`, `Debug` impls | Skip entirely. Not attack surface. |\n\n### Step 3: Improve the fuzzer\n\nImprovements fall into two categories, in priority order:\n\n**A. Extend the fuzz harness**\n\nIf an entire code path is structurally unreachable, the harness needs changes.\nExamples:\n\n- fuzz_ide doesn't exercise PCI config space reads → add PCI config read\u002Fwrite\n  to the `FuzzAction` enum in `chipset_device_fuzz`\n- fuzz_storvsp doesn't test sub-channel operations → add corresponding VMBus\n  channel actions\n\n**B. Improve `Arbitrary` implementations**\n\nIf the fuzzer generates mostly one type of operation, check the `Arbitrary`\nimpl. Common issues:\n\n- Uniform distribution across action types wastes entropy on less interesting\n  paths. Weight toward rarer operations.\n- Overly constrained generation (e.g., only valid SCSI commands) misses\n  malformed-input bugs.\n- Overly unconstrained generation (random bytes everywhere) wastes time on\n  inputs that fail early validation and never reach deep code.\n\n### Step 4: Measure improvement\n\nAfter making changes:\n\n1. Run the fuzzer for the same bounded duration before and after the change\n2. Minimize the corpus: `cargo xtask fuzz cmin \u003Ctarget>`\n3. Collect coverage again\n4. Compare line counts against prior coverage runs\n\nTrack coverage changes over time. Ratchet up: if a change reduces primary\nscope coverage, investigate why.\n\n### Step 5: Iterate\n\nCoverage-guided improvement is iterative. Each cycle:\n\n1. Collect → 2. Identify gaps → 3. Fix → 4. Fuzz → 5. Measure → repeat\n\nTarget **≥85% line coverage** in primary scope as a practical goal. The\nremaining ~15% is typically error-handling code, debug impls, and paths\nrequiring specific hardware\u002Ftiming conditions the fuzzer can't easily produce.\nCoverage percentages are not safety thresholds. Investigate guest\u002Froot-reachable\npanics and malformed-input paths regardless of the percentage.\n","# OpenVMM Fuzzer Guide\n\n## Scope and resource limits\n\nReproduce a supplied crash once before expanding the investigation. For\nexploratory fuzzing, use explicit time and worker limits. Before a multi-target\ncampaign, establish a total CPU and time budget; do not assume the machine's\nfull capacity is available.\n\nKeep runs attached by default. Follow the execution environment's process\nmanagement rules, and choose output paths appropriate to that environment.\n\n## Prerequisites\n\n- **Linux only** — libfuzzer-sys doesn't support Windows.\n- **cargo-fuzz**: `cargo install cargo-fuzz`\n- **lldb** (for debugging): `sudo apt-get install -y lldb`\n- **aarch64 RUSTFLAGS**: On aarch64, set `RUSTFLAGS=\"-Ctarget-feature=+lse,+neon\"` or builds fail with atomics errors. Not needed on x86_64.\n\n## Fuzz targets\n\nFuzz targets live in `\u003Ccrate>\u002Ffuzz\u002F` directories alongside the crate they test.\nEach has a `Cargo.toml` with `cargo-fuzz = true` metadata and a `fuzz_\u003Cname>.rs`\nbinary. Find all targets:\n\n```bash\ncargo xtask fuzz list\n```\n\nFor a crate without a `fuzz\u002F` directory, create a harness from a template:\n\n```bash\ncargo xtask fuzz init \u003CPACKAGE_NAME> basic\n```\n\nThe command also adds the generated fuzz crate to the workspace members.\nUse the `chipset-device` template for `ChipsetDevice` harnesses.\n\n## Running a fuzzer\n\n```bash\n# Reproduce a specific crash artifact\ncargo xtask fuzz run fuzz_ide path\u002Fto\u002Fcrash-artifact\n\n# Explore for 60 seconds with one worker\ncargo xtask fuzz run fuzz_ide -- -- -fork=1 -max_total_time=60\n```\n\nThe xtask wrapper sets `XTASK_FUZZ_REPRO=1` automatically when an artifact\npath is provided, which enables `init_tracing_if_repro()` in the fuzz target.\n\n## Build without running\n\n```bash\ncargo xtask fuzz build fuzz_ide\n```\n\nThe binary lands at `target\u002F\u003Ctriple>\u002Frelease\u002Ffuzz_ide` (e.g.,\n`target\u002Faarch64-unknown-linux-gnu\u002Frelease\u002Ffuzz_ide` or\n`target\u002Fx86_64-unknown-linux-gnu\u002Frelease\u002Ffuzz_ide`).\n\n## Reproducing a crash (direct binary)\n\nRunning the binary directly is faster for iteration than going through xtask:\n\n```bash\n# Without tracing (fast, quiet)\n.\u002Ftarget\u002F\u003Ctriple>\u002Frelease\u002Ffuzz_ide path\u002Fto\u002Fcrash-artifact\n\n# With tracing (verbose — shows device state at each poll)\nXTASK_FUZZ_REPRO=1 .\u002Ftarget\u002F\u003Ctriple>\u002Frelease\u002Ffuzz_ide path\u002Fto\u002Fcrash-artifact\n\n# With backtrace\nRUST_BACKTRACE=full .\u002Ftarget\u002F\u003Ctriple>\u002Frelease\u002Ffuzz_ide path\u002Fto\u002Fcrash-artifact\n```\n\n## Debugging with lldb\n\n### Key lessons\n\n1. **Use batch mode with a command file** — lldb's interactive prompt doesn't\n   work well from automated terminals. Write commands to a file and use\n   `lldb -b -s \u003Cfile>`.\n2. **Set `auto-confirm true`** — prevents lldb from blocking on \"Do you really\n   want to quit?\" prompts.\n3. **Breakpoint on `panic_fmt`** — `rust_begin_unwind` is often mangled and\n   won't resolve. Use `-r panic_fmt` instead.\n4. **Drop `XTASK_FUZZ_REPRO`** when using lldb — the tracing output from\n   repeated polls produces megabytes of spam that buries the debugger output.\n5. **Release builds have limited variable info** — `frame variable` may show\n   nothing. For richer inspection, build with `--dev` (see below).\n\n### Command file template\n\nCreate a file (e.g., `scratch\u002Flldb_fuzz.cmd`):\n\n```\nsettings set auto-confirm true\nbreakpoint set -r panic_fmt\nrun\nbt 20\nframe select 1\nsource list\nframe select 2\nsource list\nframe variable\nquit\n```\n\n### Run it\n\n```bash\nlldb -b -s scratch\u002Flldb_fuzz.cmd \\\n  -- .\u002Ftarget\u002F\u003Ctriple>\u002Frelease\u002Ffuzz_ide \\\n  path\u002Fto\u002Fcrash-artifact\n```\n\nKeep the full debugger output so that startup errors and crash details remain\nvisible.\n\n### Using rust-lldb\n\n`rust-lldb` adds Rust pretty-printers for `Vec`, `String`, etc. It requires\nlldb to be installed. Usage is the same but replace `lldb` with `rust-lldb`:\n\n```bash\nrust-lldb -b -s scratch\u002Flldb_fuzz.cmd \\\n  -- .\u002Ftarget\u002F\u003Ctriple>\u002Frelease\u002Ffuzz_ide \\\n  path\u002Fto\u002Fcrash-artifact\n```\n\n### Debug builds for variable inspection\n\nRelease builds have limited `frame variable` output. For full variable\ninspection, build with `--dev`:\n\n```bash\ncargo xtask fuzz build fuzz_ide -- --dev\n```\n\nThe debug binary lands at `target\u002F\u003Ctriple>\u002Fdebug\u002Ffuzz_ide`. It's slower but\nlldb can inspect all locals and struct fields.\n\n### Navigating Rust wrapper types in lldb\n\nReaching the actual data through Arc, Mutex, UnsafeCell etc. requires\nknowing the field path. Use `type lookup` to discover struct layouts:\n\n```\n(lldb) type lookup closeable_mutex::CloseableMutex\u003Cide::IdeDevice>\n```\n\nCommon wrapper-type traversal patterns:\n\n| Rust type | lldb field path |\n|-----------|----------------|\n| `Arc\u003CT>` | `var.ptr.pointer->data` (through `ArcInner`) |\n| `CloseableMutex\u003CT>` | `.value.value` (UnsafeCell inside Mutex) |\n| `UnsafeCell\u003CT>` | `.value` |\n| `Option\u003CT>` | `.$variants$.$variant$.value.__0` (check `$discr$` — 0 = None for most types) |\n| Rust enum | `.$variants$.$variant$N.value.__0` (N = variant index) |\n\nFull path example for IDE device state through `Arc\u003CCloseableMutex\u003CIdeDevice>>`:\n\n```\n(lldb) expr ide_device.ptr.pointer->data.value.value.channels[0].state\n(lldb) expr ide_device.ptr.pointer->data.value.value.channels[0].enlightened_write\n(lldb) expr ide_device.ptr.pointer->data.value.value.channels[0].bus_master_state\n```\n\nFor drive registers inside `Option\u003CDiskDrive>` containing an enum variant:\n\n```\n(lldb) expr ide_device.ptr.pointer->data.value.value.channels[0].drives[0].$variants$.$variant$.value.__0.$variants$.$variant$.value.__0.state.regs\n```\n\n### Setting breakpoint ignore counts\n\nTo skip the first N hits of a breakpoint (useful when a function is called\nhundreds of times during polling):\n\n```\n(lldb) breakpoint set -f lib.rs -l 1253\n(lldb) breakpoint modify -i 500 1\n(lldb) run\n```\n\nThis skips the first 500 hits, then stops on hit 501.\n\n### Reading Rust bitfield status registers\n\nStatus register values appear as `(__0 = 'X')` where `'X'` is the char at\nthat byte value. Decode manually: `0x58` = bits 3,4,6 set = `drq`, `dsc`,\n`drdy`.\n\n## Minimizing crash inputs\n\n```bash\ncargo xtask fuzz tmin fuzz_ide path\u002Fto\u002Fcrash-artifact\n```\n\n## Corpus management\n\n```bash\n# Minimize the corpus (remove redundant inputs)\ncargo xtask fuzz cmin fuzz_ide\n```\n\nCorpus files live in `\u003Ccrate>\u002Ffuzz\u002Fcorpus\u002F\u003Ctarget>\u002F`.\nCrash artifacts land in `\u003Ccrate>\u002Ffuzz\u002Fartifacts\u002F\u003Ctarget>\u002F`.\n\n## Fuzzer optimization principles\n\n### Entropy efficiency\nEvery byte of fuzzer input should drive meaningful behavior. Common wastes:\n- **Arbitrary setup parameters that don't affect coverage** — e.g., guest memory size, buffer counts. Use fixed values.\n- **`u.ratio()` calls for branching** — consumes entropy for each decision. Use `Arbitrary` enums instead (1 byte per decision vs 8+ for ratio).\n- **Redundant `arbitrary_data()` calls** — generate composite values with one call instead of field-by-field. E.g., a Guid from `[u8; 16]` instead of 11 separate calls.\n\n### Simplification\n- **Merge duplicated functions** that only differ in a small parameter. Use an enum variant to select behavior.\n- **Remove dead protocol negotiation** — if a device rejects all interesting operations without init, always negotiate. Raw packet paths can still exercise init state machines through mutation.\n- **Remove wrapper functions** that add no value over calling the underlying API directly.\n\n### Coverage gaps\n- **0-item\u002Fempty configurations** — fuzzers that always attach 1+ disks\u002Fdevices miss the empty-controller code paths. Use `0..=N` ranges.\n- **Hardcoded setup parameters** can hide code paths. E.g., fixed namespace IDs mean only one NVMe identify-namespace path is tested. Make setup params fuzzer-driven where they affect behavior.\n- **TODOs mark legitimate gaps** — don't remove TODOs unless you've verified the marked code path is either (a) implemented or (b) genuinely doesn't affect coverage.\n\n### Performance\n- **Smaller backing stores** — RAM disks used for fuzzing don't need to be large. 32KB is sufficient for most device fuzzers (was 4MB).\n- **Fixed guest memory** — varying guest memory size wastes entropy without affecting device logic.\n- **Always negotiate protocols** — skipping negotiation wastes 100% of remaining fuzz actions on a single error branch.\n- **`-fork=N`** for parallel fuzzing across CPUs. Allocate cores proportionally to fuzzer complexity.\n\n## Multi-target parallel fuzzing\n\nChoose the targets, total worker count, and duration before starting a\ncampaign. Each target's workers count toward the total CPU budget. For example,\nthis command gives one selected target one worker for 60 seconds:\n\n```bash\ncargo xtask fuzz run fuzz_storvsp -- -- \\\n  -fork=1 -max_total_time=60 -print_final_stats=1\n```\n\nRepeat the bounded command for other selected targets within the agreed budget.\nApply the aarch64 flags from the prerequisites only on aarch64. Keep each run's\nfull output, or save it to a caller-selected log path.\n\nCollect coverage afterward when the task includes gap analysis. Do not extend\nthe campaign beyond its budget without confirming the new scope.\n\n## Code coverage\n\n### Prerequisites\n\nEverything from the main prerequisites, plus:\n\n- **llvm-tools**: `rustup component add llvm-tools`\n- **lcov** (for HTML reports): `sudo apt-get install -y lcov`\n\n### Collecting coverage\n\nThe xtask has built-in coverage support. It runs each corpus entry through\na coverage-instrumented build and merges the results:\n\n```bash\n# Collect coverage data only\ncargo xtask fuzz coverage fuzz_ide\n\n# Collect + generate HTML report (requires lcov + genhtml)\ncargo xtask fuzz coverage fuzz_ide --with-html-report\n\n# Skip rebuild, just regenerate report from existing profdata\ncargo xtask fuzz coverage fuzz_ide --with-html-report --only-report\n```\n\nOn aarch64, set `RUSTFLAGS=\"-Ctarget-feature=+lse,+neon\"` as usual.\n\nCoverage artifacts land in:\n\n| Artifact | Path |\n|----------|------|\n| profdata | `\u003Ccrate>\u002Ffuzz\u002Fcoverage\u002F\u003Ctarget>\u002Fcoverage.profdata` |\n| HTML report | `target\u002F\u003Ctriple>\u002Fcoverage\u002F\u003Ctriple>\u002Frelease\u002Flcov_html_\u003Ctarget>\u002Findex.html` |\n\n### Filtering coverage to relevant crates\n\nThe raw HTML report covers *all* compiled code including dependencies — the\noverall percentage is meaningless (typically 4–6%). What matters is coverage\nof the **target crate itself** and its immediate domain dependencies.\n\nUse `llvm-cov report` with source path filtering:\n\n```bash\n# Find the llvm-cov binary from the toolchain\nSYSROOT=$(rustc --print sysroot)\nHOST=$(rustc -vV | awk '\u002F^host:\u002F { print $2 }')\nLLVM_COV=\"$SYSROOT\u002Flib\u002Frustlib\u002F$HOST\u002Fbin\u002Fllvm-cov\"\n\n# Full per-file report, excluding third-party code\n\"$LLVM_COV\" report \\\n  -instr-profile \u003Ccrate>\u002Ffuzz\u002Fcoverage\u002F\u003Ctarget>\u002Fcoverage.profdata \\\n  -object target\u002F\u003Ctriple>\u002Fcoverage\u002F\u003Ctriple>\u002Frelease\u002F\u003Ctarget> \\\n  --ignore-filename-regex='(rustc|\\.cargo|registry)' 2>&1 \\\n  | grep 'vm\u002Fdevices\u002Fstorage\u002Fide\u002Fsrc\u002F'\n```\n\nFor lcov-based per-file analysis, choose an output path in a writable directory,\nthen export to lcov and extract per-file stats:\n\n```bash\nCOVERAGE_LCOV=path\u002Fto\u002Fcoverage.lcov\n\"$LLVM_COV\" export \\\n  -instr-profile \u003Ccrate>\u002Ffuzz\u002Fcoverage\u002F\u003Ctarget>\u002Fcoverage.profdata \\\n  -object target\u002F\u003Ctriple>\u002Fcoverage\u002F\u003Ctriple>\u002Frelease\u002F\u003Ctarget> \\\n  --ignore-filename-regex='(rustc|\\.cargo|registry)' \\\n  -format=lcov > \"$COVERAGE_LCOV\"\n\n# Per-file function\u002Fline summary from lcov\nawk '\u002FSF:.*ide\\\u002Fsrc\\\u002Flib\\.rs$\u002F,\u002Fend_of_record\u002F' \"$COVERAGE_LCOV\" \\\n  | grep -E '^(FNF|FNH|LF|LH):'\n# FNF\u002FFNH = functions found\u002Fhit, LF\u002FLH = lines found\u002Fhit\n\n# Find uncovered line numbers\nawk '\u002FSF:.*ide\\\u002Fsrc\\\u002Flib\\.rs$\u002F,\u002Fend_of_record\u002F' \"$COVERAGE_LCOV\" \\\n  | grep '^DA:' | grep ',0$' | cut -d: -f2 | cut -d, -f1\n```\n\n## Coverage scope rules\n\nEach fuzzer has a **primary scope** (the crate it exists to test) and\n**secondary scope** (dependencies it exercises incidentally). Coverage\nimprovements should focus on primary scope first.\n\n### What coverage matters per fuzzer\n\n| Fuzzer | Primary scope | Secondary scope | Out of scope |\n|--------|--------------|-----------------|--------------|\n| fuzz_ide | `ide\u002Fsrc\u002F` | `scsidisk\u002Fsrc\u002Fscsidvd\u002F`, `scsidisk\u002Fsrc\u002Fatapi_scsi.rs`, `disk_backend\u002F`, `disklayer_ram\u002F` | `pci_core\u002F`, `vmcore\u002F`, `guestmem\u002F` (infrastructure) |\n| fuzz_storvsp | `storvsp\u002Fsrc\u002F` | `scsidisk\u002Fsrc\u002Flib.rs`, `vmbus_ring\u002F`, `vmbus_async\u002F`, `disk_backend\u002F` | `vmbus_channel\u002F`, `vmbus_core\u002F` (infrastructure) |\n| fuzz_nvme_driver | `nvme_driver\u002Fsrc\u002F` | `nvme\u002Fsrc\u002F`, `nvme_spec\u002F`, `user_driver\u002F` | `page_pool_alloc\u002F`, `vmcore\u002F` |\n| fuzz_firmware_uefi_nvram | `firmware_uefi\u002Fsrc\u002Fservice\u002Fnvram\u002F` | `uefi_nvram_specvars\u002F` | `crypto`, `openssl` (infrastructure) |\n| fuzz_firmware_uefi_diagnostics | `firmware_uefi\u002Fsrc\u002Fservice\u002Fdiagnostics\u002F` | — | `guestmem\u002F` |\n| fuzz_chipset_cmos_rtc | `chipset\u002Fsrc\u002Fcmos_rtc\u002F` | `chipset_device_fuzz\u002F` | `pal_async\u002F`, `vmcore\u002F` |\n| fuzz_scsi_buffers | `scsi_buffers\u002Fsrc\u002F` | — | `guestmem\u002F` |\n| fuzz_chipset_battery | `chipset\u002Fsrc\u002Fbattery\u002F` | `chipset_device_fuzz\u002F` | — |\n\n**Rules:**\n\n1. **Primary scope is the goal.** Line coverage of the target crate is the\n   metric to optimize. The fuzzer exists to find bugs in this code.\n\n2. **Secondary scope matters when it's a trust boundary.** `scsidisk` parsing\n   guest-supplied SCSI commands is a real attack surface — coverage there has\n   value. But `disklayer_ram` just storing bytes is infrastructure.\n\n3. **Out-of-scope code is noise.** `pci_core`, `vmcore`, `guestmem` get\n   exercised incidentally. Don't optimize the fuzzer to improve their coverage\n   — those crates deserve their own fuzzers if coverage matters.\n\n4. **Check the harness before excluding save\u002Frestore or resolver code.** If the\n   harness does not exercise serialization or resource resolution, exclude\n   those paths from its coverage target. Do not assume every harness omits them.\n\n5. **Inspect (`InspectMut`) implementations are low-value.** These debug\u002F\n   diagnostics paths aren't part of the attack surface. Low coverage is\n   acceptable.\n\n## Coverage-guided fuzzer improvement process\n\n### Step 1: Collect and filter\n\n```bash\n# Run coverage\ncargo xtask fuzz coverage \u003Ctarget> --with-html-report\n\n# Open the HTML report for visual inspection\n# target\u002F\u003Ctriple>\u002Fcoverage\u002F\u003Ctriple>\u002Frelease\u002Flcov_html_\u003Ctarget>\u002Findex.html\n```\n\n### Step 2: Identify gaps in primary scope\n\nLook at the HTML report or extract uncovered lines:\n\n```bash\nawk '\u002FSF:.*\u003Ccrate>\\\u002Fsrc\\\u002Flib\\.rs$\u002F,\u002Fend_of_record\u002F' \"$COVERAGE_LCOV\" \\\n  | grep '^DA:' | grep ',0$' | cut -d: -f2 | cut -d, -f1\n```\n\nRead the source at those lines. Classify each uncovered region:\n\n| Classification | Action |\n|---------------|--------|\n| **Reachable via fuzzer input** — the fuzzer *could* reach this code but hasn't found the right input sequence | Investigate why. Is the path gated by specific byte patterns the fuzzer struggles to generate? |\n| **Structurally unreachable** — the fuzzer harness doesn't wire up the code path (e.g., save\u002Frestore, PCI config reads the harness skips) | Extend the harness: add new `FuzzAction` variants, expose more device interfaces to the fuzzer. |\n| **Error-handling \u002F defensive code** — `unreachable!()`, error paths for invalid hardware states | Check guest\u002Froot reachability first. Investigate reachable panics and malformed-input paths; do not dismiss them as low priority. |\n| **Inspect \u002F debug only** — `InspectMut`, `Display`, `Debug` impls | Skip entirely. Not attack surface. |\n\n### Step 3: Improve the fuzzer\n\nImprovements fall into two categories, in priority order:\n\n**A. Extend the fuzz harness**\n\nIf an entire code path is structurally unreachable, the harness needs changes.\nExamples:\n\n- fuzz_ide doesn't exercise PCI config space reads → add PCI config read\u002Fwrite\n  to the `FuzzAction` enum in `chipset_device_fuzz`\n- fuzz_storvsp doesn't test sub-channel operations → add corresponding VMBus\n  channel actions\n\n**B. Improve `Arbitrary` implementations**\n\nIf the fuzzer generates mostly one type of operation, check the `Arbitrary`\nimpl. Common issues:\n\n- Uniform distribution across action types wastes entropy on less interesting\n  paths. Weight toward rarer operations.\n- Overly constrained generation (e.g., only valid SCSI commands) misses\n  malformed-input bugs.\n- Overly unconstrained generation (random bytes everywhere) wastes time on\n  inputs that fail early validation and never reach deep code.\n\n### Step 4: Measure improvement\n\nAfter making changes:\n\n1. Run the fuzzer for the same bounded duration before and after the change\n2. Minimize the corpus: `cargo xtask fuzz cmin \u003Ctarget>`\n3. Collect coverage again\n4. Compare line counts against prior coverage runs\n\nTrack coverage changes over time. Ratchet up: if a change reduces primary\nscope coverage, investigate why.\n\n### Step 5: Iterate\n\nCoverage-guided improvement is iterative. Each cycle:\n\n1. Collect → 2. Identify gaps → 3. Fix → 4. Fuzz → 5. Measure → repeat\n\nTarget **≥85% line coverage** in primary scope as a practical goal. The\nremaining ~15% is typically error-handling code, debug impls, and paths\nrequiring specific hardware\u002Ftiming conditions the fuzzer can't easily produce.\nCoverage percentages are not safety thresholds. Investigate guest\u002Froot-reachable\npanics and malformed-input paths regardless of the percentage.\n",{"name":5,"description":7},"main","ebcd3302222379403963385f25538e35afcd3222",".github\u002Fskills\u002Ffuzzing",277,"https:\u002F\u002Fgithub.com\u002Fmicrosoft\u002Fopenvmm","http:\u002F\u002Fopenvmm.dev\u002F","https:\u002F\u002Fgithub.com\u002Fmicrosoft","https:\u002F\u002Fopensource.microsoft.com","Open source projects and samples from Microsoft","2026-11-15 02:18:15",{"source":8,"skillName":5,"commands":59,"prompt":69,"zipAvailable":70},[60,63,66],{"tool":61,"command":62},"npx","npx skills add microsoft\u002Fopenvmm --skill fuzzing",{"tool":64,"command":65},"bunx","bunx skills add microsoft\u002Fopenvmm --skill fuzzing",{"tool":67,"command":68},"pnpm","pnpm dlx skills add microsoft\u002Fopenvmm --skill fuzzing","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fmicrosoft\u002Fopenvmm\u002Fblob\u002Fmain\u002F.github\u002Fskills\u002Ffuzzing\u002FSKILL.md",true,[],[73,94,114,139],{"skillNo":74,"name":75,"nameZh":6,"description":76,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":77,"categories":78,"keywords":79,"publishedAt":43},"01M69BX123NC683P7MH2Y7B08K","vmm-tests","Run VMM tests locally with cargo xflowey vmm-tests-run. Load when running or debugging VMM tests, or when you need to understand the petri test framework, artifact handling, or cross-compilation for VMM tests.","https:\u002F\u002Fgithub.com\u002Fmicrosoft\u002Fopenvmm\u002Fblob\u002Fmain\u002F.github\u002Fskills\u002Fvmm-tests\u002FSKILL.md",[],[80,81,82,83,40,84,39,85,86,29,87,88,89,90,91,92,93],"vmm","vmm tests","tests","test","test framework","framework","artifact","understand","with","you","load","for","when","running",{"skillNo":95,"name":96,"nameZh":6,"description":97,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":98,"categories":99,"keywords":100,"publishedAt":43},"01M69BWYZCDJJASP457EK9EPWB","update-mu-msvm","Update OpenVMM UEFI firmware to the latest published microsoft\u002Fmu_msvm release. Use when updating mu_msvm, bumping the UEFI dependency, refreshing firmware Nix hashes, or preparing the firmware ingestion pull request.","https:\u002F\u002Fgithub.com\u002Fmicrosoft\u002Fopenvmm\u002Fblob\u002Fmain\u002F.github\u002Fskills\u002Fupdate-mu-msvm\u002FSKILL.md",[],[101,102,103,104,105,106,107,108,109,110,92,111,112,113,9],"update","update mu msvm","pull","UEFI","firmware","use","dependency","ingestion","latest","request","release","pull request","nix",{"skillNo":115,"name":116,"nameZh":6,"description":117,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":118,"categories":119,"keywords":125,"publishedAt":43},"01M69BWX0NY6SCW7H5EMVVC7R1","openvmm-ci-investigation","Investigate CI failures on OpenVMM PRs. Load when a PR has failing CI checks, you need to download and analyze test artifacts, or you need to diagnose build, fmt, clippy, or VMM test failures.","https:\u002F\u002Fgithub.com\u002Fmicrosoft\u002Fopenvmm\u002Fblob\u002Fmain\u002F.github\u002Fskills\u002Fopenvmm-ci-investigation\u002FSKILL.md",[120],{"categoryNo":121,"categoryName":122,"taxonomyType":123,"taxonomyTypeDesc":124},"01JBSEEDCAT000000000000008","测试与质量","SCENARIO","使用场景",[126,127,128,129,130,83,131,132,80,133,134,135,136,137,89,90,138,92],"investigation","ci","openvmm ci investigation","failing","artifacts","diagnose","pr","investigate","download","analyze","build","clippy","prs",{"skillNo":140,"name":141,"nameZh":6,"description":142,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":143,"categories":144,"keywords":145,"publishedAt":43},"01M69BWVDKTXGYTGQ5AGFBB8AQ","guide-maintenance","Maintain the OpenVMM Guide. Load when: (1) adding, removing, or moving Guide pages, (2) adding new device crates or adding or changing CLI interfaces that need doc coverage, or (3) auditing Guide freshness against code changes.","https:\u002F\u002Fgithub.com\u002Fmicrosoft\u002Fopenvmm\u002Fblob\u002Fmain\u002F.github\u002Fskills\u002Fguide-maintenance\u002FSKILL.md",[],[146,147,148,38,149,24,150,151,152,153,90,154,92,155,156],"maintenance","guide","guide maintenance","doc","doc coverage","device","maintain","pages","changes","new","cli"]