ndctl

https://pmem.io/ndctl/
Admin
ndctl is a utility for managing the Linux kernel libnvdimm subsystem and non-volatile memory...
Tokens:55,910
Snippets:598
Trust Score:9.9
Update:1 month ago
Show doc for...
Tokens:
Raw
### cxl-update-firmware example

Source: https://pmem.io/ndctl/cxl/cxl-update-firmware

An example of updating firmware on mem0 with a specified file and waiting for completion, followed by the command output.

```bash
# cxl update-firmware mem0 -F firmware.bin -w
[
  {
    "memdev":"mem0",
    "pmem_size":1073741824,
    "ram_size":1073741824,
    "serial":0,
    "numa_node":0,
    "host":"cxl_mem.0",
    "firmware":{
      "num_slots":3,
      "active_slot":2,
      "online_activate_capable":false,
      "slot_1_version":"cxl_test_fw_001",
      "slot_2_version":"cxl_test_fw_002",
      "slot_3_version":"cxl_test_new_fw",
      "fw_update_in_progress":false
    }
  }
]
firmware update completed on 1 mem device
```

--------------------------------

### Start cxl-monitor daemon as a system service

Source: https://pmem.io/ndctl/cxl/cxl-monitor

Starts the cxl-monitor daemon as a system service using systemctl. This requires the cxl-monitor.service unit to be installed.

```bash
systemctl start cxl-monitor.service
```

--------------------------------

### ndctl list -BDF firmware example

Source: https://pmem.io/ndctl/ndctl/ndctl-list

Example output for ndctl list -BDF, which includes bus, dimm, and firmware info. Shows firmware activation state and per-dimm firmware details.

```bash
# ndctl list -BDF
[
  {
    "provider":"nfit_test.0",
    "dev":"ndbus2",
    "scrub_state":"idle",
    "firmware":{
      "activate_method":"suspend",
      "activate_state":"idle"
    },
    "dimms":[
      {
        "dev":"nmem1",
        "id":"cdab-0a-07e0-ffffffff",
        "handle":0,
        "phys_id":0,
        "security":"disabled",
        "firmware":{
          "current_version":0,
          "can_update":true
        }
      },
...
]
```

--------------------------------

### daxctl reconfigure-device configuration file example

Source: https://pmem.io/ndctl/daxctl/daxctl-reconfigure-device

Example configuration for managing three devdax namespaces with different modes and options. The subsection name is arbitrary and used only to identify the config section.

```ini
[reconfigure-device dax0]
nvdimm.uuid = ed93e918-e165-49d8-921d-383d7b9660c5
mode = devdax

[reconfigure-device dax1]
nvdimm.uuid = f36d02ff-1d9f-4fb9-a5b9-8ceb10a00fe3
mode = system-ram

[reconfigure-device dax2]
nvdimm.uuid = f36d02ff-1d9f-4fb9-a5b9-8ceb10a00fe3
mode = system-ram
online = true
movable = false
```

--------------------------------

### ndctl list dimm info example

Source: https://pmem.io/ndctl/ndctl/ndctl-list

Example output for dimm info when using the --dimms option. Shows device name, id, handle, physical id, and security state.

```json
{
  "dev":"nmem0",
  "id":"cdab-0a-07e0-ffffffff",
  "handle":0,
  "phys_id":0,
  "security:":"disabled"
}
```

--------------------------------

### List regions and devices

Source: https://pmem.io/ndctl/daxctl/daxctl-list

Example output when listing both regions and devices.

```bash
# daxctl list --regions --devices

{
  "id":1,
  "devices":[
    {
      "chardev":"dax1.0",
      "size":3233808384
    }
  ]
}
```

--------------------------------

### ndctl list --device-dax example

Source: https://pmem.io/ndctl/ndctl/ndctl-list

Example output for device-dax details when using the --device-dax option. Shows daxregion info including alignment and character devices.

```json
{
  "dev":"namespace0.0",
  "mode":"devdax",
  "size":4225761280,
  "uuid":"18ae1bbb-bb62-4efc-86df-4a5caacb5dcc",
  "daxregion":{
    "id":0,
    "size":4225761280,
    "align":2097152,
    "devices":[
      {
        "chardev":"dax0.0",
        "size":4225761280
      }
    ]
  }
}
```

--------------------------------

### cxl disable-region example disabling all regions

Source: https://pmem.io/ndctl/cxl/cxl-disable-region

Example command to disable all regions, with the expected output showing that 2 regions were disabled.

```bash
# cxl disable-region all
disabled 2 regions

```

--------------------------------

### ndctl list --buses --namespaces example

Source: https://pmem.io/ndctl/ndctl/ndctl-list

Example output from running ndctl list --buses --namespaces. Shows JSON objects for each bus with their namespaces, including mode, size, and block device.

```bash
# ndctl list --buses --namespaces

{
  "provider":"nfit_test.1",
  "dev":"ndbus2",
  "namespaces":[
    {
      "dev":"namespace9.0",
      "mode":"raw",
      "size":33554432,
      "blockdev":"pmem9"
    }
  ]
}
{
  "provider":"nfit_test.0",
  "dev":"ndbus1"
}
{
  "provider":"e820",
  "dev":"ndbus0",
  "namespaces":[
    {
      "dev":"namespace0.0",
      "mode":"fsdax",
      "size":8589934592,
      "blockdev":"pmem0"
    }
  ]
}
```

--------------------------------

### cxl destroy-region all example

Source: https://pmem.io/ndctl/cxl/cxl-destroy-region

Example of destroying all regions. The output confirms that two regions were destroyed.

```bash
# cxl destroy-region all
destroyed 2 regions

```

--------------------------------

### Freeze security workflow example

Source: https://pmem.io/ndctl/ndctl/ndctl-freeze-security

This sequence demonstrates checking the initial security state of a DIMM, applying the freeze-security command, and verifying the updated security status.

```bash
$ ndctl list -d nmem0
[
  {
    "dev":"nmem0",
    "id":"cdab-0a-07e0-ffffffff",
    "handle":0,
    "phys_id":0,
    "security":"unlocked"
  }
]

$ ndctl freeze-security  nmem0
security froze 1 nmem.

$ ndctl list -d nmem0
[
  {
    "dev":"nmem0",
    "id":"cdab-0a-07e0-ffffffff",
    "handle":0,
    "phys_id":0,
    "security":"unlocked",
    "security_frozen":true
  },
]
```

--------------------------------

### Online memory for a device

Source: https://pmem.io/ndctl/daxctl/daxctl-online-memory

Example of onlining the memory for a specific device.

```bash
# daxctl online-memory dax0.0
dax0.0: 62 new sections onlined
onlined memory for 1 device
```

--------------------------------

### cxl create-region example with JSON output

Source: https://pmem.io/ndctl/cxl/cxl-create-region

Example command that creates a region with two memdevs (mem0, mem1) using decoder0.1, 2 interleave ways, and 1024 granularity. The output shows the created region object in JSON format and a confirmation message.

```bash
#cxl create-region -m -d decoder0.1 -w 2 -g 1024 mem0 mem1
```

```json
{
  "region":"region0",
  "resource":"0xc90000000",
  "size":"512.00 MiB (536.87 MB)",
  "interleave_ways":2,
  "interleave_granularity":1024,
  "mappings":[
    {
      "position":1,
      "decoder":"decoder4.0"
    },
    {
      "position":0,
      "decoder":"decoder3.0"
    }
  ]
}
created 1 region
```

--------------------------------

### ndctl list --health example

Source: https://pmem.io/ndctl/ndctl/ndctl-list

Example output for dimm health info when using the --health option. Shows health state, temperature, spares, thresholds, and shutdown state.

```json
{
  "dev":"nmem0",
  "health":{
    "health_state":"non-critical",
    "temperature_celsius":23,
    "spares_percentage":75,
    "alarm_temperature":true,
    "alarm_spares":true,
    "temperature_threshold":40,
    "spares_threshold":5,
    "life_used_percentage":5,
    "shutdown_state":"clean"
  }
}
```

--------------------------------

### cxl list -TP output and cxl inject-protocol-error example

Source: https://pmem.io/ndctl/cxl/cxl-inject-protocol-error

Example showing the output of 'cxl list -TP' to identify a dport with 'protocol_injectable' set to true, followed by an injection command using that dport. The command injects a mem-correctable protocol error.

```json
# cxl list -TP
 [
  {
    "port":"port1",
    "host":"pci0000:e0",
    "depth":1,
    "decoders_committed":1,
    "nr_dports":1,
    "dports":[
      {
        "dport":"0000:e0:01.1",
        "alias":"device:02",
        "id":0,
        "protocol_injectable":true
      }
    ]
  }
]

```

```bash
# cxl inject-protocol-error "0000:e0:01.1" -p mem -s correctable
cxl inject-protocol-error: inject_proto_err: injected mem-correctable protocol error.

```

--------------------------------

### Online memory with existing online sections

Source: https://pmem.io/ndctl/daxctl/daxctl-online-memory

Example of onlining memory when some sections are already in an online state.

```bash
# daxctl online-memory dax0.0
dax0.0: 1 section already online
dax0.0: 61 new sections onlined
onlined memory for 1 device
```

--------------------------------

### Reconfigure dax0.0 to system-ram mode

Source: https://pmem.io/ndctl/daxctl/daxctl-offline-memory

Example of reconfiguring a device to system-ram mode before offlining memory.

```bash
# daxctl reconfigure-device --mode=system-ram --human dax0.0
{
  "chardev":"dax0.0",
  "size":"7.87 GiB (8.45 GB)",
  "target_node":2,
  "mode":"system-ram"
}
```

--------------------------------

### Run cxl-monitor as a daemon with log file

Source: https://pmem.io/ndctl/cxl/cxl-monitor

Starts cxl-monitor as a daemon, sending log messages to /var/log/cxl-monitor.log. The --daemon option requires an absolute path for the log file.

```bash
cxl monitor --daemon --log=/var/log/cxl-monitor.log
```

--------------------------------

### Destroy all devices in a region

Source: https://pmem.io/ndctl/daxctl/daxctl-destroy-device

Example showing how to disable and destroy all devices within a specific region ID.

```bash
# daxctl disable-device -r 0 all
disabled 3 devices
# daxctl destroy-device -r 0 all
destroyed 2 devices
```

--------------------------------

### Arm device for firmware activation with --arm

Source: https://pmem.io/ndctl/ndctl/ndctl-update-firmware

Example of arming a device for firmware activation with --arm. Shows the error message when the arm is aborted due to overflow, and the subsequent list of devices that were updated.

```shell
ndctl update-firmware --arm --bus=nfit_test.0 all
  Error: update firmware: nmem4: arm aborted, tripped overflow
[
  {
    "dev":"nmem1",
    "id":"cdab-0a-07e0-ffffffff",
    "handle":"0",
    "phys_id":"0",
    "security":"disabled",
    "firmware":{
      "current_version":"0",
      "can_update":true
    }
  },
  {
    "dev":"nmem3",
    "id":"cdab-0a-07e0-fffeffff",
    "handle":"0x100",
    "phys_id":"0x2",
    "security":"disabled",
    "firmware":{
      "current_version":"0",
      "can_update":true
    }
  },
  {
    "dev":"nmem2",
    "id":"cdab-0a-07e0-feffffff",
    "handle":"0x1",
    "phys_id":"0x1",
    "security":"disabled",
    "firmware":{
      "current_version":"0",
      "can_update":true
    }
  }
]
updated 3 nmems.

```

--------------------------------

### Destroy a specific dax device

Source: https://pmem.io/ndctl/daxctl/daxctl-destroy-device

Example showing the sequence of disabling and then destroying a specific dax device.

```bash
# daxctl disable-device dax0.1
disabled 1 device
# daxctl destroy-device dax0.1
destroyed 1 device
```

--------------------------------

### Reconfigure device to system-ram mode

Source: https://pmem.io/ndctl/daxctl/daxctl-online-memory

Example of reconfiguring a device to system-ram mode without immediately onlining the memory.

```bash
# daxctl reconfigure-device --mode=system-ram --no-online --human dax0.0
{
  "chardev":"dax0.0",
  "size":"7.87 GiB (8.45 GB)",
  "target_node":2,
  "mode":"system-ram"
}
```

--------------------------------

### cxl list -m mem0 -I output

Source: https://pmem.io/ndctl/cxl/cxl-list

Example output of the cxl list command with the -I option, showing memdev information including ram_size and partition_info.

```json
# cxl list -m mem0 -I
[
  {
    "memdev":"mem0",
    "ram_size":273535729664,
    "partition_info":{
      "total_size":273535729664,
      "volatile_only_size":0,
      "persistent_only_size":0,
      "partition_alignment_size":268435456
      "active_volatile_size":273535729664,
      "active_persistent_size":0,
      "next_volatile_size":0,
      "next_persistent_size":0,
    }
  }
]
```

--------------------------------

### daxctl config file [reconfigure-device] section

Source: https://pmem.io/ndctl/daxctl/daxctl-reconfigure-device

Example configuration file section for persistent reconfiguration of dax devices. The section name must be unique, and the keys set the NVDIMM namespace UUID, the desired mode (default system-ram), whether to online the memory (default true), and whether to use movable memory (default true).

```ini
[reconfigure-device <unique_subsection_name>]
nvdimm.uuid = <NVDIMM namespace uuid>
mode = <desired reconfiguration mode> (default: system-ram)
online = <true|false> (default: true)
movable = <true|false> (default: true)
```

--------------------------------

### Verbose region listing with ndctl list

Source: https://pmem.io/ndctl/ndctl/ndctl-list

Example of running ndctl list with high verbosity (-vvv) and region filtering to display capabilities.

```bash
# ndctl list -Ru -vvv -r 0
{
  "dev":"region0",
  "size":"4.00 GiB (4.29 GB)",
  "available_size":0,
  "max_available_extent":0,
  "type":"pmem",
  "numa_node":0,
  "target_node":2,
  "capabilities":[
    {
      "mode":"sector",
      "sector_sizes":[
        512,
        520,
        528,
        4096,
        4104,
        4160,
        4224
      ]
    },
    {
      "mode":"fsdax",
      "alignments":[
        4096,
        2097152,
        1073741824
      ]
    },
    {
      "mode":"devdax",
      "alignments":[
        4096,
        2097152,
        1073741824
      ]
    }
  ],
  "persistence_domain":"unknown"
}
```

--------------------------------

### cxl list output showing media errors

Source: https://pmem.io/ndctl/cxl/cxl-clear-media-poison

Example output from cxl list showing a device with injected poison at offset 0x1000. Use this to identify poison that can be cleared.

```bash
# cxl list -m mem0 -L -u
{
  "memdev":"mem0",
  "ram_size":"1024.00 MiB (1073.74 MB)",
  "ram_qos_class":42,
  "serial":"0x0",
  "numa_node:1,
  "host":"0000:35:00.0",
  "media_errors":[
    {
      "offset":"0x1000",
      "length":64,
      "source":"Injected"
    }
  ]
}

```

--------------------------------

### View bus armed state with ndctl list -BF

Source: https://pmem.io/ndctl/ndctl/ndctl-update-firmware

Example of viewing the 'armed' state of the bus using ndctl list -BF. The output shows the firmware activation state, including activate_method and activate_state.

```json
ndctl list -BF -b nfit_test.0
[
  {
    "provider":"nfit_test.0",
    "dev":"ndbus2",
    "scrub_state":"idle",
    "firmware":{
      "activate_method":"suspend",
      "activate_state":"overflow"
    }
  }
]

```

--------------------------------

### Disable namespace and read info-block as JSON

Source: https://pmem.io/ndctl/ndctl/ndctl-read-infoblock

Example workflow: first disable the namespace (required before accessing the info-block), then read the info-block with -j to output JSON. The output shows the parsed info-block fields.

```bash
ndctl disable-namespace namespace0.0
disabled 1 namespace
ndctl read-infoblock -j namespace0.0
[
  {
    "dev":"namespace0.0",
    "signature":"NVDIMM_PFN_INFO",
    "uuid":"56b11990-66b1-4d91-9cac-ca084c051259",
    "parent_uuid":"00000000-0000-0000-0000-000000000000",
    "flags":0,
    "version":"1.3",
    "dataoff":69206016,
    "npfns":1031680,
    "mode":2,
    "start_pad":0,
    "end_trunc":0,
    "align":2097152
  }
]
```

--------------------------------

### Equivalent commands for listing switch ports

Source: https://pmem.io/ndctl/cxl/cxl-list

Demonstrates equivalent commands for listing switch ports by default.

```bash
# cxl list -P
# cxl list -P -p switch
```

--------------------------------

### Create devices with full available size

Source: https://pmem.io/ndctl/daxctl/daxctl-create-device

Creates devices with the fully available size on all regions.

```bash
# daxctl create-device -u
[
  {
    "chardev":"dax0.1",
    "size":"15.63 GiB (16.78 GB)",
    "target_node":0,
    "mode":"devdax"
  },
  {
    "chardev":"dax1.1",
    "size":"15.63 GiB (16.78 GB)",
    "target_node":1,
    "mode":"devdax"
  }
]
```

--------------------------------

### Equivalent commands for listing endpoints

Source: https://pmem.io/ndctl/cxl/cxl-list

Demonstrates equivalent commands for listing endpoint objects.

```bash
# cxl list -E
# cxl list -P -p endpoint
```

--------------------------------

### Activate firmware synopsis

Source: https://pmem.io/ndctl/ndctl/ndctl-activate-firmware

The basic command structure for activating firmware on specified buses.

```bash
ndctl activate-firmware [<bus-id> <bus-id2> … <bus-idN>] [<options>]
```

--------------------------------

### Offline the memory

Source: https://pmem.io/ndctl/daxctl/daxctl-offline-memory

Example command to offline the memory for a specific dax device.

```bash
# daxctl offline-memory dax0.0
dax0.0: 62 sections offlined
offlined memory for 1 device
```

--------------------------------

### Filter by device

Source: https://pmem.io/ndctl/daxctl/daxctl-list

Example of filtering the listing to a specific device instance in a region.

```bash
# daxctl list --dev=1.0

{
  "chardev":"dax1.0",
  "size":3233808384
}
```

--------------------------------

### Disable a specific dax device

Source: https://pmem.io/ndctl/daxctl/daxctl-disable-device

Example command to disable the dax0.1 device.

```bash
# daxctl disable-device dax0.1
```

--------------------------------

### Equivalent commands for listing root ports

Source: https://pmem.io/ndctl/cxl/cxl-list

Demonstrates equivalent commands for listing root ports using the -B flag versus the -P -p root -S flags.

```bash
# cxl list -B
# cxl list -P -p root -S
```

--------------------------------

### ndctl setup-passphrase command syntax

Source: https://pmem.io/ndctl/ndctl/ndctl-setup-passphrase

The basic command structure for setting up a passphrase on one or more NVDIMMs.

```bash
ndctl setup-passphrase <nmem0> [<nmem1>..<nmemN>] -k <key_handle> [<options>]
```

--------------------------------

### cxl list command synopsis

Source: https://pmem.io/ndctl/cxl/cxl-list

Shows the basic usage of the cxl list command with its options placeholder.

```bash
cxl list [<options>]

```

--------------------------------

### List bus firmware activation method

Source: https://pmem.io/ndctl/ndctl/ndctl-activate-firmware

Enumerates the default activation method for a specific bus using the ndctl list command.

```bash
# ndctl list -b nfit_test.0 -BF
[
  {
    "provider":"nfit_test.0",
    "dev":"ndbus2",
    "scrub_state":"idle",
    "firmware":{
      "activate_method":"suspend",
      "activate_state":"idle"
    }
  }
]
```

--------------------------------

### Monitoring as a system service

Source: https://pmem.io/ndctl/ndctl/ndctl-monitor

Start the ndctl-monitor system service, which runs the monitor daemon as a system service.

```bash
systemctl start ndctl-monitor.service
```

--------------------------------

### ndctl enable-dimm command syntax

Source: https://pmem.io/ndctl/ndctl/ndctl-enable-dimm

Shows the basic command syntax for enabling one or more DIMMs. The <dimm> argument can be a nmemX device name or a dimm id number, and the keyword 'all' can be used to indicate no restriction.

```bash
ndctl enable-dimm <dimm> [<options>]

```

--------------------------------

### Disable all devices in a region

Source: https://pmem.io/ndctl/daxctl/daxctl-disable-device

Example command to disable all devices within region 0, including the command output.

```bash
# daxctl disable-device -r 0 all
disabled 3 devices
```

--------------------------------

### Start scrub on a specific bus

Source: https://pmem.io/ndctl/ndctl/ndctl-start-scrub

Attempts to initiate an ARS operation on a specific bus, reporting an error if the operation is not supported.

```bash
# ndctl start-scrub e820
error starting scrub: Operation not supported
```

--------------------------------

### List all devices

Source: https://pmem.io/ndctl/daxctl/daxctl-list

The default behavior of daxctl list when no options are provided.

```bash
daxctl list --devices
```

--------------------------------

### cxl create-region command syntax

Source: https://pmem.io/ndctl/cxl/cxl-create-region

Shows the basic command syntax for cxl create-region. The command takes options and targets.

```bash
cxl create-region [<options>]
```

--------------------------------

### Example JSON output for media errors

Source: https://pmem.io/ndctl/ndctl/ndctl-list

This JSON output demonstrates the structure of media error information when using the --media-errors flag.

```json
{
  "dev":"namespace7.0",
  "mode":"raw",
  "size":33554432,
  "blockdev":"pmem7",
  "badblock_count":17,
  "badblocks":[
    {
      "offset":4,
      "length":1
    },
    {
      "offset":32768,
      "length":8
    },
    {
      "offset":65528,
      "length":8
    }
  ]
}
```

--------------------------------

### Start scrub on all buses

Source: https://pmem.io/ndctl/ndctl/ndctl-start-scrub

Initiates an ARS operation across all supported nvdimm buses in the system, returning a JSON report of the active scrub states.

```bash
# ndctl start-scrub
[
  {
    "provider":"nfit_test.1",
    "dev":"ndbus3",
    "scrub_state":"active"
  },
  {
    "provider":"nfit_test.0",
    "dev":"ndbus2",
    "scrub_state":"active"
  }
]
```

--------------------------------

### cxl list -m mem0 -A output

Source: https://pmem.io/ndctl/cxl/cxl-list

Example output of the cxl list command with the -A option, showing alert configuration fields for the memdev.

```json
# cxl list -m mem0 -A
[
  {
    "memdev":"mem0",
    "pmem_size":0,
    "ram_size":273535729664,
    "alert_config":{
      "life_used_prog_warn_threshold_valid":false,
      "dev_over_temperature_prog_warn_threshold_valid":false,
      "dev_under_temperature_prog_warn_threshold_valid":false,
      "corrected_volatile_mem_err_prog_warn_threshold_valid":true,
      "corrected_pmem_err_prog_warn_threshold_valid":false,
      "life_used_prog_warn_threshold_writable":false,
      "dev_over_temperature_prog_warn_threshold_writable":false,
      "dev_under_temperature_prog_warn_threshold_writable":false,
      "corrected_volatile_mem_err_prog_warn_threshold_writable":true,
      "corrected_pmem_err_prog_warn_threshold_writable":false,
      "life_used_crit_alert_threshold":0,
      "life_used_prog_warn_threshold":0,
      "dev_over_temperature_crit_alert_threshold":0,
      "dev_under_temperature_crit_alert_threshold":0,
      "dev_over_temperature_prog_warn_threshold":0,
      "dev_under_temperature_prog_warn_threshold":0,
      "corrected_volatile_mem_err_prog_warn_threshold":0,
      "corrected_pmem_err_prog_warn_threshold":0
    },
  }
]
```

--------------------------------

### Enable all regions with cxl enable-region

Source: https://pmem.io/ndctl/cxl/cxl-enable-region

Shows the command and output when enabling all CXL regions.

```bash
# cxl enable-region all
enabled 2 regions
```

--------------------------------

### cxl-update-firmware --wait behavior

Source: https://pmem.io/ndctl/cxl/cxl-update-firmware

Explanation of the --wait option when used without a firmware file.

```text
If --wait is passed in without an accompanying firmware-file,
it will initiate a wait on any current in-progress firmware
updates, and then return.
```

--------------------------------

### Wait for sanitize operation on a CXL memory device

Source: https://pmem.io/ndctl/cxl/cxl-wait-sanitize

Example of using the cxl wait-sanitize command to wait for a sanitize operation to complete on mem0, followed by the command output.

```bash
# cxl wait-sanitize mem0
sanitize completed on 1 mem device
```

--------------------------------

### Run a process with numactl on a reconfigured device

Source: https://pmem.io/ndctl/daxctl/daxctl-reconfigure-device

Reconfigures dax0.0 to system-ram and then runs a service restricted to specific CPU and memory nodes.

```bash
# daxctl reconfigure-device --mode=system-ram dax0.0
[
  {
    "chardev":"dax0.0",
    "size":16777216000,
    "target_node":2,
    "mode":"system-ram"
  }
]

# numactl --cpunodebind=0-1 --membind=2 -- some-service --opt1 --opt2
```

--------------------------------

### cxl list -B output showing injectable_protocol_errors

Source: https://pmem.io/ndctl/cxl/cxl-inject-protocol-error

Example output of 'cxl list -B' showing the 'injectable_protocol_errors' attribute under a CXL bus object. This attribute lists the available error types for injection.

```json
# cxl list -B
[
  {
    "bus":"root0",
    "provider":"ACPI.CXL",
    "injectable_protocol_errors":[
      "mem-correctable",
      "mem-fatal",
    ]
  }
]

```
Tokens:
Raw