// An authentication tag pointer is required by HW to be 16-bytes aligned. // 硬件要求认证标签指针必须 16 字节对齐。 #define UVM_CONF_COMPUTING_AUTH_TAG_ALIGNMENT 16
// An IV pointer is required by HW to be 16-bytes aligned. // HW 要求 IV 指针为 16 字节对齐。 // // Use sizeof(UvmCslIv) to refer to the IV size. // 使用 sizeof(UvmCslIv) 来引用 IV 大小。 #define UVM_CONF_COMPUTING_IV_ALIGNMENT 16
// SEC2 decrypt operation buffers are required to be 16-bytes aligned. CE // encrypt/decrypt can be unaligned if the buffer lies in a single 32B segment. // Otherwise, they need to be 32B aligned. // SEC2 解密操作缓冲区需要 16 字节对齐。如果缓冲区位于单个 32B 段中，则 CE 加密/解密可以 // 不对齐。否则，它们需要 32B 对齐。 #define UVM_CONF_COMPUTING_BUF_ALIGNMENT 32
// SEC2 supports at most a stream of 64 entries in the method stream for // signing. Each entry is made of the method address and method data, therefore // the maximum buffer size is: UVM_METHOD_SIZE * 2 * 64 = 512. // UVM, however, won't use this amount of entries, in the worst case scenario, // we push a semaphore_releases or a decrypt. A SEC2 semaphore_release uses 6 1U // entries, whereas a SEC2 decrypt uses 10 1U entries. For 10 entries, // UVM_METHOD_SIZE * 2 * 10 = 80. // SEC2 最多支持 64 个方法流条目进行签名。每个条目由方法地址和方法数据组成，因此最大缓冲区 // 大小为：UVM_METHOD_SIZE * 2 * 64 = 512。但是 UVM 不会使用这么多条目，在最坏的情况下， // 我们会推送一个 semaphore_releases 或一个解密。SEC2 semaphore_release 使用 6 个 // 1U 条目，而 SEC2 解密使用 10 个 1U 条目。对于 10 个条目，UVM_METHOD_SIZE * 2 * 10 = 80。 #define UVM_CONF_COMPUTING_SIGN_BUF_MAX_SIZE 80
// All GPUs derive confidential computing status from their parent. // By current policy all parent GPUs have identical confidential // computing status. // 所有 GPU 都从其父 GPU 获得机密计算状态。根据当前政策，所有父 GPU 都具有相同的机密计算状态。 NV_STATUS uvm_conf_computing_init_parent_gpu(constuvm_parent_gpu_t *parent); booluvm_conf_computing_mode_enabled_parent(constuvm_parent_gpu_t *parent); booluvm_conf_computing_mode_enabled(constuvm_gpu_t *gpu); booluvm_conf_computing_mode_is_hcc(constuvm_gpu_t *gpu);
typedefstruct { // List of free DMA buffers (uvm_conf_computing_dma_buffer_t). // A free DMA buffer can be grabbed anytime, though the tracker // inside it may still have pending work. // 空闲 DMA 缓冲区列表（uvm_conf_computing_dma_buffer_t）。空闲的 DMA 缓冲区可以随时获取，但其中的跟踪器可能仍有待处理的工作。 structlist_headfree_dma_buffers;
// Used to grow the pool when full. // 用于在池满时增大池子。 size_t num_dma_buffers;
// Used internally by the pool management code to track the state of // a free buffer. // 由池管理代码内部使用，以跟踪空闲缓冲区的状态。 uvm_tracker_t tracker;
// When the DMA buffer is used as the destination of a GPU encryption, SEC2 // writes the authentication tag here. Later when the buffer is decrypted // on the CPU the authentication tag is used again (read) for CSL to verify // the authenticity. The allocation is big enough for one authentication // tag per PAGE_SIZE page in the alloc buffer. // 当 DMA 缓冲区用作 GPU 加密的目标时，SEC2 会在此处写入身份验证标签。稍后，当缓冲区 // 在 CPU 上解密时，身份验证标签将再次用于（读取）CSL 以验证真实性。分配缓冲区中每个 // PAGE_SIZE 页的分配足够大，可以容纳一个身份验证标签。 uvm_mem_t *auth_tag;
// CSL supports out-of-order decryption, the decrypt IV is used similarly // to the authentication tag. The allocation is big enough for one IV per // PAGE_SIZE page in the alloc buffer. The granularity between the decrypt // IV and authentication tag must match. // CSL 支持无序解密，解密 IV 的使用方式与身份验证标签类似。分配缓冲区中每个 PAGE_SIZE // 页的分配足够大，可以容纳一个 IV。解密 IV 和身份验证标签之间的粒度必须匹配。 UvmCslIv decrypt_iv[(UVM_CONF_COMPUTING_DMA_BUFFER_SIZE / PAGE_SIZE)];
// Retrieve a DMA buffer from the given DMA allocation pool. // NV_OK Stage buffer successfully retrieved // NV_ERR_NO_MEMORY No free DMA buffers are available for grab, and // expanding the memory pool to get new ones failed. // // out_dma_buffer is only valid if NV_OK is returned. The caller is responsible // for calling uvm_conf_computing_dma_buffer_free once the operations on this // buffer are done. // When out_tracker is passed to the function, the buffer's dependencies are // added to the tracker. The caller is guaranteed that all pending tracker // entries come from the same GPU as the pool's owner. Before being able to use // the DMA buffer, the caller is responsible for either acquiring or waiting // on out_tracker. If out_tracker is NULL, the wait happens in the allocation // itself. // Upon success the encrypted_page_mask is cleared as part of the allocation. // 从给定的 DMA 分配池中检索 DMA 缓冲区。 // NV_OK 阶段缓冲区已成功检索 // NV_ERR_NO_MEMORY 没有可供抓取的空闲 DMA 缓冲区，扩展内存池以获取新缓冲区失败。 // // out_dma_buffer 仅在返回 NV_OK 时才有效。调用者负责在完成此缓冲区上的操作后调用 // uvm_conf_computing_dma_buffer_free。 // 当 out_tracker 传递给函数时，缓冲区的依赖项将添加到跟踪器。调用者保证所有待处理的跟踪 // 器条目都来自与池所有者相同的 GPU。在能够使用 DMA 缓冲区之前，调用者负责获取或等待 // out_tracker。如果 out_tracker 为 NULL，则等待发生在分配本身中。 // 成功后，encrypted_page_mask 将作为分配的一部分被清除。 NV_STATUS uvm_conf_computing_dma_buffer_alloc(uvm_conf_computing_dma_buffer_pool_t *dma_buffer_pool, uvm_conf_computing_dma_buffer_t **out_dma_buffer, uvm_tracker_t *out_tracker);
// Free a DMA buffer to the DMA allocation pool. All DMA buffers must be freed // prior to GPU deinit. // // The tracker is optional and a NULL tracker indicates that no new operation // has been pushed for the buffer. A non-NULL tracker indicates any additional // pending operations on the buffer pushed by the caller that need to be // synchronized before freeing or re-using the buffer. // 将 DMA 缓冲区释放到 DMA 分配池。在 GPU 取消初始化之前，必须释放所有 DMA 缓冲区。 // // 跟踪器是可选的，NULL 跟踪器表示尚未为缓冲区推送任何新操作。非 NULL 跟踪器表示调用者推送 // 的缓冲区上任何其他待处理操作，这些操作需要在释放或重新使用缓冲区之前进行同步。 voiduvm_conf_computing_dma_buffer_free(uvm_conf_computing_dma_buffer_pool_t *dma_buffer_pool, uvm_conf_computing_dma_buffer_t *dma_buffer, uvm_tracker_t *tracker);
// Synchronize trackers in all entries in the GPU's DMA pool // 同步 GPU 的 DMA 池中的所有条目中的跟踪器 voiduvm_conf_computing_dma_buffer_pool_sync(uvm_conf_computing_dma_buffer_pool_t *dma_buffer_pool);
// Initialization and deinitialization of Confidential Computing data structures // for the given GPU. // 初始化和取消初始化给定 GPU 的机密计算数据结构。 NV_STATUS uvm_conf_computing_gpu_init(uvm_gpu_t *gpu); voiduvm_conf_computing_gpu_deinit(uvm_gpu_t *gpu);
// Logs encryption information from the GPU and returns the IV. // 记录来自 GPU 的加密信息并返回 IV。 voiduvm_conf_computing_log_gpu_encryption(uvm_channel_t *channel, UvmCslIv *iv);
// Acquires next CPU encryption IV and returns it. // 获取下一个CPU加密IV并返回。 voiduvm_conf_computing_acquire_encryption_iv(uvm_channel_t *channel, UvmCslIv *iv);
// CPU side encryption helper with explicit IV, which is obtained from // uvm_conf_computing_acquire_encryption_iv. Without an explicit IV // the function uses the next IV in order. Encrypts data in src_plain and // write the cipher text in dst_cipher. src_plain and dst_cipher can't overlap. // The IV is invalidated and can't be used again after this operation. // CPU 端加密辅助程序，具有显式 IV，可从 uvm_conf_computing_acquire_encryption_iv 获取。 // 如果没有显式 IV，该函数将按顺序使用下一个 IV。加密 src_plain 中的数据并将密文写入 // dst_cipher。src_plain 和 dst_cipher 不能重叠。此操作后，IV 无效，无法再次使用。 voiduvm_conf_computing_cpu_encrypt(uvm_channel_t *channel, void *dst_cipher, constvoid *src_plain, UvmCslIv *encrypt_iv, size_t size, void *auth_tag_buffer) { NV_STATUS status;
// nvUvmInterfaceCslEncrypt fails when a 64-bit encryption counter // overflows. This is not supposed to happen on CC. UVM_ASSERT(status == NV_OK); }
// CPU side decryption helper. Decrypts data from src_cipher and writes the // plain text in dst_plain. src_cipher and dst_plain can't overlap. IV obtained // from uvm_conf_computing_log_gpu_encryption() needs to be be passed to src_iv. // CPU 端解密助手。从 src_cipher 解密数据并将纯文本写入 dst_plain。src_cipher 和 // dst_plain 不能重叠。从 uvm_conf_computing_log_gpu_encryption() 获得的 IV 需要传递给 src_iv。 NV_STATUS uvm_conf_computing_cpu_decrypt(uvm_channel_t *channel, void *dst_plain, constvoid *src_cipher, const UvmCslIv *src_iv, size_t size, constvoid *auth_tag_buffer) { NV_STATUS status;
// // Add the conditions to exclude these macros from Orin build, as CONFIDENTIAL_COMPUTE // is a guardword. The #if could be removed when nvRmReg.h file is trimmed from Orin build. // // Enable Disable Confidential Compute and control its various modes of operation // 0 - Feature Disable // 1 - Feature Enable // // 添加条件以从 Orin 构建中排除这些宏，因为 CONFIDENTIAL_COMPUTE 是一个保护字。当从 Orin 构建中修剪 nvRmReg.h 文件时，可以删除 #if。 // // 启用禁用机密计算并控制其各种操作模式 // 0 - 功能禁用 // 1 - 功能启用 #define NV_REG_STR_RM_CONFIDENTIAL_COMPUTE "RmConfidentialCompute" #define NV_REG_STR_RM_CONFIDENTIAL_COMPUTE_ENABLED 0:0 #define NV_REG_STR_RM_CONFIDENTIAL_COMPUTE_ENABLED_NO 0x00000000 #define NV_REG_STR_RM_CONFIDENTIAL_COMPUTE_ENABLED_YES 0x00000001 #define NV_REG_STR_RM_CONFIDENTIAL_COMPUTE_DEV_MODE_ENABLED 1:1 #define NV_REG_STR_RM_CONFIDENTIAL_COMPUTE_DEV_MODE_ENABLED_NO 0x00000000 #define NV_REG_STR_RM_CONFIDENTIAL_COMPUTE_DEV_MODE_ENABLED_YES 0x00000001 #define NV_REG_STR_RM_CONFIDENTIAL_COMPUTE_GPUS_READY_CHECK 2:2 #define NV_REG_STR_RM_CONFIDENTIAL_COMPUTE_GPUS_READY_CHECK_DISABLED 0x00000000 #define NV_REG_STR_RM_CONFIDENTIAL_COMPUTE_GPUS_READY_CHECK_ENABLED 0x00000001
// Encrypts the contents of the source buffer into the destination buffer, up to // the given size. The authentication tag of the encrypted contents is written // to auth_tag, so it can be verified later on by a decrypt operation. // // The addressing modes of the destination and authentication tag addresses // should match. If the addressing mode is physical, then the address apertures // should also match. typedefvoid(*uvm_hal_ce_encrypt_t)(uvm_push_t *push, uvm_gpu_address_t dst, uvm_gpu_address_t src, NvU32 size, uvm_gpu_address_t auth_tag);
// Decrypts the contents of the source buffer into the destination buffer, up to // the given size. The method also verifies the integrity of the encrypted // buffer by calculating its authentication tag, and comparing it with the one // provided as argument. // // The addressing modes of the source and authentication tag addresses should // match. If the addressing mode is physical, then the address apertures should // also match. typedefvoid(*uvm_hal_ce_decrypt_t)(uvm_push_t *push, uvm_gpu_address_t dst, uvm_gpu_address_t src, NvU32 size, uvm_gpu_address_t auth_tag);
typedefstruct { // id is either a hardware class or GPU architecture NvU32 id; NvU32 parent_id; union { // host_ops: id is a hardware class uvm_host_hal_t host_ops;
// ce_ops: id is a hardware class uvm_ce_hal_t ce_ops;
// arch_ops: id is an architecture uvm_arch_hal_t arch_ops;
// fault_buffer_ops: id is an architecture uvm_fault_buffer_hal_t fault_buffer_ops;
// access_counter_buffer_ops: id is an architecture uvm_access_counter_buffer_hal_t access_counter_buffer_ops;
// sec2_ops: id is an architecture uvm_sec2_hal_t sec2_ops; } u; } uvm_hal_class_ops_t;
// Table for copy engine functions. // Each entry is associated with a copy engine class through the 'class' field. // By setting the 'parent_class' field, a class will inherit the parent class's // functions for any fields left NULL when uvm_hal_init_table() runs upon module // load. The parent class must appear earlier in the array than the child. staticuvm_hal_class_ops_t ce_table[] = { { .id = MAXWELL_DMA_COPY_A, .u.ce_ops = { // ... .encrypt = uvm_hal_maxwell_ce_encrypt_unsupported, .decrypt = uvm_hal_maxwell_ce_decrypt_unsupported, } }, // ... { .id = HOPPER_DMA_COPY_A, .parent_id = AMPERE_DMA_COPY_B, .u.ce_ops = { // ... .memcopy_copy_type = uvm_hal_hopper_ce_memcopy_copy_type, // ... .encrypt = uvm_hal_hopper_ce_encrypt, .decrypt = uvm_hal_hopper_ce_decrypt, }, }, };
C program
uvm_gpu.c: uvm_ioctl
kernel-open/nvidia-uvm/uvm_gpu.c
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
uvm_ioctl() --> UVM_ROUTE_CMD_STACK_INIT_CHECK(UVM_REGISTER_GPU, uvm_api_register_gpu); --> uvm_va_space_register_gpu() --> uvm_gpu_retain_by_uuid() --> gpu_retain_by_uuid_locked() --> add_gpu() --> init_gpu() --> status = uvm_conf_computing_gpu_init(gpu); // Initialization and deinitialization of Confidential Computing data structures // for the given GPU. if (status != NV_OK) { UVM_ERR_PRINT("Failed to initialize Confidential Compute: %s for GPU %s\n", nvstatusToString(status), uvm_gpu_name(gpu)); return status; }
函数 conf_computing_copy_pages_finish 负责完成 GPU 到 CPU 的页面复制操作，并在 CPU 端解密这些数据。通过初始化变量和验证参数，函数确保数据传输和加密操作的正确性。遍历加密页面掩码中的每个页面，逐页解密数据，并处理可能出现的错误。在完成所有页面的处理后，函数返回成功状态。
encrypted_memcopy_cpu_to_gpu
这个函数 encrypted_memcopy_gpu_to_cpu 实现了在 GPU 和 CPU 之间进行同步加密复制的操作。它通过 GPU 端的加密（使用复制引擎）和 CPU 端的解密，将 GPU 上的数据传输到 CPU，最终在目标 CPU 缓冲区中得到解密后的明文数据。以下是对这段代码的详细分析：