┌─────────────────────────────────────────────────────────────┐
│                    GP API Error Layer                      │  ← GP标准错误码
├─────────────────────────────────────────────────────────────┤
│                TEE Service Error Layer                     │  ← TEE内核错误处理
├─────────────────────────────────────────────────────────────┤
│              Storage Backend Error Layer                   │  ← 后端特定错误
├─────────────────────────────────────────────────────────────┤
│               Hash Tree Error Layer                        │  ← 完整性验证错误
├─────────────────────────────────────────────────────────────┤
│                 RPC Error Layer                           │  ← TEE-REE通信错误
├─────────────────────────────────────────────────────────────┤
│              Hardware Error Layer                          │  ← 硬件级错误处理
└─────────────────────────────────────────────────────────────┘

// 源文件: optee_os/core/tee/tee_svc_storage.c
TEE_Result TEE_CreatePersistentObject()
{
    // 1. 参数验证
    if (!objectID || objectIDLen == 0)
        return TEE_ERROR_BAD_PARAMETERS;
    
    // 2. 存储可用性检查
    if (!storage_backend_available())
        return TEE_ERROR_STORAGE_NOT_AVAILABLE;
    
    // 3. 空间检查
    if (!check_storage_space(initialDataLen))
        return TEE_ERROR_STORAGE_NO_SPACE;
    
    // 4. 权限检查
    if (!check_access_rights(flags))
        return TEE_ERROR_ACCESS_DENIED;
    
    // 5. 重复性检查
    if (object_exists(objectID))
        return TEE_ERROR_ACCESS_CONFLICT;
    
    // 6. 实际创建操作
    res = create_persistent_object(...);
    if (res != TEE_SUCCESS) {
        // 清理已分配的资源
        cleanup_partial_object();
        return res;
    }
    
    return TEE_SUCCESS;
}

// 对象完整性验证和错误恢复
TEE_Result read_persistent_object()
{
    // 1. 哈希树验证
    res = verify_hash_tree();
    if (res == TEE_ERROR_CORRUPT_OBJECT) {
        // 尝试从备份版本恢复
        res = recover_from_backup_version();
        if (res != TEE_SUCCESS)
            return TEE_ERROR_CORRUPT_OBJECT_2;
    }
    
    // 2. 解密验证
    res = decrypt_and_verify();
    if (res != TEE_SUCCESS) {
        return TEE_ERROR_CORRUPT_OBJECT;
    }
    
    return TEE_SUCCESS;
}

// 内核错误到GP错误的转换
static TEE_Result convert_kernel_error(TEE_Result kernel_res)
{
    switch (kernel_res) {
    case TEE_ERROR_FS_NO_SPACE:
        return TEE_ERROR_STORAGE_NO_SPACE;
    case TEE_ERROR_FS_NOT_AVAILABLE:
        return TEE_ERROR_STORAGE_NOT_AVAILABLE;
    case TEE_ERROR_FS_CORRUPTED:
        return TEE_ERROR_CORRUPT_OBJECT;
    default:
        return kernel_res;
    }
}

// 错误时的资源清理
static void cleanup_storage_operation(struct tee_pobj *po)
{
    if (po) {
        // 1. 释放文件句柄
        if (po->fh)
            tee_file_ops->close(&po->fh);
        
        // 2. 清除缓存
        clear_object_cache(po);
        
        // 3. 释放内存
        free(po);
        
        // 4. 更新引用计数
        decrement_ref_count();
    }
}

// COW操作失败时的回滚机制
static TEE_Result cow_error_recovery(struct ree_fs_file *f)
{
    // 1. 恢复到原始版本
    if (f->backup_version) {
        restore_from_backup(f);
    }
    
    // 2. 清理临时文件
    cleanup_temp_files(f);
    
    // 3. 重置文件状态
    reset_file_state(f);
    
    return TEE_SUCCESS;
}

// 块级读写错误处理
static TEE_Result handle_block_error(struct ree_fs_file *f, 
                                    size_t block_num, 
                                    TEE_Result error)
{
    switch (error) {
    case TEE_ERROR_COMMUNICATION:
        // RPC通信错误，重试
        return retry_block_operation(f, block_num);
    
    case TEE_ERROR_CORRUPT_OBJECT:
        // 数据损坏，尝试从哈希树恢复
        return recover_block_from_htree(f, block_num);
    
    case TEE_ERROR_STORAGE_NO_SPACE:
        // 空间不足，触发垃圾回收
        gc_trigger();
        return TEE_ERROR_STORAGE_NO_SPACE;
    
    default:
        return error;
    }
}

// RPMB写入失败恢复
static TEE_Result rpmb_write_error_recovery(void)
{
    // 1. 检查写计数器状态
    res = check_write_counter();
    if (res != TEE_SUCCESS) {
        // 写计数器异常，系统严重错误
        return TEE_ERROR_STORAGE_NOT_AVAILABLE;
    }
    
    // 2. 验证RPMB认证
    res = verify_rpmb_auth();
    if (res != TEE_SUCCESS) {
        // 认证失败，安全威胁
        return TEE_ERROR_SECURITY;
    }
    
    // 3. 重试写入操作
    return retry_rpmb_write();
}

// FAT表损坏时的恢复机制
static TEE_Result recover_fat_table(void)
{
    // 1. 扫描所有RPMB块
    scan_all_rpmb_blocks();
    
    // 2. 重建FAT表
    rebuild_fat_from_blocks();
    
    // 3. 验证重建的FAT表
    if (!verify_rebuilt_fat()) {
        // 无法恢复，格式化RPMB
        return format_rpmb_filesystem();
    }
    
    return TEE_SUCCESS;
}

// 哈希验证失败时的处理
static TEE_Result handle_hash_mismatch(struct tee_fs_htree *ht, 
                                      size_t node_id)
{
    // 1. 检查是否是叶子节点
    if (is_leaf_node(node_id)) {
        // 数据块损坏，标记为坏块
        mark_bad_block(ht, node_id);
        return TEE_ERROR_CORRUPT_OBJECT;
    }
    
    // 2. 内部节点损坏，尝试重建
    res = rebuild_internal_node(ht, node_id);
    if (res != TEE_SUCCESS) {
        // 无法重建，整个树损坏
        return TEE_ERROR_CORRUPT_OBJECT_2;
    }
    
    return TEE_SUCCESS;
}

// 原子更新失败时的回滚
static TEE_Result rollback_htree_update(struct tee_fs_htree *ht)
{
    // 1. 恢复到上一个稳定版本
    restore_previous_version(ht);
    
    // 2. 清理临时哈希节点
    cleanup_temp_hash_nodes(ht);
    
    // 3. 重置更新状态
    reset_update_state(ht);
    
    return TEE_SUCCESS;
}

// RPC操作超时处理
static TEE_Result handle_rpc_timeout(uint32_t cmd)
{
    // 1. 检查REE状态
    if (!ree_available()) {
        return TEE_ERROR_COMMUNICATION;
    }
    
    // 2. 重试操作
    for (int retry = 0; retry < MAX_RPC_RETRIES; retry++) {
        res = send_rpc_command(cmd);
        if (res == TEE_SUCCESS)
            return TEE_SUCCESS;
        
        // 指数退避重试
        msleep(RETRY_DELAY_MS << retry);
    }
    
    return TEE_ERROR_COMMUNICATION;
}

// RPC数据完整性验证
static TEE_Result verify_rpc_data_integrity(void *data, size_t len)
{
    // 1. 计算数据校验和
    uint32_t checksum = calculate_checksum(data, len);
    
    // 2. 与预期值比较
    if (checksum != expected_checksum) {
        // 数据损坏，请求重传
        request_retransmission();
        return TEE_ERROR_CORRUPT_OBJECT;
    }
    
    return TEE_SUCCESS;
}

// 内存不足时的处理策略
static TEE_Result handle_memory_shortage(size_t required_size)
{
    // 1. 尝试释放缓存
    free_storage_cache();
    
    // 2. 触发垃圾回收
    garbage_collect();
    
    // 3. 再次尝试分配
    void *ptr = malloc(required_size);
    if (!ptr) {
        // 仍然失败，降级服务
        return TEE_ERROR_OUT_OF_MEMORY;
    }
    
    return TEE_SUCCESS;
}

// 存储系统错误注入测试
static void test_storage_error_injection(void)
{
    // 1. 注入空间不足错误
    inject_storage_full_error();
    res = TEE_CreatePersistentObject(...);
    assert(res == TEE_ERROR_STORAGE_NO_SPACE);
    
    // 2. 注入数据损坏错误
    inject_corruption_error();
    res = TEE_ReadObjectData(...);
    assert(res == TEE_ERROR_CORRUPT_OBJECT);
    
    // 3. 注入通信错误
    inject_rpc_error();
    res = TEE_WriteObjectData(...);
    assert(res == TEE_ERROR_COMMUNICATION);
}

// 错误恢复性能基准测试
static void benchmark_error_recovery(void)
{
    // 测试各种错误场景的恢复时间
    measure_recovery_time(CORRUPTION_ERROR);
    measure_recovery_time(COMMUNICATION_ERROR);
    measure_recovery_time(MEMORY_ERROR);
}