How To Issue CXL Commands Using C++/Python

#include <fcntl.h>      // For open()
#include <unistd.h>     // For close()
#include <sys/ioctl.h>  // For ioctl()
#include <iostream>
#include <cstring>

// Define the device path and ioctl interfaces
#define CXL_MEM_DEV_PATH "/dev/cxl/mem0"          // Path to the CXL memory device
#define CXL_QUERY_COMMAND 0xC0506200              // ioctl for querying supported commands
#define CXL_SEND_COMMAND 0xC0506201               // ioctl for sending commands

// Command IDs from CXL specification (replace with actual values)
#define CXL_MEMDEV_IDENTIFY_COMMAND 0x4000          // Command ID for Identify

// Structure for querying commands (defined by CXL open-source driver)
struct cxl_mem_query {
    uint32_t n_commands;         // Number of commands supported
    uint32_t commands[32];       // Array to hold supported command IDs
};

// Structure for sending commands (defined by CXL open-source driver)
struct cxl_mem_command {
    uint32_t id;                 // Command ID to send
    uint32_t flags;              // Command-specific flags
    uint64_t in_payload;         // Pointer to input data (if required)
    uint32_t in_size;            // Size of input data
    uint64_t out_payload;        // Pointer to output buffer
    uint32_t out_size;           // Size of output buffer
};

// Structure for receiving Identify data (defined by CXL specification)
struct cxl_memdev_identify {
    uint64_t fw_revision[2];
    uint64_t total_capacity;
    uint64_t volatile_only_capacity;
    uint64_t persistent_only_capacity;
    uint64_t partition_alignment;
    // Add other fields as defined in the CXL specification
};

int main() {
    // Open the CXL memory device
    int cxl_fd = open(CXL_MEM_DEV_PATH, O_RDWR);
    if (cxl_fd < 0) {
        std::cerr << "Error: Unable to open CXL device handle." << std::endl;
        return -1;
    }

    // Step 1: Query Supported Commands
    cxl_mem_query query = {0};  // Initialize the structure to zero
    query.n_commands = 32;      // Assume we want to query up to 32 commands

    // Query the device for supported commands
    if (ioctl(cxl_fd, CXL_QUERY_COMMAND, &query) < 0) {
        std::cerr << "Error: Failed to query supported commands." << std::endl;
        close(cxl_fd);
        return -1;
    }

    std::cout << "Supported commands queried successfully. Number of commands: " << query.n_commands << std::endl;

    // Check if the Identify command is supported
    bool identify_supported = false;
    for (uint32_t i = 0; i < query.n_commands; i++) {
        if (query.commands[i] == CXL_MEMDEV_IDENTIFY_COMMAND) {
            identify_supported = true;
            break;
        }
    }

    if (!identify_supported) {
        std::cerr << "Identify command is not supported." << std::endl;
        close(cxl_fd);
        return -1;
    }

    std::cout << "Identify command is supported." << std::endl;

    // Step 2: Send Identify Command
    cxl_mem_command identify_cmd;
    memset(&identify_cmd, 0, sizeof(identify_cmd));  // Zero out the structure
    cxl_memdev_identify identify_data;

    identify_cmd.id = CXL_MEMDEV_IDENTIFY_COMMAND;  // Set the command ID
    identify_cmd.out_payload = (uint64_t)&identify_data;  // Output buffer to receive data
    identify_cmd.out_size = sizeof(identify_data);  // Size of the output buffer

    // Send the Identify command
    if (ioctl(cxl_fd, CXL_SEND_COMMAND, &identify_cmd) < 0) {
        std::cerr << "Error: Failed to send 'Memory Device Identify' command." << std::endl;
    } else {
        std::cout << "Memory Device Identify command sent successfully!" << std::endl;
        std::cout << "total_capacity: " << identify_data.total_capacity << std::endl;
        std::cout << "volatile_only_capacity: " << identify_data.volatile_only_capacity << std::endl;
        // Print other fields from identify_data as needed
    }

    // Close the CXL device handle
    close(cxl_fd);
    return 0;
}

import os
import fcntl
import struct  # For packing/unpacking binary data

# Define constants
CXL_MEM_DEV_PATH = "/dev/cxl/mem0"      # Replace with your actual device path
CXL_QUERY_COMMAND = 0xC0506200          # ioctl for querying supported commands
CXL_SEND_COMMAND = 0xC0506201           # ioctl for sending commands
CXL_MEMDEV_IDENTIFY_COMMAND = 0x4000      # Command ID for Identify

# Open the CXL memory device
cxl_fd = os.open(CXL_MEM_DEV_PATH, os.O_RDWR)

try:
    # Step 1: Query Supported Commands
    query_buf = struct.pack("I32I", 32, *([0] * 32))  # Prepare the buffer to hold the query result

    # Perform ioctl call to query supported commands
    query_result = fcntl.ioctl(cxl_fd, CXL_QUERY_COMMAND, query_buf)
    n_commands, *commands = struct.unpack("I32I", query_result)
    print(f"Supported commands queried successfully. Number of commands: {n_commands}")

    # Check if the Identify command is supported
    if CXL_MEMDEV_IDENTIFY_COMMAND not in commands[:n_commands]:
        print("Identify command is not supported.")
    else:
        print("Identify command is supported.")

        # Step 2: Send Identify Command
        identify_data = bytearray(256)  # Adjust size based on the actual structure

        # Prepare command struct for the ioctl call
        send_cmd = struct.pack("IIQIQ", CXL_MEMDEV_IDENTIFY_COMMAND, 0, 0, identify_data, len(identify_data))

        # Send the identify command using ioctl
        fcntl.ioctl(cxl_fd, CXL_SEND_COMMAND, send_cmd)

        # Unpack the response (replace format with actual structure from the CXL specification)
        total_capacity, volatile_only_capacity, persistent_only_capacity, partition_alignment = struct.unpack("I I 16s Q", identify_data[:32])
        print(f"total_capacity: {total_capacity}")
        print(f"volatile_only_capacity: {volatile_only_capacity}")
        #add more prints according to CXL Specification

finally:
    # Close the CXL device handle
    os.close(cxl_fd)