Oracle 数据分析加速器 (DAX)¶

DAX 是一个协处理器，它位于 SPARC M7 (DAX1) 和 M8 (DAX2) 处理器芯片上，可以直接访问 CPU 的 L3 缓存以及物理内存。它可以对具有各种输入和输出格式的数据流执行多种操作。驱动程序提供传输机制，并且对各种操作码和数据格式的了解有限。用户空间库提供高级服务，并将这些服务转换为底层命令，然后传递到驱动程序，随后传递到 Hypervisor 和协处理器。建议应用程序使用该库来使用协处理器，驱动程序接口不适合通用用途。本文档描述了驱动程序的一般流程、其结构及其编程接口。它还提供了足够的示例代码，用于编写使用 DAX 功能的用户或内核应用程序。

用户库是开源的，可在以下位置获得：

https://oss.oracle.com/git/gitweb.cgi?p=libdax.git

协处理器的 Hypervisor 接口在随附的文档 dax-hv-api.txt 中详细描述，该文档是（Oracle 内部）“UltraSPARC 虚拟机规范”版本 3.0.20+15 的纯文本摘录，日期为 2017-09-25。

高级概述¶

协处理器请求由命令控制块 (CCB) 描述。CCB 包含操作码和各种参数。操作码指定要执行的操作，参数指定选项、标志、大小和地址。CCB（或 CCB 数组）被传递给 Hypervisor，Hypervisor 处理可用协处理器执行单元的请求的排队和调度。返回的状态代码指示请求是否已成功提交，或者是否存在错误。每个 CCB 中给出的地址之一是指向“完成区域”的指针，该完成区域是一个 128 字节的内存块，协处理器会写入该内存块以提供执行状态。完成时不会生成中断；必须由软件轮询完成区域以查找事务何时完成，但 M7 及更高版本的处理器提供了一种机制，可以暂停虚拟处理器，直到协处理器更新完成状态。这是使用受监视的加载和 mwait 指令完成的，稍后将详细描述。DAX 协处理器被设计为在提交请求后，内核不再参与其处理。轮询在用户级别完成，这使得请求完成与请求线程恢复执行之间的延迟几乎为零。

寻址内存¶

由于存在额外的内存虚拟化级别，内核无法访问 Sun4v 架构中的物理内存。此中间级别称为“实际”内存，内核将其视为物理内存。Hypervisor 处理实际内存和物理内存之间的转换，以便每个逻辑域 (LDOM) 都可以拥有一个与其它 LDOM 隔离的物理内存分区。当内核设置虚拟映射时，它会指定一个虚拟地址以及应该映射到的实际地址。

DAX 协处理器只能在物理内存上运行，因此在将请求馈送到协处理器之前，CCB 中的所有地址都必须转换为物理地址。内核无法执行此操作，因为它无法查看物理地址。因此，CCB 可以包含缓冲区的虚拟地址或实际地址，也可以包含它们的组合。对于 CCB 中可能给出的每个地址，都有一个“地址类型”字段。在所有情况下，Hypervisor 都会在调度到硬件之前将所有地址转换为物理地址。地址转换是使用发起请求的进程的上下文执行的。

驱动程序 API¶

应用程序通过 write() 系统调用向驱动程序发出请求，并通过 read() 获取结果（如果有）。完成区域可以通过 mmap() 访问，并且对于应用程序是只读的。

该请求可以是立即命令，也可以是要提交给硬件的 CCB 数组。

设备的每个打开实例都专属于打开它的线程，并且必须由该线程用于所有后续操作。驱动程序打开函数会为线程创建一个新上下文并将其初始化以供使用。此上下文包含驱动程序内部使用的指针和值，用于跟踪提交的请求。还会分配完成区域缓冲区，该缓冲区足够大，可以容纳许多并发请求的完成区域。当设备关闭时，所有未完成的事务都将被刷新，并且上下文将被清除。

在 DAX1 系统 (M7) 上，设备将被称为“oradax1”，而在 DAX2 系统 (M8) 上，它将被称为“oradax2”。如果应用程序需要其中一个，则应尝试打开相应的设备。任何给定系统上都只存在其中一个设备，因此可以使用名称来确定平台支持的内容。

立即命令为 CCB_DEQUEUE、CCB_KILL 和 CCB_INFO。对于所有这些命令，write() 的返回值等于调用中给出的字节数，表示成功。否则，返回 -1 并设置 errno。

CCB_DEQUEUE¶

告诉驱动程序清除与过去请求相关的资源。由于在请求完成时不会生成中断，因此必须告知驱动程序何时可以回收资源。不会返回进一步的状态信息，因此用户不应随后调用 read()。

CCB_KILL¶

在执行期间终止 CCB。保证 CCB 在此调用成功返回后不会继续执行。成功后，必须调用 read() 以检索操作结果。

CCB_INFO¶

检索有关当前正在执行的 CCB 的信息。请注意，当 CCB 处于“inprogress”状态时，某些 Hypervisor 可能会返回“notfound”。为确保处于“notfound”状态的 CCB 永远不会执行，必须对该 CCB 调用 CCB_KILL。成功后，必须调用 read() 以检索操作的详细信息。

提交要执行的 CCB 数组¶

长度为 CCB 大小的倍数的 write() 被视为提交操作。文件偏移量被视为要使用的完成区域的索引，可以通过 lseek() 或使用 pwrite() 系统调用进行设置。如果返回 -1，则设置 errno 以指示错误。否则，返回值是协处理器实际接受的数组的长度。如果接受的长度等于请求的长度，则提交完全成功，并且无需进一步的状态；因此，用户不应随后调用 read()。返回的值小于请求的长度表示部分接受 CCB 数组，必须调用 read() 以检索进一步的状态信息。状态将反映由第一个未被接受的 CCB 引起的错误，并且 status_data 在某些情况下将提供其他数据。

MMAP¶

mmap() 函数提供对驱动程序中分配的完成区域的访问。请注意，完成区域对于用户进程是不可写的，并且 mmap 调用不得指定 PROT_WRITE。

请求完成¶

每个完成区域中的第一个字节是由协处理器硬件更新的命令状态。软件可以利用新的 M7/M8 处理器功能来有效地轮询此状态字节。首先，通过使用 ASI 0x84 (ASI_MONITOR_PRIMARY) 从备用空间加载 (ldxa、lduba 等) 来实现“受监视的加载”。其次，通过 mwait 指令（写入 %asr28）实现“受监视的等待”。此指令类似于暂停，因为它会暂停虚拟处理器执行给定的纳秒数，但此外，当发生多个事件之一时，它会提前终止。如果修改了包含受监视位置的数据块，则 mwait 将终止。这将导致软件在事务完成后立即恢复执行（无需上下文切换或内核到用户的转换）。因此，事务完成和恢复执行之间的延迟可能只有几纳秒。

DAX 提交的应用程序生命周期¶

打开 dax 设备

调用 mmap() 以获取完成区域地址

分配一个 CCB 并填写操作码、标志、参数、地址等。

通过 write() 或 pwrite() 提交 CCB

进入一个循环，执行受监视的加载 + 受监视的等待，并在命令状态指示请求已完成时终止（必要时可以随时使用 CCB_KILL 或 CCB_INFO）

执行 CCB_DEQUEUE

为完成区域调用 munmap()

关闭 dax 设备

内存限制¶

DAX 硬件仅在物理地址上运行。因此，它不了解虚拟内存映射以及虚拟缓冲区映射到的物理内存中可能存在的不连续性。没有 I/O TLB 或任何分散/收集机制。所有缓冲区（无论是输入还是输出）都必须位于内存的物理连续区域中。

Hypervisor 会在将 CCB 移交给 DAX 之前将 CCB 中的所有地址转换为物理地址。Hypervisor 会确定给定的每个虚拟地址的虚拟页面大小，并使用它来为每个地址设置大小限制。这可以防止协处理器读取或写入超出虚拟页面边界的内容，即使它直接访问物理内存也是如此。一种更简单的说法是，DAX 操作永远不会“跨越”虚拟页面边界。如果使用 8k 虚拟页面，则数据严格限制为 8k。如果用户的缓冲区大于 8k，则必须使用更大的页面大小，否则事务大小将被截断为 8k。

巨页。用户可以使用标准接口分配巨页。驻留在巨页上的内存缓冲区可用于实现更大的 DAX 事务大小，但仍必须遵守规则，并且任何事务都不会跨越页面边界，即使是巨页。一个主要的注意事项是，Sparc 上的 Linux 将 8Mb 作为巨页大小之一。 Sparc 实际上并不提供 8Mb 的硬件页面大小，这个大小是通过将两个 4Mb 页面粘贴在一起合成的。出现这种情况的原因是历史遗留问题，它会导致一个问题，即在 DAX 请求中，这个 8Mb 页面实际上只能有一半用于任何给定的缓冲区，并且它必须是前半部分或后半部分；它不能是中间的 4Mb 块，因为它跨越了（硬件）页面边界。请注意，这个问题可能被更高级别的库隐藏起来。

CCB 结构¶

CCB 是一个由 8 个 64 位字组成的数组。其中一些字提供命令操作码、参数、标志等，其余的则是完成区域、输出缓冲区和各种输入的地址。

struct ccb {
    u64   control;
    u64   completion;
    u64   input0;
    u64   access;
    u64   input1;
    u64   op_data;
    u64   output;
    u64   table;
};

有关每个字段的详细说明，请参见 libdax/common/sys/dax1/dax1_ccb.h，有关访客操作系统（即 Linux 内核）可用的 Hypervisor API 的完整描述，请参见 dax-hv-api.txt。

驱动程序检查第一个字（控制），以确定以下内容

CCB 版本，必须与硬件版本一致
操作码，必须是文档中允许的命令之一
地址类型，对于用户给出的所有地址，必须设置为“虚拟”，从而确保应用程序只能访问其拥有的内存

示例代码¶

用户代码和内核代码都可以访问 DAX。内核代码可以直接进行超级调用，而用户代码必须使用驱动程序提供的包装器。CCB 的设置对于两者几乎相同；唯一的区别在于完成区域的准备。现在给出一个用户代码的示例，随后给出内核代码。

为了使用驱动程序 API 进行编程，必须包含文件 arch/sparc/include/uapi/asm/oradax.h。

首先，必须打开正确的设备。对于 M7，它将是 /dev/oradax1，对于 M8，它将是 /dev/oradax2。最简单的过程是尝试同时打开这两个设备，因为只有一个会成功

fd = open("/dev/oradax1", O_RDWR);
if (fd < 0)
        fd = open("/dev/oradax2", O_RDWR);
if (fd < 0)
       /* No DAX found */

接下来，必须映射完成区域

completion_area = mmap(NULL, DAX_MMAP_LEN, PROT_READ, MAP_SHARED, fd, 0);

所有输入和输出缓冲区必须完全包含在一个硬件页面中，因为如上所述，DAX 受虚拟页面边界的严格限制。此外，输出缓冲区必须是 64 字节对齐的，并且其大小必须是 64 字节的倍数，因为协处理器以缓存行的单位写入。

此示例演示了 DAX 扫描命令，该命令将向量和匹配值作为输入，并生成位图作为输出。对于输入中每个与该值匹配的元素，输出中的相应位将被置位。

在此示例中，输入向量由一系列单比特组成，匹配值为 0。因此，输入中的每个 0 位将在输出中产生 1，反之亦然，从而产生一个与输入位图反转的输出位图。

有关此 CCB 中使用的所有参数和位的详细信息，请参阅 DAX Hypervisor API 文档的 36.2.1.3 节，其中详细描述了扫描命令

ccb->control =       /* Table 36.1, CCB Header Format */
          (2L << 48)     /* command = Scan Value */
        | (3L << 40)     /* output address type = primary virtual */
        | (3L << 34)     /* primary input address type = primary virtual */
                     /* Section 36.2.1, Query CCB Command Formats */
        | (1 << 28)     /* 36.2.1.1.1 primary input format = fixed width bit packed */
        | (0 << 23)     /* 36.2.1.1.2 primary input element size = 0 (1 bit) */
        | (8 << 10)     /* 36.2.1.1.6 output format = bit vector */
        | (0 <<  5)     /* 36.2.1.3 First scan criteria size = 0 (1 byte) */
        | (31 << 0);    /* 36.2.1.3 Disable second scan criteria */

ccb->completion = 0;    /* Completion area address, to be filled in by driver */

ccb->input0 = (unsigned long) input; /* primary input address */

ccb->access =       /* Section 36.2.1.2, Data Access Control */
          (2 << 24)    /* Primary input length format = bits */
        | (nbits - 1); /* number of bits in primary input stream, minus 1 */

ccb->input1 = 0;       /* secondary input address, unused */

ccb->op_data = 0;      /* scan criteria (value to be matched) */

ccb->output = (unsigned long) output;   /* output address */

ccb->table = 0;        /* table address, unused */

CCB 提交是对驱动程序的 write() 或 pwrite() 系统调用。如果调用失败，则必须使用 read() 来检索状态

if (pwrite(fd, ccb, 64, 0) != 64) {
        struct ccb_exec_result status;
        read(fd, &status, sizeof(status));
        /* bail out */
}

成功提交 CCB 后，可以轮询完成区域以确定 DAX 何时完成。有关完成区域内容的详细信息，请参阅 DAX HV API 文档的 36.2.2 节

while (1) {
        /* Monitored Load */
        __asm__ __volatile__("lduba [%1] 0x84, %0\n"
                             : "=r" (status)
                             : "r"  (completion_area));

        if (status)          /* 0 indicates command in progress */
                break;

        /* MWAIT */
        __asm__ __volatile__("wr %%g0, 1000, %%asr28\n" ::);    /* 1000 ns */
}

完成区域状态为 1 表示 CCB 成功完成并且输出位图有效，可以立即使用。所有其他非零值表示错误情况，这些情况在 36.2.2 节中进行了描述

if (completion_area[0] != 1) {  /* section 36.2.2, 1 = command ran and succeeded */
        /* completion_area[0] contains the completion status */
        /* completion_area[1] contains an error code, see 36.2.2 */
}

处理完完成区域后，必须通知驱动程序它可以释放与请求关联的任何资源。这是通过出队操作完成的

struct dax_command cmd;
cmd.command = CCB_DEQUEUE;
if (write(fd, &cmd, sizeof(cmd)) != sizeof(cmd)) {
        /* bail out */
}

最后，应完成正常的程序清理，例如，取消映射完成区域、关闭 dax 设备、释放内存等。

内核示例¶

在内核代码中使用 DAX 的唯一区别在于完成区域的处理。与用户应用程序 mmap 驱动程序分配的完成区域不同，内核代码必须分配自己的内存用于完成区域，并且此地址及其类型必须在 CCB 中给出

ccb->control |=      /* Table 36.1, CCB Header Format */
        (3L << 32);     /* completion area address type = primary virtual */

ccb->completion = (unsigned long) completion_area;   /* Completion area address */

直接进行 dax 提交超级调用。ccb_submit 调用中使用的标志记录在 DAX HV API 的 36.3.1/ 节中

#include <asm/hypervisor.h>

      hv_rv = sun4v_ccb_submit((unsigned long)ccb, 64,
                               HV_CCB_QUERY_CMD |
                               HV_CCB_ARG0_PRIVILEGED | HV_CCB_ARG0_TYPE_PRIMARY |
                               HV_CCB_VA_PRIVILEGED,
                               0, &bytes_accepted, &status_data);

      if (hv_rv != HV_EOK) {
              /* hv_rv is an error code, status_data contains */
              /* potential additional status, see 36.3.1.1 */
      }

提交后，完成区域轮询代码与用户空间中的代码相同

while (1) {
        /* Monitored Load */
        __asm__ __volatile__("lduba [%1] 0x84, %0\n"
                             : "=r" (status)
                             : "r"  (completion_area));

        if (status)          /* 0 indicates command in progress */
                break;

        /* MWAIT */
        __asm__ __volatile__("wr %%g0, 1000, %%asr28\n" ::);    /* 1000 ns */
}

if (completion_area[0] != 1) {  /* section 36.2.2, 1 = command ran and succeeded */
        /* completion_area[0] contains the completion status */
        /* completion_area[1] contains an error code, see 36.2.2 */
}

完成状态指示成功后，输出位图即可立即使用。

摘自 UltraSPARC 虚拟机规范¶

Excerpt from UltraSPARC Virtual Machine Specification
Compiled from version 3.0.20+15
Publication date 2017-09-25 08:21
Copyright © 2008, 2015 Oracle and/or its affiliates. All rights reserved.
Extracted via "pdftotext -f 547 -l 572 -layout sun4v_20170925.pdf"
Authors:
Charles Kunzman
Sam Glidden
Mark Cianchetti

Chapter 36. Coprocessor services
The following APIs provide access via the Hypervisor to hardware assisted data processing functionality.
These APIs may only be provided by certain platforms, and may not be available to all virtual machines
even on supported platforms. Restrictions on the use of these APIs may be imposed in order to support
live-migration and other system management activities.

36.1. Data Analytics Accelerator
The Data Analytics Accelerator (DAX) functionality is a collection of hardware coprocessors that provide
high speed processoring of database-centric operations. The coprocessors may support one or more of
the following data query operations: search, extraction, compression, decompression, and translation. The
functionality offered may vary by virtual machine implementation.

The DAX is a virtual device to sun4v guests, with supported data operations indicated by the virtual device
compatibility property. Functionality is accessed through the submission of Command Control Blocks
(CCBs) via the ccb_submit API function. The operations are processed asynchronously, with the status
of the submitted operations reported through a Completion Area linked to each CCB. Each CCB has a
separate Completion Area and, unless execution order is specifically restricted through the use of serial-
conditional flags, the execution order of submitted CCBs is arbitrary. Likewise, the time to completion
for a given CCB is never guaranteed.

Guest software may implement a software timeout on CCB operations, and if the timeout is exceeded, the
operation may be cancelled or killed via the ccb_kill API function. It is recommended for guest software
to implement a software timeout to account for certain RAS errors which may result in lost CCBs. It is
recommended such implementation use the ccb_info API function to check the status of a CCB prior to
killing it in order to determine if the CCB is still in queue, or may have been lost due to a RAS error.

There is no fixed limit on the number of outstanding CCBs guest software may have queued in the virtual
machine, however, internal resource limitations within the virtual machine can cause CCB submissions
to be temporarily rejected with EWOULDBLOCK. In such cases, guests should continue to attempt
submissions until they succeed; waiting for an outstanding CCB to complete is not necessary, and would
not be a guarantee that a future submission would succeed.

The availability of DAX coprocessor command service is indicated by the presence of the DAX virtual
device node in the guest MD (Section 8.24.17, “Database Analytics Accelerators (DAX) virtual-device
node”).

36.1.1. DAX Compatibility Property
The query functionality may vary based on the compatibility property of the virtual device:

36.1.1.1. "ORCL,sun4v-dax" Device Compatibility
Available CCB commands:

• No-op/Sync

• Extract

• Scan Value

• Inverted Scan Value

• Scan Range

509

Coprocessor services

• Inverted Scan Range

• Translate

• Inverted Translate

• Select

See Section 36.2.1, “Query CCB Command Formats” for the corresponding CCB input and output formats.

Only version 0 CCBs are available.

36.1.1.2. "ORCL,sun4v-dax-fc" Device Compatibility
"ORCL,sun4v-dax-fc" is compatible with the "ORCL,sun4v-dax" interface, and includes additional CCB
bit fields and controls.

36.1.1.3. "ORCL,sun4v-dax2" Device Compatibility
Available CCB commands:

• No-op/Sync

• Extract

• Scan Value

• Inverted Scan Value

• Scan Range

• Inverted Scan Range

• Translate

• Inverted Translate

• Select

See Section 36.2.1, “Query CCB Command Formats” for the corresponding CCB input and output formats.

Version 0 and 1 CCBs are available. Only version 0 CCBs may use Huffman encoded data, whereas only
version 1 CCBs may use OZIP.

36.1.2. DAX Virtual Device Interrupts
The DAX virtual device has multiple interrupts associated with it which may be used by the guest if
desired. The number of device interrupts available to the guest is indicated in the virtual device node of the
guest MD (Section 8.24.17, “Database Analytics Accelerators (DAX) virtual-device node”). If the device
node indicates N interrupts available, the guest may use any value from 0 to N - 1 (inclusive) in a CCB
interrupt number field. Using values outside this range will result in the CCB being rejected for an invalid
field value.

The interrupts may be bound and managed using the standard sun4v device interrupts API (Chapter 16,
Device interrupt services). Sysino interrupts are not available for DAX devices.

36.2. Coprocessor Control Block (CCB)
CCBs are either 64 or 128 bytes long, depending on the operation type. The exact contents of the CCB
are command specific, but all CCBs contain at least one memory buffer address. All memory locations

510

Coprocessor services

referenced by a CCB must be pinned in memory until the CCB either completes execution or is killed
via the ccb_kill API call. Changes in virtual address mappings occurring after CCB submission are not
guaranteed to be visible, and as such all virtual address updates need to be synchronized with CCB
execution.

All CCBs begin with a common 32-bit header.

Table 36.1. CCB Header Format
Bits Field Description
[31:28] CCB version. For API version 2.0: set to 1 if CCB uses OZIP encoding; set to 0 if the CCB
uses Huffman encoding; otherwise either 0 or 1. For API version 1.0: always set to 0.
[27] When API version 2.0 is negotiated, this is the Pipeline Flag [512]. It is reserved in
API version 1.0
[26] Long CCB flag [512]
[25] Conditional synchronization flag [512]
[24] Serial synchronization flag
[23:16] CCB operation code:
0x00 No Operation (No-op) or Sync
0x01 Extract
0x02 Scan Value
0x12 Inverted Scan Value
0x03 Scan Range
0x13 Inverted Scan Range
0x04 Translate
0x14 Inverted Translate
0x05 Select
[15:13] Reserved
[12:11] Table address type
0b'00 No address
0b'01 Alternate context virtual address
0b'10 Real address
0b'11 Primary context virtual address
[10:8] Output/Destination address type
0b'000 No address
0b'001 Alternate context virtual address
0b'010 Real address
0b'011 Primary context virtual address
0b'100 Reserved
0b'101 Reserved
0b'110 Reserved
0b'111 Reserved
[7:5] Secondary source address type

511

Coprocessor services

Bits Field Description
0b'000 No address
0b'001 Alternate context virtual address
0b'010 Real address
0b'011 Primary context virtual address
0b'100 Reserved
0b'101 Reserved
0b'110 Reserved
0b'111 Reserved
[4:2] Primary source address type
0b'000 No address
0b'001 Alternate context virtual address
0b'010 Real address
0b'011 Primary context virtual address
0b'100 Reserved
0b'101 Reserved
0b'110 Reserved
0b'111 Reserved
[1:0] Completion area address type
0b'00 No address
0b'01 Alternate context virtual address
0b'10 Real address
0b'11 Primary context virtual address

The Long CCB flag indicates whether the submitted CCB is 64 or 128 bytes long; value is 0 for 64 bytes
and 1 for 128 bytes.

The Serial and Conditional flags allow simple relative ordering between CCBs. Any CCB with the Serial
flag set will execute sequentially relative to any previous CCB that is also marked as Serial in the same
CCB submission. CCBs without the Serial flag set execute independently, even if they are between CCBs
with the Serial flag set. CCBs marked solely with the Serial flag will execute upon the completion of the
previous Serial CCB, regardless of the completion status of that CCB. The Conditional flag allows CCBs
to conditionally execute based on the successful execution of the closest CCB marked with the Serial flag.
A CCB may only be conditional on exactly one CCB, however, a CCB may be marked both Conditional
and Serial to allow execution chaining. The flags do NOT allow fan-out chaining, where multiple CCBs
execute in parallel based on the completion of another CCB.

The Pipeline flag is an optimization that directs the output of one CCB (the "source" CCB) directly to
the input of the next CCB (the "target" CCB). The target CCB thus does not need to read the input from
memory. The Pipeline flag is advisory and may be dropped.

Both the Pipeline and Serial bits must be set in the source CCB. The Conditional bit must be set in the
target CCB. Exactly one CCB must be made conditional on the source CCB; either 0 or 2 target CCBs
is invalid. However, Pipelines can be extended beyond two CCBs: the sequence would start with a CCB
with both the Pipeline and Serial bits set, proceed through CCBs with the Pipeline, Serial, and Conditional
bits set, and terminate at a CCB that has the Conditional bit set, but not the Pipeline bit.

512

Coprocessor services

The input of the target CCB must start within 64 bytes of the output of the source CCB or the pipeline flag
will be ignored. All CCBs in a pipeline must be submitted in the same call to ccb_submit.

The various address type fields indicate how the various address values used in the CCB should be
interpreted by the virtual machine. Not all of the types specified are used by every CCB format. Types
which are not applicable to the given CCB command should be indicated as type 0 (No address). Virtual
addresses used in the CCB must have translation entries present in either the TLB or a configured TSB
for the submitting virtual processor. Virtual addresses which cannot be translated by the virtual machine
will result in the CCB submission being rejected, with the causal virtual address indicated. The CCB
may be resubmitted after inserting the translation, or the address may be translated by guest software and
resubmitted using the real address translation.

36.2.1. Query CCB Command Formats
36.2.1.1. Supported Data Formats, Elements Sizes and Offsets
Data for query commands may be encoded in multiple possible formats. The data query commands use a
common set of values to indicate the encoding formats of the data being processed. Some encoding formats
require multiple data streams for processing, requiring the specification of both primary data formats (the
encoded data) and secondary data streams (meta-data for the encoded data).

36.2.1.1.1. Primary Input Format

The primary input format code is a 4-bit field when it is used. There are 10 primary input formats available.
The packed formats are not endian neutral. Code values not listed below are reserved.

Code Format Description
0x0 Fixed width byte packed Up to 16 bytes
0x1 Fixed width bit packed Up to 15 bits (CCB version 0) or 23 bits (CCB version
1); bits are read most significant bit to least significant bit
within a byte
0x2 Variable width byte packed Data stream of lengths must be provided as a secondary
input
0x4 Fixed width byte packed with run Up to 16 bytes; data stream of run lengths must be
length encoding provided as a secondary input
0x5 Fixed width bit packed with run Up to 15 bits (CCB version 0) or 23 bits (CCB version
length encoding 1); bits are read most significant bit to least significant bit
within a byte; data stream of run lengths must be provided
as a secondary input
0x8 Fixed width byte packed with Up to 16 bytes before the encoding; compressed stream
Huffman (CCB version 0) or bits are read most significant bit to least significant bit
OZIP (CCB version 1) encoding within a byte; pointer to the encoding table must be
provided
0x9 Fixed width bit packed with Up to 15 bits (CCB version 0) or 23 bits (CCB version
Huffman (CCB version 0) or 1); compressed stream bits are read most significant bit to
OZIP (CCB version 1) encoding least significant bit within a byte; pointer to the encoding
table must be provided
0xA Variable width byte packed with Up to 16 bytes before the encoding; compressed stream
Huffman (CCB version 0) or bits are read most significant bit to least significant bit
OZIP (CCB version 1) encoding within a byte; data stream of lengths must be provided as
a secondary input; pointer to the encoding table must be
provided

513

Coprocessor services

Code Format Description
0xC Fixed width byte packed with Up to 16 bytes before the encoding; compressed stream
run length encoding, followed by bits are read most significant bit to least significant bit
Huffman (CCB version 0) or within a byte; data stream of run lengths must be provided
OZIP (CCB version 1) encoding as a secondary input; pointer to the encoding table must
be provided
0xD Fixed width bit packed with Up to 15 bits (CCB version 0) or 23 bits(CCB version 1)
run length encoding, followed by before the encoding; compressed stream bits are read most
Huffman (CCB version 0) or significant bit to least significant bit within a byte; data
OZIP (CCB version 1) encoding stream of run lengths must be provided as a secondary
input; pointer to the encoding table must be provided

If OZIP encoding is used, there must be no reserved bytes in the table.

36.2.1.1.2. Primary Input Element Size

For primary input data streams with fixed size elements, the element size must be indicated in the CCB
command. The size is encoded as the number of bits or bytes, minus one. The valid value range for this
field depends on the input format selected, as listed in the table above.

36.2.1.1.3. Secondary Input Format

For primary input data streams which require a secondary input stream, the secondary input stream is
always encoded in a fixed width, bit-packed format. The bits are read from most significant bit to least
significant bit within a byte. There are two encoding options for the secondary input stream data elements,
depending on whether the value of 0 is needed:

Secondary Input Description
Format Code
0 Element is stored as value minus 1 (0 evaluates to 1, 1 evaluates
to 2, etc)
1 Element is stored as value

36.2.1.1.4. Secondary Input Element Size

Secondary input element size is encoded as a two bit field:

Secondary Input Size Description
Code
0x0 1 bit
0x1 2 bits
0x2 4 bits
0x3 8 bits

36.2.1.1.5. Input Element Offsets

Bit-wise input data streams may have any alignment within the base addressed byte. The offset, specified
from most significant bit to least significant bit, is provided as a fixed 3 bit field for each input type. A
value of 0 indicates that the first input element begins at the most significant bit in the first byte, and a
value of 7 indicates it begins with the least significant bit.

This field should be zero for any byte-wise primary input data streams.

514

Coprocessor services

36.2.1.1.6. Output Format

Query commands support multiple sizes and encodings for output data streams. There are four possible
output encodings, and up to four supported element sizes per encoding. Not all output encodings are
supported for every command. The format is indicated by a 4-bit field in the CCB:

Output Format Code Description
0x0 Byte aligned, 1 byte elements
0x1 Byte aligned, 2 byte elements
0x2 Byte aligned, 4 byte elements
0x3 Byte aligned, 8 byte elements
0x4 16 byte aligned, 16 byte elements
0x5 Reserved
0x6 Reserved
0x7 Reserved
0x8 Packed vector of single bit elements
0x9 Reserved
0xA Reserved
0xB Reserved
0xC Reserved
0xD 2 byte elements where each element is the index value of a bit,
from an bit vector, which was 1.
0xE 4 byte elements where each element is the index value of a bit,
from an bit vector, which was 1.
0xF Reserved

36.2.1.1.7. Application Data Integrity (ADI)

On platforms which support ADI, the ADI version number may be specified for each separate memory
access type used in the CCB command. ADI checking only occurs when reading data. When writing data,
the specified ADI version number overwrites any existing ADI value in memory.

An ADI version value of 0 or 0xF indicates the ADI checking is disabled for that data access, even if it is
enabled in memory. By setting the appropriate flag in CCB_SUBMIT (Section 36.3.1, “ccb_submit”) it is
also an option to disable ADI checking for all inputs accessed via virtual address for all CCBs submitted
during that hypercall invocation.

The ADI value is only guaranteed to be checked on the first 64 bytes of each data access. Mismatches on
subsequent data chunks may not be detected, so guest software should be careful to use page size checking
to protect against buffer overruns.

36.2.1.1.8. Page size checking

All data accesses used in CCB commands must be bounded within a single memory page. When addresses
are provided using a virtual address, the page size for checking is extracted from the TTE for that virtual
address. When using real addresses, the guest must supply the page size in the same field as the address
value. The page size must be one of the sizes supported by the underlying virtual machine. Using a value
that is not supported may result in the CCB submission being rejected or the generation of a CCB parsing
error in the completion area.

515

Coprocessor services

36.2.1.2. Extract command

Converts an input vector in one format to an output vector in another format. All input format types are
supported.

The only supported output format is a padded, byte-aligned output stream, using output codes 0x0 - 0x4.
When the specified output element size is larger than the extracted input element size, zeros are padded to
the extracted input element. First, if the decompressed input size is not a whole number of bytes, 0 bits are
padded to the most significant bit side till the next byte boundary. Next, if the output element size is larger
than the byte padded input element, bytes of value 0 are added based on the Padding Direction bit in the
CCB. If the output element size is smaller than the byte-padded input element size, the input element is
truncated by dropped from the least significant byte side until the selected output size is reached.

The return value of the CCB completion area is invalid. The “number of elements processed” field in the
CCB completion area will be valid.

The extract CCB is a 64-byte “short format” CCB.

The extract CCB command format can be specified by the following packed C structure for a big-endian
machine:

struct extract_ccb {
uint32_t header;
uint32_t control;
uint64_t completion;
uint64_t primary_input;
uint64_t data_access_control;
uint64_t secondary_input;
uint64_t reserved;
uint64_t output;
uint64_t table;
};

The exact field offsets, sizes, and composition are as follows:

Offset Size Field Description
0 4 CCB header (Table 36.1, “CCB Header Format”)
4 4 Command control
Bits Field Description
[31:28] Primary Input Format (see Section 36.2.1.1.1, “Primary Input
Format”)
[27:23] Primary Input Element Size (see Section 36.2.1.1.2, “Primary
Input Element Size”)
[22:20] Primary Input Starting Offset (see Section 36.2.1.1.5, “Input
Element Offsets”)
[19] Secondary Input Format (see Section 36.2.1.1.3, “Secondary
Input Format”)
[18:16] Secondary Input Starting Offset (see Section 36.2.1.1.5, “Input
Element Offsets”)

516

Coprocessor services

Offset Size Field Description
Bits Field Description
[15:14] Secondary Input Element Size (see Section 36.2.1.1.4,
“Secondary Input Element Size”
[13:10] Output Format (see Section 36.2.1.1.6, “Output Format”)
[9] Padding Direction selector: A value of 1 causes padding bytes
to be added to the left side of output elements. A value of 0
causes padding bytes to be added to the right side of output
elements.
[8:0] Reserved
8 8 Completion
Bits Field Description
[63:60] ADI version (see Section 36.2.1.1.7, “Application Data
Integrity (ADI)”)
[59] If set to 1, a virtual device interrupt will be generated using
the device interrupt number specified in the lower bits of this
completion word. If 0, the lower bits of this completion word
are ignored.
[58:6] Completion area address bits [58:6]. Address type is
determined by CCB header.
[5:0] Virtual device interrupt number for completion interrupt, if
enabled.
16 8 Primary Input
Bits Field Description
[63:60] ADI version (see Section 36.2.1.1.7, “Application Data
Integrity (ADI)”)
[59:56] If using real address, these bits should be filled in with the
page size code for the page boundary checking the guest wants
the virtual machine to use when accessing this data stream
(checking is only guaranteed to be performed when using API
version 1.1 and later). If using a virtual address, this field will
be used as as primary input address bits [59:56].
[55:0] Primary input address bits [55:0]. Address type is determined
by CCB header.
24 8 Data Access Control
Bits Field Description
[63:62] Flow Control
Value Description
0b'00 Disable flow control
0b'01 Enable flow control (only valid with "ORCL,sun4v-
dax-fc" compatible virtual device variants)
0b'10 Reserved
0b'11 Reserved
[61:60] Reserved (API 1.0)

517

Coprocessor services

Offset Size Field Description
Bits Field Description
Pipeline target (API 2.0)
Value Description
0b'00 Connect to primary input
0b'01 Connect to secondary input
0b'10 Reserved
0b'11 Reserved
[59:40] Output buffer size given in units of 64 bytes, minus 1. Value of
0 means 64 bytes, value of 1 means 128 bytes, etc. Buffer size is
only enforced if flow control is enabled in Flow Control field.
[39:32] Reserved
[31:30] Output Data Cache Allocation
Value Description
0b'00 Do not allocate cache lines for output data stream.
0b'01 Force cache lines for output data stream to be
allocated in the cache that is local to the submitting
virtual cpu.
0b'10 Allocate cache lines for output data stream, but allow
existing cache lines associated with the data to remain
in their current cache instance. Any memory not
already in cache will be allocated in the cache local
to the submitting virtual cpu.
0b'11 Reserved
[29:26] Reserved
[25:24] Primary Input Length Format
Value Description
0b'00 Number of primary symbols
0b'01 Number of primary bytes
0b'10 Number of primary bits
0b'11 Reserved
[23:0] Primary Input Length
Format Field Value
# of primary symbols Number of input elements to process,
minus 1. Command execution stops
once count is reached.
# of primary bytes Number of input bytes to process,
minus 1. Command execution stops
once count is reached. The count is
done before any decompression or
decoding.
# of primary bits Number of input bits to process,
minus 1. Command execution stops

518

Coprocessor services

Offset Size Field Description
Bits Field Description
Format Field Value
once count is reached. The count is
done before any decompression or
decoding, and does not include any
bits skipped by the Primary Input
Offset field value of the command
control word.
32 8 Secondary Input, if used by Primary Input Format. Same fields as Primary
Input.
40 8 Reserved
48 8 Output (same fields as Primary Input)
56 8 Symbol Table (if used by Primary Input)
Bits Field Description
[63:60] ADI version (see Section 36.2.1.1.7, “Application Data
Integrity (ADI)”)
[59:56] If using real address, these bits should be filled in with the
page size code for the page boundary checking the guest wants
the virtual machine to use when accessing this data stream
(checking is only guaranteed to be performed when using API
version 1.1 and later). If using a virtual address, this field will
be used as as symbol table address bits [59:56].
[55:4] Symbol table address bits [55:4]. Address type is determined
by CCB header.
[3:0] Symbol table version
Value Description
0 Huffman encoding. Must use 64 byte aligned table
address. (Only available when using version 0 CCBs)
1 OZIP encoding. Must use 16 byte aligned table
address. (Only available when using version 1 CCBs)

36.2.1.3. Scan commands

The scan commands search a stream of input data elements for values which match the selection criteria.
All the input format types are supported. There are multiple formats for the scan commands, allowing the
scan to search for exact matches to one value, exact matches to either of two values, or any value within
a specified range. The specific type of scan is indicated by the command code in the CCB header. For the
scan range commands, the boundary conditions can be specified as greater-than-or-equal-to a value, less-
than-or-equal-to a value, or both by using two boundary values.

There are two supported formats for the output stream: the bit vector and index array formats (codes 0x8,
0xD, and 0xE). For the standard scan command using the bit vector output, for each input element there
exists one bit in the vector that is set if the input element matched the scan criteria, or clear if not. The
inverted scan command inverts the polarity of the bits in the output. The most significant bit of the first
byte of the output stream corresponds to the first element in the input stream. The standard index array
output format contains one array entry for each input element that matched the scan criteria. Each array

519

Coprocessor services

entry is the index of an input element that matched the scan criteria. An inverted scan command produces
a similar array, but of all the input elements which did NOT match the scan criteria.

The return value of the CCB completion area contains the number of input elements found which match
the scan criteria (or number that did not match for the inverted scans). The “number of elements processed”
field in the CCB completion area will be valid, indicating the number of input elements processed.

These commands are 128-byte “long format” CCBs.

The scan CCB command format can be specified by the following packed C structure for a big-endian
machine:

struct scan_ccb {
uint32_t header;
uint32_t control;
uint64_t completion;
uint64_t primary_input;
uint64_t data_access_control;
uint64_t secondary_input;
uint64_t match_criteria0;
uint64_t output;
uint64_t table;
uint64_t match_criteria1;
uint64_t match_criteria2;
uint64_t match_criteria3;
uint64_t reserved[5];
};

The exact field offsets, sizes, and composition are as follows:

Offset Size Field Description
0 4 CCB header (Table 36.1, “CCB Header Format”)
4 4 Command control
Bits Field Description
[31:28] Primary Input Format (see Section 36.2.1.1.1, “Primary Input
Format”)
[27:23] Primary Input Element Size (see Section 36.2.1.1.2, “Primary
Input Element Size”)
[22:20] Primary Input Starting Offset (see Section 36.2.1.1.5, “Input
Element Offsets”)
[19] Secondary Input Format (see Section 36.2.1.1.3, “Secondary
Input Format”)
[18:16] Secondary Input Starting Offset (see Section 36.2.1.1.5, “Input
Element Offsets”)
[15:14] Secondary Input Element Size (see Section 36.2.1.1.4,
“Secondary Input Element Size”
[13:10] Output Format (see Section 36.2.1.1.6, “Output Format”)
[9:5] Operand size for first scan criteria value. In a scan value
operation, this is one of two potential exact match values.
In a scan range operation, this is the size of the upper range

520

Coprocessor services

Offset Size Field Description
Bits Field Description
boundary. The value of this field is the number of bytes in the
operand, minus 1. Values 0xF-0x1E are reserved. A value of
0x1F indicates this operand is not in use for this scan operation.
[4:0] Operand size for second scan criteria value. In a scan value
operation, this is one of two potential exact match values.
In a scan range operation, this is the size of the lower range
boundary. The value of this field is the number of bytes in the
operand, minus 1. Values 0xF-0x1E are reserved. A value of
0x1F indicates this operand is not in use for this scan operation.
8 8 Completion (same fields as Section 36.2.1.2, “Extract command”)
16 8 Primary Input (same fields as Section 36.2.1.2, “Extract command”)
24 8 Data Access Control (same fields as Section 36.2.1.2, “Extract command”)
32 8 Secondary Input, if used by Primary Input Format. Same fields as Primary
Input.
40 4 Most significant 4 bytes of first scan criteria operand. If first operand is less
than 4 bytes, the value is left-aligned to the lowest address bytes.
44 4 Most significant 4 bytes of second scan criteria operand. If second operand
is less than 4 bytes, the value is left-aligned to the lowest address bytes.
48 8 Output (same fields as Primary Input)
56 8 Symbol Table (if used by Primary Input). Same fields as Section 36.2.1.2,
“Extract command”
64 4 Next 4 most significant bytes of first scan criteria operand occurring after the
bytes specified at offset 40, if needed by the operand size. If first operand
is less than 8 bytes, the valid bytes are left-aligned to the lowest address.
68 4 Next 4 most significant bytes of second scan criteria operand occurring after
the bytes specified at offset 44, if needed by the operand size. If second
operand is less than 8 bytes, the valid bytes are left-aligned to the lowest
address.
72 4 Next 4 most significant bytes of first scan criteria operand occurring after the
bytes specified at offset 64, if needed by the operand size. If first operand
is less than 12 bytes, the valid bytes are left-aligned to the lowest address.
76 4 Next 4 most significant bytes of second scan criteria operand occurring after
the bytes specified at offset 68, if needed by the operand size. If second
operand is less than 12 bytes, the valid bytes are left-aligned to the lowest
address.
80 4 Next 4 most significant bytes of first scan criteria operand occurring after the
bytes specified at offset 72, if needed by the operand size. If first operand
is less than 16 bytes, the valid bytes are left-aligned to the lowest address.
84 4 Next 4 most significant bytes of second scan criteria operand occurring after
the bytes specified at offset 76, if needed by the operand size. If second
operand is less than 16 bytes, the valid bytes are left-aligned to the lowest
address.

521

Coprocessor services

36.2.1.4. Translate commands

The translate commands takes an input array of indices, and a table of single bit values indexed by those
indices, and outputs a bit vector or index array created by reading the tables bit value at each index in
the input array. The output should therefore contain exactly one bit per index in the input data stream,
when outputting as a bit vector. When outputting as an index array, the number of elements depends on the
values read in the bit table, but will always be less than, or equal to, the number of input elements. Only
a restricted subset of the possible input format types are supported. No variable width or Huffman/OZIP
encoded input streams are allowed. The primary input data element size must be 3 bytes or less.

The maximum table index size allowed is 15 bits, however, larger input elements may be used to provide
additional processing of the output values. If 2 or 3 byte values are used, the least significant 15 bits are
used as an index into the bit table. The most significant 9 bits (when using 3-byte input elements) or single
bit (when using 2-byte input elements) are compared against a fixed 9-bit test value provided in the CCB.
If the values match, the value from the bit table is used as the output element value. If the values do not
match, the output data element value is forced to 0.

In the inverted translate operation, the bit value read from bit table is inverted prior to its use. The additional
additional processing based on any additional non-index bits remains unchanged, and still forces the output
element value to 0 on a mismatch. The specific type of translate command is indicated by the command
code in the CCB header.

There are two supported formats for the output stream: the bit vector and index array formats (codes 0x8,
0xD, and 0xE). The index array format is an array of indices of bits which would have been set if the
output format was a bit array.

The return value of the CCB completion area contains the number of bits set in the output bit vector,
or number of elements in the output index array. The “number of elements processed” field in the CCB
completion area will be valid, indicating the number of input elements processed.

These commands are 64-byte “short format” CCBs.

The translate CCB command format can be specified by the following packed C structure for a big-endian
machine:

struct translate_ccb {
uint32_t header;
uint32_t control;
uint64_t completion;
uint64_t primary_input;
uint64_t data_access_control;
uint64_t secondary_input;
uint64_t reserved;
uint64_t output;
uint64_t table;
};

The exact field offsets, sizes, and composition are as follows:

Offset Size Field Description
0 4 CCB header (Table 36.1, “CCB Header Format”)

522

Coprocessor services

Offset Size Field Description
4 4 Command control
Bits Field Description
[31:28] Primary Input Format (see Section 36.2.1.1.1, “Primary Input
Format”)
[27:23] Primary Input Element Size (see Section 36.2.1.1.2, “Primary
Input Element Size”)
[22:20] Primary Input Starting Offset (see Section 36.2.1.1.5, “Input
Element Offsets”)
[19] Secondary Input Format (see Section 36.2.1.1.3, “Secondary
Input Format”)
[18:16] Secondary Input Starting Offset (see Section 36.2.1.1.5, “Input
Element Offsets”)
[15:14] Secondary Input Element Size (see Section 36.2.1.1.4,
“Secondary Input Element Size”
[13:10] Output Format (see Section 36.2.1.1.6, “Output Format”)
[9] Reserved
[8:0] Test value used for comparison against the most significant bits
in the input values, when using 2 or 3 byte input elements.
8 8 Completion (same fields as Section 36.2.1.2, “Extract command”
16 8 Primary Input (same fields as Section 36.2.1.2, “Extract command”
24 8 Data Access Control (same fields as Section 36.2.1.2, “Extract command”,
except Primary Input Length Format may not use the 0x0 value)
32 8 Secondary Input, if used by Primary Input Format. Same fields as Primary
Input.
40 8 Reserved
48 8 Output (same fields as Primary Input)
56 8 Bit Table
Bits Field Description
[63:60] ADI version (see Section 36.2.1.1.7, “Application Data
Integrity (ADI)”)
[59:56] If using real address, these bits should be filled in with the
page size code for the page boundary checking the guest wants
the virtual machine to use when accessing this data stream
(checking is only guaranteed to be performed when using API
version 1.1 and later). If using a virtual address, this field will
be used as as bit table address bits [59:56]
[55:4] Bit table address bits [55:4]. Address type is determined by
CCB header. Address must be 64-byte aligned (CCB version
0) or 16-byte aligned (CCB version 1).
[3:0] Bit table version
Value Description
0 4KB table size
1 8KB table size

523

Coprocessor services

36.2.1.5. Select command
The select command filters the primary input data stream by using a secondary input bit vector to determine
which input elements to include in the output. For each bit set at a given index N within the bit vector,
the Nth input element is included in the output. If the bit is not set, the element is not included. Only a
restricted subset of the possible input format types are supported. No variable width or run length encoded
input streams are allowed, since the secondary input stream is used for the filtering bit vector.

The only supported output format is a padded, byte-aligned output stream. The stream follows the same
rules and restrictions as padded output stream described in Section 36.2.1.2, “Extract command”.

The return value of the CCB completion area contains the number of bits set in the input bit vector. The
"number of elements processed" field in the CCB completion area will be valid, indicating the number
of input elements processed.

The select CCB is a 64-byte “short format” CCB.

The select CCB command format can be specified by the following packed C structure for a big-endian
machine:

struct select_ccb {
uint32_t header;
uint32_t control;
uint64_t completion;
uint64_t primary_input;
uint64_t data_access_control;
uint64_t secondary_input;
uint64_t reserved;
uint64_t output;
uint64_t table;
};

The exact field offsets, sizes, and composition are as follows:

Offset Size Field Description
0 4 CCB header (Table 36.1, “CCB Header Format”)
4 4 Command control
Bits Field Description
[31:28] Primary Input Format (see Section 36.2.1.1.1, “Primary Input
Format”)
[27:23] Primary Input Element Size (see Section 36.2.1.1.2, “Primary
Input Element Size”)
[22:20] Primary Input Starting Offset (see Section 36.2.1.1.5, “Input
Element Offsets”)
[19] Secondary Input Format (see Section 36.2.1.1.3, “Secondary
Input Format”)
[18:16] Secondary Input Starting Offset (see Section 36.2.1.1.5, “Input
Element Offsets”)
[15:14] Secondary Input Element Size (see Section 36.2.1.1.4,
“Secondary Input Element Size”

524

Coprocessor services

Offset Size Field Description
Bits Field Description
[13:10] Output Format (see Section 36.2.1.1.6, “Output Format”)
[9] Padding Direction selector: A value of 1 causes padding bytes
to be added to the left side of output elements. A value of 0
causes padding bytes to be added to the right side of output
elements.
[8:0] Reserved
8 8 Completion (same fields as Section 36.2.1.2, “Extract command”
16 8 Primary Input (same fields as Section 36.2.1.2, “Extract command”
24 8 Data Access Control (same fields as Section 36.2.1.2, “Extract command”)
32 8 Secondary Bit Vector Input. Same fields as Primary Input.
40 8 Reserved
48 8 Output (same fields as Primary Input)
56 8 Symbol Table (if used by Primary Input). Same fields as Section 36.2.1.2,
“Extract command”

36.2.1.6. No-op and Sync commands
The no-op (no operation) command is a CCB which has no processing effect. The CCB, when processed
by the virtual machine, simply updates the completion area with its execution status. The CCB may have
the serial-conditional flags set in order to restrict when it executes.

The sync command is a variant of the no-op command which with restricted execution timing. A sync
command CCB will only execute when all previous commands submitted in the same request have
completed. This is stronger than the conditional flag sequencing, which is only dependent on a single
previous serial CCB. While the relative ordering is guaranteed, virtual machine implementations with
shared hardware resources may cause the sync command to wait for longer than the minimum required
time.

The return value of the CCB completion area is invalid for these CCBs. The “number of elements
processed” field is also invalid for these CCBs.

These commands are 64-byte “short format” CCBs.

The no-op CCB command format can be specified by the following packed C structure for a big-endian
machine:

struct nop_ccb {
uint32_t header;
uint32_t control;
uint64_t completion;
uint64_t reserved[6];
};

The exact field offsets, sizes, and composition are as follows:

Offset Size Field Description
0 4 CCB header (Table 36.1, “CCB Header Format”)

525

Coprocessor services

Offset Size Field Description
4 4 Command control
Bits Field Description
[31] If set, this CCB functions as a Sync command. If clear, this
CCB functions as a No-op command.
[30:0] Reserved
8 8 Completion (same fields as Section 36.2.1.2, “Extract command”
16 46 Reserved

36.2.2. CCB Completion Area
All CCB commands use a common 128-byte Completion Area format, which can be specified by the
following packed C structure for a big-endian machine:

struct completion_area {
uint8_t status_flag;
uint8_t error_note;
uint8_t rsvd0[2];
uint32_t error_values;
uint32_t output_size;
uint32_t rsvd1;
uint64_t run_time;
uint64_t run_stats;
uint32_t elements;
uint8_t rsvd2[20];
uint64_t return_value;
uint64_t extra_return_value[8];
};

The Completion Area must be a 128-byte aligned memory location. The exact layout can be described
using byte offsets and sizes relative to the memory base:

Offset Size Field Description
0 1 CCB execution status
0x0 Command not yet completed
0x1 Command ran and succeeded
0x2 Command ran and failed (partial results may be been
produced)
0x3 Command ran and was killed (partial execution may
have occurred)
0x4 Command was not run
0x5-0xF Reserved
1 1 Error reason code
0x0 Reserved
0x1 Buffer overflow

526

Coprocessor services

Offset Size Field Description
0x2 CCB decoding error
0x3 Page overflow
0x4-0x6 Reserved
0x7 Command was killed
0x8 Command execution timeout
0x9 ADI miscompare error
0xA Data format error
0xB-0xD Reserved
0xE Unexpected hardware error (Do not retry)
0xF Unexpected hardware error (Retry is ok)
0x10-0x7F Reserved
0x80 Partial Symbol Warning
0x81-0xFF Reserved
2 2 Reserved
4 4 If a partial symbol warning was generated, this field contains the number
of remaining bits which were not decoded.
8 4 Number of bytes of output produced
12 4 Reserved
16 8 Runtime of command (unspecified time units)
24 8 Reserved
32 4 Number of elements processed
36 20 Reserved
56 8 Return value
64 64 Extended return value

The CCB completion area should be treated as read-only by guest software. The CCB execution status
byte will be cleared by the Hypervisor to reflect the pending execution status when the CCB is submitted
successfully. All other fields are considered invalid upon CCB submission until the CCB execution status
byte becomes non-zero.

CCBs which complete with status 0x2 or 0x3 may produce partial results and/or side effects due to partial
execution of the CCB command. Some valid data may be accessible depending on the fault type, however,
it is recommended that guest software treat the destination buffer as being in an unknown state. If a CCB
completes with a status byte of 0x2, the error reason code byte can be read to determine what corrective
action should be taken.

A buffer overflow indicates that the results of the operation exceeded the size of the output buffer indicated
in the CCB. The operation can be retried by resubmitting the CCB with a larger output buffer.

A CCB decoding error indicates that the CCB contained some invalid field values. It may be also be
triggered if the CCB output is directed at a non-existent secondary input and the pipelining hint is followed.

A page overflow error indicates that the operation required accessing a memory location beyond the page
size associated with a given address. No data will have been read or written past the page boundary, but
partial results may have been written to the destination buffer. The CCB can be resubmitted with a larger
page size memory allocation to complete the operation.

527

Coprocessor services

In the case of pipelined CCBs, a page overflow error will be triggered if the output from the pipeline source
CCB ends before the input of the pipeline target CCB. Page boundaries are ignored when the pipeline
hint is followed.

Command kill indicates that the CCB execution was halted or prevented by use of the ccb_kill API call.

Command timeout indicates that the CCB execution began, but did not complete within a pre-determined
limit set by the virtual machine. The command may have produced some or no output. The CCB may be
resubmitted with no alterations.

ADI miscompare indicates that the memory buffer version specified in the CCB did not match the value
in memory when accessed by the virtual machine. Guest software should not attempt to resubmit the CCB
without determining the cause of the version mismatch.

A data format error indicates that the input data stream did not follow the specified data input formatting
selected in the CCB.

Some CCBs which encounter hardware errors may be resubmitted without change. Persistent hardware
errors may result in multiple failures until RAS software can identify and isolate the faulty component.

The output size field indicates the number of bytes of valid output in the destination buffer. This field is
not valid for all possible CCB commands.

The runtime field indicates the execution time of the CCB command once it leaves the internal virtual
machine queue. The time units are fixed, but unspecified, allowing only relative timing comparisons
by guest software. The time units may also vary by hardware platform, and should not be construed to
represent any absolute time value.

Some data query commands process data in units of elements. If applicable to the command, the number of
elements processed is indicated in the listed field. This field is not valid for all possible CCB commands.

The return value and extended return value fields are output locations for commands which do not use
a destination output buffer, or have secondary return results. The field is not valid for all possible CCB
commands.

36.3. Hypervisor API Functions
36.3.1. ccb_submit
trap# FAST_TRAP
function# CCB_SUBMIT
arg0 address
arg1 length
arg2 flags
arg3 reserved
ret0 status
ret1 length
ret2 status data
ret3 reserved

Submit one or more coprocessor control blocks (CCBs) for evaluation and processing by the virtual
machine. The CCBs are passed in a linear array indicated by address. length indicates the size of
the array in bytes.

528

Coprocessor services

The address should be aligned to the size indicated by length, rounded up to the nearest power of
two. Virtual machines implementations may reject submissions which do not adhere to that alignment.
length must be a multiple of 64 bytes. If length is zero, the maximum supported array length will be
returned as length in ret1. In all other cases, the length value in ret1 will reflect the number of bytes
successfully consumed from the input CCB array.

Implementation note
Virtual machines should never reject submissions based on the alignment of address if the
entire array is contained within a single memory page of the smallest page size supported by the
virtual machine.

A guest may choose to submit addresses used in this API function, including the CCB array address,
as either a real or virtual addresses, with the type of each address indicated in flags. Virtual addresses
must be present in either the TLB or an active TSB to be processed. The translation context for virtual
addresses is determined by a combination of CCB contents and the flags argument.

The flags argument is divided into multiple fields defined as follows:

Bits Field Description
[63:16] Reserved
[15] Disable ADI for VA reads (in API 2.0)
Reserved (in API 1.0)
[14] Virtual addresses within CCBs are translated in privileged context
[13:12] Alternate translation context for virtual addresses within CCBs:
0b'00 CCBs requesting alternate context are rejected
0b'01 Reserved
0b'10 CCBs requesting alternate context use secondary context
0b'11 CCBs requesting alternate context use nucleus context
[11:9] Reserved
[8] Queue info flag
[7] All-or-nothing flag
[6] If address is a virtual address, treat its translation context as privileged
[5:4] Address type of address:
0b'00 Real address
0b'01 Virtual address in primary context
0b'10 Virtual address in secondary context
0b'11 Virtual address in nucleus context
[3:2] Reserved
[1:0] CCB command type:
0b'00 Reserved
0b'01 Reserved
0b'10 Query command
0b'11 Reserved

529

Coprocessor services

The CCB submission type and address type for the CCB array must be provided in the flags argument.
All other fields are optional values which change the default behavior of the CCB processing.

When set to one, the "Disable ADI for VA reads" bit will turn off ADI checking when using a virtual
address to load data. ADI checking will still be done when loading real-addressed memory. This bit is only
available when using major version 2 of the coprocessor API group; at major version 1 it is reserved. For
more information about using ADI and DAX, see Section 36.2.1.1.7, “Application Data Integrity (ADI)”.

By default, all virtual addresses are treated as user addresses. If the virtual address translations are
privileged, they must be marked as such in the appropriate flags field. The virtual addresses used within
the submitted CCBs must all be translated with the same privilege level.

By default, all virtual addresses used within the submitted CCBs are translated using the primary context
active at the time of the submission. The address type field within a CCB allows each address to request
translation in an alternate address context. The address context used when the alternate address context is
requested is selected in the flags argument.

The all-or-nothing flag specifies whether the virtual machine should allow partial submissions of the
input CCB array. When using CCBs with serial-conditional flags, it is strongly recommended to use
the all-or-nothing flag to avoid broken conditional chains. Using long CCB chains on a machine under
high coprocessor load may make this impractical, however, and require submitting without the flag.
When submitting serial-conditional CCBs without the all-or-nothing flag, guest software must manually
implement the serial-conditional behavior at any point where the chain was not submitted in a single API
call, and resubmission of the remaining CCBs should clear any conditional flag that might be set in the
first remaining CCB. Failure to do so will produce indeterminate CCB execution status and ordering.

When the all-or-nothing flag is not specified, callers should check the value of length in ret1 to determine
how many CCBs from the array were successfully submitted. Any remaining CCBs can be resubmitted
without modifications.

The value of length in ret1 is also valid when the API call returns an error, and callers should always
check its value to determine which CCBs in the array were already processed. This will additionally
identify which CCB encountered the processing error, and was not submitted successfully.

If the queue info flag is used during submission, and at least one CCB was successfully submitted, the
length value in ret1 will be a multi-field value defined as follows:
Bits Field Description
[63:48] DAX unit instance identifier
[47:32] DAX queue instance identifier
[31:16] Reserved
[15:0] Number of CCB bytes successfully submitted

The value of status data depends on the status value. See error status code descriptions for details.
The value is undefined for status values that do not specifically list a value for the status data.

The API has a reserved input and output register which will be used in subsequent minor versions of this
API function. Guest software implementations should treat that register as voltile across the function call
in order to maintain forward compatibility.

36.3.1.1. Errors
EOK One or more CCBs have been accepted and enqueued in the virtual machine
and no errors were been encountered during submission. Some submitted
CCBs may not have been enqueued due to internal virtual machine limitations,
and may be resubmitted without changes.

530

Coprocessor services

EWOULDBLOCK An internal resource conflict within the virtual machine has prevented it from
being able to complete the CCB submissions sufficiently quickly, requiring
it to abandon processing before it was complete. Some CCBs may have been
successfully enqueued prior to the block, and all remaining CCBs may be
resubmitted without changes.
EBADALIGN CCB array is not on a 64-byte boundary, or the array length is not a multiple
of 64 bytes.
ENORADDR A real address used either for the CCB array, or within one of the submitted
CCBs, is not valid for the guest. Some CCBs may have been enqueued prior
to the error being detected.
ENOMAP A virtual address used either for the CCB array, or within one of the submitted
CCBs, could not be translated by the virtual machine using either the TLB
or TSB contents. The submission may be retried after adding the required
mapping, or by converting the virtual address into a real address. Due to the
shared nature of address translation resources, there is no theoretical limit on
the number of times the translation may fail, and it is recommended all guests
implement some real address based backup. The virtual address which failed
translation is returned as status data in ret2. Some CCBs may have been
enqueued prior to the error being detected.
EINVAL The virtual machine detected an invalid CCB during submission, or invalid
input arguments, such as bad flag values. Note that not all invalid CCB values
will be detected during submission, and some may be reported as errors in the
completion area instead. Some CCBs may have been enqueued prior to the
error being detected. This error may be returned if the CCB version is invalid.
ETOOMANY The request was submitted with the all-or-nothing flag set, and the array size is
greater than the virtual machine can support in a single request. The maximum
supported size for the current virtual machine can be queried by submitting a
request with a zero length array, as described above.
ENOACCESS The guest does not have permission to submit CCBs, or an address used in a
CCBs lacks sufficient permissions to perform the required operation (no write
permission on the destination buffer address, for example). A virtual address
which fails permission checking is returned as status data in ret2. Some
CCBs may have been enqueued prior to the error being detected.
EUNAVAILABLE The requested CCB operation could not be performed at this time. The
restricted operation availability may apply only to the first unsuccessfully
submitted CCB, or may apply to a larger scope. The status should not be
interpreted as permanent, and the guest should attempt to submit CCBs in
the future which had previously been unable to be performed. The status
data provides additional information about scope of the restricted availability
as follows:
Value Description
0 Processing for the exact CCB instance submitted was unavailable,
and it is recommended the guest emulate the operation. The
guest should continue to submit all other CCBs, and assume no
restrictions beyond this exact CCB instance.
1 Processing is unavailable for all CCBs using the requested opcode,
and it is recommended the guest emulate the operation. The
guest should continue to submit all other CCBs that use different
opcodes, but can expect continued rejections of CCBs using the
same opcode in the near future.

531

Coprocessor services

Value Description
2 Processing is unavailable for all CCBs using the requested CCB
version, and it is recommended the guest emulate the operation.
The guest should continue to submit all other CCBs that use
different CCB versions, but can expect continued rejections of
CCBs using the same CCB version in the near future.
3 Processing is unavailable for all CCBs on the submitting vcpu,
and it is recommended the guest emulate the operation or resubmit
the CCB on a different vcpu. The guest should continue to submit
CCBs on all other vcpus but can expect continued rejections of all
CCBs on this vcpu in the near future.
4 Processing is unavailable for all CCBs, and it is recommended
the guest emulate the operation. The guest should expect all CCB
submissions to be similarly rejected in the near future.

36.3.2. ccb_info

trap# FAST_TRAP
function# CCB_INFO
arg0 address
ret0 status
ret1 CCB state
ret2 position
ret3 dax
ret4 queue

Requests status information on a previously submitted CCB. The previously submitted CCB is identified
by the 64-byte aligned real address of the CCBs completion area.

A CCB can be in one of 4 states:

State Value Description
COMPLETED 0 The CCB has been fetched and executed, and is no longer active in
the virtual machine.
ENQUEUED 1 The requested CCB is current in a queue awaiting execution.
INPROGRESS 2 The CCB has been fetched and is currently being executed. It may still
be possible to stop the execution using the ccb_kill hypercall.
NOTFOUND 3 The CCB could not be located in the virtual machine, and does not
appear to have been executed. This may occur if the CCB was lost
due to a hardware error, or the CCB may not have been successfully
submitted to the virtual machine in the first place.

Implementation note
Some platforms may not be able to report CCBs that are currently being processed, and therefore
guest software should invoke the ccb_kill hypercall prior to assuming the request CCB will never
be executed because it was in the NOTFOUND state.

532

Coprocessor services

The position return value is only valid when the state is ENQUEUED. The value returned is the number
of other CCBs ahead of the requested CCB, to provide a relative estimate of when the CCB may execute.

The dax return value is only valid when the state is ENQUEUED. The value returned is the DAX unit
instance identifier for the DAX unit processing the queue where the requested CCB is located. The value
matches the value that would have been, or was, returned by ccb_submit using the queue info flag.

The queue return value is only valid when the state is ENQUEUED. The value returned is the DAX
queue instance identifier for the DAX unit processing the queue where the requested CCB is located. The
value matches the value that would have been, or was, returned by ccb_submit using the queue info flag.

36.3.2.1. Errors

EOK The request was processed and the CCB state is valid.
EBADALIGN address is not on a 64-byte aligned.
ENORADDR The real address provided for address is not valid.
EINVAL The CCB completion area contents are not valid.
EWOULDBLOCK Internal resource constraints prevented the CCB state from being queried at this
time. The guest should retry the request.
ENOACCESS The guest does not have permission to access the coprocessor virtual device
functionality.

36.3.3. ccb_kill

trap# FAST_TRAP
function# CCB_KILL
arg0 address
ret0 status
ret1 result

Request to stop execution of a previously submitted CCB. The previously submitted CCB is identified by
the 64-byte aligned real address of the CCBs completion area.

The kill attempt can produce one of several values in the result return value, reflecting the CCB state
and actions taken by the Hypervisor:

Result Value Description
COMPLETED 0 The CCB has been fetched and executed, and is no longer active in
the virtual machine. It could not be killed and no action was taken.
DEQUEUED 1 The requested CCB was still enqueued when the kill request was
submitted, and has been removed from the queue. Since the CCB
never began execution, no memory modifications were produced by
it, and the completion area will never be updated. The same CCB may
be submitted again, if desired, with no modifications required.
KILLED 2 The CCB had been fetched and was being executed when the kill
request was submitted. The CCB execution was stopped, and the CCB
is no longer active in the virtual machine. The CCB completion area
will reflect the killed status, with the subsequent implications that
partial results may have been produced. Partial results may include full

533

Coprocessor services

Result Value Description
command execution if the command was stopped just prior to writing
to the completion area.
NOTFOUND 3 The CCB could not be located in the virtual machine, and does not
appear to have been executed. This may occur if the CCB was lost
due to a hardware error, or the CCB may not have been successfully
submitted to the virtual machine in the first place. CCBs in the state
are guaranteed to never execute in the future unless resubmitted.

36.3.3.1. Interactions with Pipelined CCBs

If the pipeline target CCB is killed but the pipeline source CCB was skipped, the completion area of the
target CCB may contain status (4,0) "Command was skipped" instead of (3,7) "Command was killed".

If the pipeline source CCB is killed, the pipeline target CCB's completion status may read (1,0) "Success".
This does not mean the target CCB was processed; since the source CCB was killed, there was no
meaningful output on which the target CCB could operate.

36.3.3.2. Errors

EOK The request was processed and the result is valid.
EBADALIGN address is not on a 64-byte aligned.
ENORADDR The real address provided for address is not valid.
EINVAL The CCB completion area contents are not valid.
EWOULDBLOCK Internal resource constraints prevented the CCB from being killed at this time.
The guest should retry the request.
ENOACCESS The guest does not have permission to access the coprocessor virtual device
functionality.

36.3.4. dax_info
trap# FAST_TRAP
function# DAX_INFO
ret0 status
ret1 Number of enabled DAX units
ret2 Number of disabled DAX units

Returns the number of DAX units that are enabled for the calling guest to submit CCBs. The number of
DAX units that are disabled for the calling guest are also returned. A disabled DAX unit would have been
available for CCB submission to the calling guest had it not been offlined.

36.3.4.1. Errors

EOK The request was processed and the number of enabled/disabled DAX units
are valid.

534

Linux 内核

目录

本页

Oracle 数据分析加速器 (DAX)¶

高级概述¶

寻址内存¶

驱动程序 API¶

CCB_DEQUEUE¶

CCB_KILL¶

CCB_INFO¶

提交要执行的 CCB 数组¶

MMAP¶

请求完成¶

DAX 提交的应用程序生命周期¶

内存限制¶

CCB 结构¶

示例代码¶

内核示例¶

摘自 UltraSPARC 虚拟机规范¶