┌─────────────────────────────────────────────────────────────┐
│               GP Internal API (TEE_*Object)                │  ← TA应用层接口
│  • 对象生命周期管理  • 属性系统  • 数据流操作               │
├─────────────────────────────────────────────────────────────┤
│            TEE Storage Service Layer                       │  ← 系统调用转换层
│  • syscall_storage_*()  • 对象句柄管理  • 权限验证        │
├─────────────────────────────────────────────────────────────┤
│              Object Management Layer                       │  ← 对象管理层
│  ┌────────────────┐  ┌─────────────────────────────────────┐│
│  │  tee_obj       │  │         tee_pobj                   ││  ← 对象抽象
│  │ (瞬态对象)      │  │       (持久化对象)                  ││
│  └────────────────┘  └─────────────────────────────────────┘│
├─────────────────────────────────────────────────────────────┤
│              Storage Backend Abstraction                   │  ← 后端抽象层
│  • tee_file_operations  • 统一文件接口  • 后端路由          │
├─────────────────────────────────────────────────────────────┤
│               Concrete Storage Backends                    │  ← 具体后端实现
│  ┌──────────────┐           ┌──────────────────────────────┐ │
│  │   REE FS     │           │        RPMB FS              │ │
│  │ • 写时复制    │           │ • 硬件防重放                 │ │
│  │ • 块级加密    │           │ • FAT文件系统                │ │
│  │ • 哈希树完整性 │           │ • 缓存优化                  │ │
│  └──────────────┘           └──────────────────────────────┘ │
├─────────────────────────────────────────────────────────────┤
│         Cryptographic Security Layer                       │  ← 密码学安全层
│  • 四层密钥体系  • ESSIV加密模式  • 完整性哈希树            │
├─────────────────────────────────────────────────────────────┤
│               RPC Communication Layer                      │  ← TEE-REE通信层
│  • 零拷贝传输  • 错误重试  • 超时处理                      │
├─────────────────────────────────────────────────────────────┤
│            Hardware Storage Layer                          │  ← 硬件存储层
│  ┌──────────────┐           ┌──────────────────────────────┐ │
│  │ REE文件系统   │           │        eMMC RPMB            │ │
│  │ (ext4/f2fs)  │           │      (硬件保护分区)           │ │
│  └──────────────┘           └──────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘

struct tee_pobj {
    TAILQ_ENTRY(tee_pobj) link;     // 全局对象链表
    uint32_t refcnt;                // 原子引用计数
    TEE_UUID uuid;                  // TA身份标识
    uint32_t flags;                 // 访问标志位图
    bool creating;                  // 创建状态原子标志
    const struct tee_file_operations *fops; // 后端操作表
};

struct ree_fs_file {
    struct mutex mu;                    // 文件级互斥锁
    struct tee_fs_htree ht;            // 哈希树状态
    struct ree_fs_file_meta meta;      // 加密元数据
    bool meta_dirty;                   // 元数据脏标志
    struct tee_fs_file_info info;      // 文件系统信息
};

struct ree_fs_file_meta {
    size_t length;                     // 逻辑文件长度
    uint32_t backup_version_table[NUM_BLOCKS_PER_FILE]; // 版本表
};

static TEE_Result out_of_place_write(struct tee_fs_fd *fdp, size_t pos,
                                     const void *buf, size_t len)
{
    size_t start_block_num = pos_to_block_num(pos);
    size_t end_block_num = pos_to_block_num(pos + len - 1);
    
    for (size_t bn = start_block_num; bn <= end_block_num; bn++) {
        // 1. 读取原块内容（如果存在）
        if (bn * BLOCK_SIZE < ROUNDUP(fdp->meta.length, BLOCK_SIZE)) {
            res = tee_fs_htree_read_block(&fdp->ht, bn, block);
        }
        
        // 2. 修改块内容
        size_t offset = (bn == start_block_num) ? (pos % BLOCK_SIZE) : 0;
        size_t size = MIN(len - written, BLOCK_SIZE - offset);
        memcpy(block + offset, (uint8_t *)buf + written, size);
        
        // 3. 写入新块（COW）- 原子操作
        res = tee_fs_htree_write_block(&fdp->ht, bn, block);
        if (res != TEE_SUCCESS) {
            // 写入失败，自动回滚到原始状态
            tee_fs_htree_rollback(&fdp->ht);
            return res;
        }
    }
    
    // 4. 原子提交所有更改
    return tee_fs_htree_sync_to_storage(&fdp->ht);
}

enum rpmb_state {
    RPMB_STATE_IDLE,               // 空闲状态
    RPMB_STATE_WR_CNT,            // 获取写计数器
    RPMB_STATE_WRITE_DATA,        // 写入数据
    RPMB_STATE_GET_WR_CNT,        // 确认写计数器
    RPMB_STATE_READ_DATA,         // 读取数据
};

struct rpmb_req {
    uint16_t msg_type;            // 消息类型
    uint16_t *req_resp_code;      // 请求/响应码  
    uint16_t blk_cnt;            // 块计数
    uint16_t addr;               // 地址
    uint32_t write_counter;       // 写计数器
    uint8_t *key_mac;            // 密钥MAC
    uint8_t *data;               // 数据缓冲区
    uint8_t *nonce;              // 随机数
    uint8_t *data_frame;         // 数据帧
};

#define RPMB_CACHE_MAX_ENTRIES  16
#define RPMB_CACHE_LINE_SIZE    256

struct rpmb_cache_entry {
    struct mutex lock;            // 条目级锁
    bool valid;                  // 有效标志
    bool dirty;                  // 脏数据标志
    uint16_t addr;               // RPMB地址
    uint64_t access_time;        // 访问时间戳
    uint8_t data[RPMB_CACHE_LINE_SIZE]; // 缓存数据
    struct condvar write_complete; // 写完成信号
};

static struct {
    struct mutex cache_lock;      // 全局缓存锁
    struct rpmb_cache_entry entries[RPMB_CACHE_MAX_ENTRIES];
    uint32_t lru_counter;        // LRU计数器
    size_t hit_count;           // 命中统计
    size_t miss_count;          // 未命中统计
} rpmb_cache_ctx;

static bool tee_rpmb_write_is_atomic(uint32_t addr, uint32_t len)
{
    uint8_t byte_offset = addr % RPMB_DATA_SIZE;
    uint16_t blkcnt = ROUNDUP_DIV(len + byte_offset, RPMB_DATA_SIZE);
    
    // 检查是否在可靠写入块计数范围内
    return (blkcnt <= rpmb_ctx->rel_wr_blkcnt);
}

// HUK (Hardware Unique Key) - 设备根密钥
static TEE_Result get_huk(uint8_t huk[HUK_SIZE])
{
    return tee_otp_get_hw_unique_key(huk, HUK_SIZE);
}

// SSK (Secure Storage Key) - 存储系统密钥
static TEE_Result derive_ssk(uint8_t ssk[TEE_FS_KM_SSK_SIZE])
{
    const uint8_t key_label[] = "STORAGE_KEY";
    return huk_subkey_derive(HUK_SUBKEY_SSK, key_label, 
                           sizeof(key_label) - 1, ssk, TEE_FS_KM_SSK_SIZE);
}

// TSK (Trusted App Storage Key) - TA专用密钥
static TEE_Result derive_tsk(const TEE_UUID *uuid, uint8_t tsk[TEE_FS_KM_TSK_SIZE])
{
    return do_hmac(tsk, TEE_FS_KM_TSK_SIZE, 
                   tee_fs_ssk.key, TEE_FS_KM_SSK_SIZE,
                   uuid, sizeof(*uuid));
}

// FEK (File Encryption Key) - 文件加密密钥
static TEE_Result encrypt_fek(const TEE_UUID *uuid, const uint8_t *in_key,
                             uint8_t *out_key, size_t size)
{
    uint8_t tsk[TEE_FS_KM_TSK_SIZE];
    res = derive_tsk(uuid, tsk);
    
    // FEK_encrypted = AES-ECB(TSK, FEK_plaintext)
    return aes_ecb_encrypt(tsk, in_key, out_key, size);
}

static TEE_Result do_essiv(uint8_t iv[TEE_AES_BLOCK_SIZE],
                          const uint8_t fek[TEE_FS_KM_FEK_SIZE],
                          uint16_t blk_idx)
{
    uint8_t essiv_key[TEE_AES_BLOCK_SIZE];
    uint8_t sector_id[TEE_AES_BLOCK_SIZE] = { 0 };
    
    // 1. ESSIV密钥派生: ESSIV_KEY = SHA256(FEK)[0:16]
    res = hash_sha256(essiv_key, sizeof(essiv_key), fek, TEE_FS_KM_FEK_SIZE);
    
    // 2. 扇区ID编码 (little-endian)
    sector_id[0] = blk_idx & 0xFF;
    sector_id[1] = (blk_idx >> 8) & 0xFF;
    
    // 3. IV生成: IV = AES-ECB(ESSIV_KEY, SECTOR_ID)
    return aes_ecb_encrypt_block(essiv_key, sector_id, iv);
}

struct tee_fs_htree_node_image {
    uint8_t hash[TEE_FS_HTREE_HASH_SIZE];    // SHA-256哈希值
    uint8_t iv[TEE_FS_HTREE_IV_SIZE];        // AES-GCM IV (96位)
    uint8_t tag[TEE_FS_HTREE_TAG_SIZE];      // AES-GCM认证标签
    uint16_t flags;                          // 版本控制标志
    uint8_t pad[TEE_FS_HTREE_NODE_SIZE - 
               (TEE_FS_HTREE_HASH_SIZE + TEE_FS_HTREE_IV_SIZE + 
                TEE_FS_HTREE_TAG_SIZE + sizeof(uint16_t))]; // 填充对齐
};

#define HTREE_NODE_COMMITTED_BLOCK     BIT32(0)
#define HTREE_NODE_COMMITTED_CHILD(n)  BIT32(1 + (n))

static TEE_Result htree_atomic_begin(struct tee_fs_htree *ht)
{
    // 1. 记录当前版本号
    ht->update_version = ht->committed_version;
    
    // 2. 创建更新上下文
    ht->update_nodes = calloc(ht->node_count, sizeof(struct htree_update_node));
    
    // 3. 标记更新开始
    ht->update_in_progress = true;
    
    return TEE_SUCCESS;
}

static TEE_Result htree_atomic_commit(struct tee_fs_htree *ht)
{
    // 1. 自底向上更新哈希值
    for (int level = ht->max_level; level >= 0; level--) {
        for (size_t idx = 0; idx < nodes_per_level[level]; idx++) {
            res = update_node_hash(ht, level, idx);
            if (res != TEE_SUCCESS) {
                htree_atomic_rollback(ht);
                return res;
            }
        }
    }
    
    // 2. 原子切换版本标志
    ht->root_node.flags ^= HTREE_NODE_COMMITTED_BLOCK;
    
    // 3. 提交到存储
    res = write_root_node_atomic(ht);
    if (res == TEE_SUCCESS) {
        ht->committed_version = ht->update_version;
        ht->update_in_progress = false;
    }
    
    return res;
}

struct rpmb_data_frame {
    uint8_t stuff[196];              // 填充数据
    uint8_t key_mac[32];            // HMAC-SHA256认证码
    uint8_t data[256];              // 用户数据
    uint8_t nonce[16];              // 随机数
    uint32_t write_counter;         // 单调递增计数器
    uint16_t address;               // 块地址
    uint16_t block_count;           // 块计数
    uint16_t result;                // 操作结果
    uint16_t req_resp;              // 请求/响应类型
};

static TEE_Result rpmb_hmac_verify(struct rpmb_data_frame *frame)
{
    uint8_t calculated_mac[32];
    
    // 1. 计算整个帧的HMAC (除key_mac字段外)
    res = hmac_sha256(calculated_mac, rpmb_key, 32,
                     &frame->data, sizeof(*frame) - 32);
    
    // 2. 常量时间比较MAC
    return crypto_memneq(calculated_mac, frame->key_mac, 32) ? 
           TEE_ERROR_MAC_INVALID : TEE_SUCCESS;
}

static TEE_Result rpmb_verify_write_counter(uint32_t expected_counter,
                                          uint32_t received_counter)
{
    // 写计数器必须单调递增
    if (received_counter <= expected_counter) {
        return TEE_ERROR_STORAGE_NOT_AVAILABLE;
    }
    
    return TEE_SUCCESS;
}

/data/tee/                           ← REE存储根目录
├── [TA_UUID_32_chars]/              ← 每个TA的独立目录
│   ├── dirf.db                      ← 目录文件数据库 (加密)
│   ├── dirh.db                      ← 目录哈希数据库 (完整性)
│   └── [ObjectID_hex]/              ← 持久化对象目录
│       ├── O                        ← 对象数据文件 (分块存储)
│       ├── .info                    ← 对象元数据 (GP格式)
│       ├── .htree                   ← 哈希树节点缓存
│       └── .backup/                 ← 写时复制备份
│           ├── O.v1                 ← 版本1数据
│           ├── O.v2                 ← 版本2数据
│           └── .htree.backup        ← 哈希树备份

struct tee_svc_storage_head {
    uint32_t head_size;              // 头部大小 (用于版本兼容)
    uint32_t magic;                  // 魔数 0x53544F52 ("STOR")
    uint32_t objectSize;             // 对象数据大小
    uint32_t keySize;                // 密钥大小 
    uint32_t maxKeySize;             // 最大密钥大小
    uint32_t objectUsage;            // 对象用途标志
    uint32_t objectType;             // 对象类型 (数据/密钥)
    uint32_t have_attrs;             // 属性存在位图
    /* 可变长度部分 */
    uint8_t  encr_key[FEK_SIZE];     // 加密的文件加密密钥
    uint8_t  attrs_data[];           // 序列化的属性数据
};

#define TEE_SVC_STORAGE_MAGIC 0x53544F52

struct tee_obj_attr_packed {
    uint32_t attr_id;                // GP属性ID
    uint32_t a_type;                 // 属性类型 (buffer/value/bigint)
    union {
        struct {
            uint32_t len;            // 缓冲区长度
            /* 紧跟 len 字节的数据 */
        } buffer;
        struct {
            uint32_t a;              // 值A
            uint32_t b;              // 值B  
        } value;
        struct {
            uint32_t sign;           // 符号位
            uint32_t len;            // 大整数长度
            /* 紧跟 len 字节的大整数数据 */
        } bigint;
    };
};

struct tee_fs_dirfile_dirh {
    const struct tee_fs_dirfile_operations *fops;
    struct tee_file_handle *fh;      // 文件句柄
    int nbits;                       // 位向量大小 
    bitstr_t *files;                 // 文件分配位图
    size_t ndents;                   // 目录条目数量
    size_t max_files;                // 最大文件数
    struct mutex dir_mutex;          // 目录级互斥锁
};

#define TEE_FS_DIRFILE_FILELEN          56  // 文件名长度
#define TEE_FS_DIRFILE_HASH_LEN         32  // 哈希长度

struct tee_fs_dirfile_fileh {
    uint32_t file_number;            // 文件编号
    uint32_t hash_present;           // 哈希存在标志
    char fname[TEE_FS_DIRFILE_FILELEN]; // 文件名 (对象ID十六进制)
    uint8_t hash[TEE_FS_DIRFILE_HASH_LEN]; // 文件内容哈希
};

static TEE_Result get_absolute_filename(const TEE_UUID *uuid,
                                       const char *file,
                                       char **out_abs_filename)
{
    char uuid_str[37];  // UUID字符串: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
    char *abs_filename;
    
    // 1. UUID转换为规范字符串格式
    snprintf(uuid_str, sizeof(uuid_str), 
            "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
            uuid->timeLow, uuid->timeMid, uuid->timeHiAndVersion,
            uuid->clockSeqAndNode[0], uuid->clockSeqAndNode[1],
            uuid->clockSeqAndNode[2], uuid->clockSeqAndNode[3],
            uuid->clockSeqAndNode[4], uuid->clockSeqAndNode[5],
            uuid->clockSeqAndNode[6], uuid->clockSeqAndNode[7]);
    
    // 2. 构建绝对路径: /data/tee/{UUID}/{filename}
    if (asprintf(&abs_filename, "%s/%s/%s", 
                tee_fs_parent_path, uuid_str, file) < 0) {
        return TEE_ERROR_OUT_OF_MEMORY;
    }
    
    *out_abs_filename = abs_filename;
    return TEE_SUCCESS;
}

static TEE_Result check_access_rights(uint32_t flags, uint32_t mode)
{
    // 读权限检查
    if ((flags & TEE_DATA_FLAG_ACCESS_READ) && !(mode & TEE_MODE_READ)) {
        return TEE_ERROR_ACCESS_DENIED;
    }
    
    // 写权限检查  
    if ((flags & TEE_DATA_FLAG_ACCESS_WRITE) && !(mode & TEE_MODE_WRITE)) {
        return TEE_ERROR_ACCESS_DENIED;
    }
    
    // 元数据写权限检查
    if ((flags & TEE_DATA_FLAG_ACCESS_WRITE_META) && 
        !(mode & TEE_MODE_WRITE_META)) {
        return TEE_ERROR_ACCESS_DENIED;
    }
    
    return TEE_SUCCESS;
}

struct storage_cache_hierarchy {
    // L1: 对象句柄缓存 (最频繁访问)
    struct {
        struct tee_obj *hot_objects[L1_CACHE_SIZE];
        uint64_t access_times[L1_CACHE_SIZE];
        struct mutex l1_mutex;
    } l1_cache;
    
    // L2: 持久化对象缓存 (中等频率访问)  
    struct {
        struct tee_pobj *warm_objects[L2_CACHE_SIZE];
        uint64_t access_times[L2_CACHE_SIZE];
        struct mutex l2_mutex;
    } l2_cache;
    
    // L3: 块数据缓存 (大容量，低频率)
    struct {
        struct block_cache_entry *cold_blocks[L3_CACHE_SIZE];
        struct lru_list lru;
        struct mutex l3_mutex;
    } l3_cache;
};

#define TEE_STORAGE_FORMAT_VERSION_1    1
#define TEE_STORAGE_FORMAT_VERSION_2    2
#define TEE_STORAGE_FORMAT_CURRENT      TEE_STORAGE_FORMAT_VERSION_2

static TEE_Result upgrade_storage_format(uint32_t old_version, uint32_t new_version)
{
    switch (old_version) {
    case TEE_STORAGE_FORMAT_VERSION_1:
        if (new_version >= TEE_STORAGE_FORMAT_VERSION_2) {
            // 升级到版本2: 添加扩展属性支持
            res = add_extended_attributes_support();
            if (res != TEE_SUCCESS) return res;
        }
        // fall through
    case TEE_STORAGE_FORMAT_VERSION_2:
        // 当前版本，无需升级
        break;
    default:
        return TEE_ERROR_NOT_SUPPORTED;
    }
    
    return TEE_SUCCESS;
}

## Major Source Files

### Core Implementation (optee_os/core/tee/)
- **`tee_svc_storage.c`** - 存储系统调用实现，处理GP API到内核的转换
- **`tee_pobj.c`** - 持久化对象管理，引用计数和生命周期控制
- **`tee_obj.c`** - 通用对象管理，包括瞬态和持久化对象
- **`tee_fs_key_manager.c`** - 文件加密密钥管理，四层密钥派生体系
- **`fs_htree.c`** - 哈希树完整性保护，Merkle树实现
- **`fs_dirfile.c`** - 目录文件管理，支持对象枚举操作

### Backend Implementation (optee_os/core/tee/)
- **`tee_ree_fs.c`** - REE文件系统后端，写时复制机制
- **`tee_rpmb_fs.c`** - RPMB文件系统后端，FAT管理和缓存
- **`tee_fs_rpc.c`** - TEE-REE RPC通信层

### Header Files (optee_os/core/include/tee/)
- **`tee_fs.h`** - 文件系统抽象接口定义
- **`tee_svc_storage.h`** - 存储系统调用接口声明
- **`tee_pobj.h`** - 持久化对象结构和管理函数
- **`tee_obj.h`** - 对象结构定义和属性管理
- **`fs_htree.h`** - 哈希树数据结构和操作接口
- **`tee_fs_key_manager.h`** - 密钥管理接口声明
- **`fs_dirfile.h`** - 目录文件结构定义

### Client Side Implementation (optee_client/tee-supplicant/src/)
- **`tee_supp_fs.c`** - REE文件系统服务实现
- **`rpmb.c`** - RPMB设备操作和硬件认证
- **`optee_msg_supplicant.h`** - RPC消息协议定义

### Examples and Tests
- **`optee_examples/secure_storage/`** - 完整的安全存储示例
- **`optee_test/ta/storage/`** - 核心存储功能测试套件
- **`optee_test/ta/storage_benchmark/`** - 性能基准测试

## Storage Flow Overview
1. **TA调用GP API** (如TEE_CreatePersistentObject)
2. **系统调用转换** (tee_svc_storage.c)
3. **后端选择** (REE FS 或 RPMB)
4. **安全处理** (加密 + 哈希树)
5. **RPC通信** (如果使用REE FS)
6. **物理存储** (文件系统或RPMB)

## Key Data Structures

### Core Object Structures
- **`struct tee_file_operations`** - 抽象文件系统接口，定义open、create、read、write等操作
- **`struct tee_pobj`** - 持久化对象结构，包含UUID、引用计数和文件系统操作指针
- **`struct tee_obj`** - 通用对象结构，管理属性、数据流位置和文件句柄
- **`struct tee_svc_storage_head`** - GP格式的安全存储文件头部结构

### Security Structures  
- **`struct tee_fs_htree_*`** - 哈希树结构家族，用于完整性保护
  - `tee_fs_htree_meta` - 元数据节点
  - `tee_fs_htree_image` - 节点镜像
  - `tee_fs_htree_node_image` - 节点图像数据
- **`struct fs_dirfile_*`** - 目录文件结构，支持对象枚举

### Communication Structures
- **RPC消息结构** - TEE与REE通信的消息格式
- **RPMB协议结构** - 硬件安全存储的通信协议

## Security Mechanisms Detail

### Four-Level Key Hierarchy
1. **HUK (Hardware Unique Key)** - 硬件根密钥
2. **SSK (Secure Storage Key)** - 安全存储密钥  
3. **TSK (Trusted App Storage Key)** - TA存储密钥
4. **FEK (File Encryption Key)** - 文件加密密钥

### Cryptographic Protection
- **AES-GCM认证加密** - 提供机密性和真实性
- **SHA-256哈希树** - 完整性验证
- **ESSIV加密模式** - 语义安全性保护
- **RPMB写计数器** - 硬件级防重放保护

### Atomic Operations
- **写时复制(Copy-on-Write)** - 确保原子更新
- **双版本管理** - 防止数据不一致
- **哈希树原子提交** - 完整性保护的原子性

## Performance Optimization Features

### Caching Strategies
- **块级缓存** - 可配置的RPMB缓存条目
- **内存池管理** - 高效的临时块分配
- **写入缓存** - 延迟写入操作优化

### Communication Optimization  
- **批量操作** - 减少系统调用开销
- **零拷贝RPC** - 高效的TEE-REE数据传输
- **异步I/O** - 非阻塞文件操作

### Memory Management
- **引用计数** - 自动资源管理
- **对象池** - 减少内存分配开销
- **缓存一致性** - 多级缓存同步

## Advanced Performance Optimization Techniques

### 1. 零拷贝数据传输
```c
static TEE_Result tee_fs_rpc_read_primitive(struct tee_file_handle *fh,
                                           size_t pos, void *buf, size_t *len)
{
    struct thread_param params[4];
    
    // 设置零拷贝参数
    params[0] = THREAD_PARAM_VALUE(INOUT, fh->fd, pos, *len);
    params[1] = THREAD_PARAM_MEMREF(OUT, buf, *len);
    
    // 直接内存映射，避免数据拷贝
    return thread_rpc_cmd(OPTEE_RPC_CMD_FS_READ, 4, params);
}

#define READAHEAD_WINDOW_SIZE    (64 * 1024)  // 64KB预读窗口

static void trigger_readahead(struct tee_fs_fd *fdp, size_t current_pos)
{
    size_t next_block = pos_to_block_num(current_pos + BLOCK_SIZE);
    size_t readahead_blocks = READAHEAD_WINDOW_SIZE / BLOCK_SIZE;
    
    // 异步预读下几个块
    for (size_t i = 0; i < readahead_blocks; i++) {
        if (!is_block_cached(next_block + i)) {
            async_read_block(fdp, next_block + i);
        }
    }
}

static TEE_Result batch_write_blocks(struct tee_fs_htree *ht,
                                    struct block_write_request *requests,
                                    size_t num_requests)
{
    // 1. 排序请求以优化磁盘访问模式
    qsort(requests, num_requests, sizeof(*requests), compare_block_addr);
    
    // 2. 合并连续块写入
    struct merged_write_op *ops = merge_consecutive_writes(requests, num_requests);
    
    // 3. 并行执行非相关的写入操作
    return execute_parallel_writes(ops);
}

struct storage_memory_pools {
    struct mempool *small_objects;   // < 1KB
    struct mempool *medium_objects;  // 1KB - 16KB  
    struct mempool *large_objects;   // 16KB - 64KB
    struct mempool *block_buffers;   // 固定4KB块
    struct mempool *crypto_contexts; // 加密上下文
    struct mempool *hash_contexts;   // 哈希上下文
};

static void *smart_alloc(size_t size)
{
    if (size <= 1024) {
        return mempool_alloc(pools.small_objects);
    } else if (size <= 16384) {
        return mempool_alloc(pools.medium_objects);
    } else if (size <= 65536) {
        return mempool_alloc(pools.large_objects);
    } else {
        return malloc(size);  // 回退到系统分配器
    }
}

// 一致性优先的设计示例
static TEE_Result atomic_multi_object_update(struct update_batch *batch)
{
    // 1. 预验证阶段 - 检查所有操作可行性
    for (size_t i = 0; i < batch->count; i++) {
        res = validate_update_operation(&batch->ops[i]);
        if (res != TEE_SUCCESS) {
            return res;  // 全部失败，保证一致性
        }
    }
    
    // 2. 执行阶段 - 原子执行所有操作
    return execute_atomic_batch(batch);
}

// 稀疏哈希树实现 - 只存储非空节点
struct sparse_htree_node {
    uint32_t block_id;               // 块ID
    uint8_t hash[32];               // 哈希值
    struct sparse_htree_node *left;  // 左子树
    struct sparse_htree_node *right; // 右子树
};

// 时间复杂度: O(log N), 空间复杂度: O(实际块数)
static struct sparse_htree_node *find_node(uint32_t block_id)
{
    struct sparse_htree_node *node = root;
    while (node && node->block_id != block_id) {
        node = (block_id < node->block_id) ? node->left : node->right;
    }
    return node;
}

struct tee_file_operations {
    TEE_Result (*open)(struct tee_pobj *po, size_t *size, struct tee_file_handle **fh);
    TEE_Result (*create)(struct tee_pobj *po, bool overwrite, struct tee_file_handle **fh);
    TEE_Result (*close)(struct tee_file_handle **fh);
    TEE_Result (*read)(struct tee_file_handle *fh, size_t pos, void *buf, size_t *len);
    TEE_Result (*write)(struct tee_file_handle *fh, size_t pos, const void *buf, size_t len);
    TEE_Result (*truncate)(struct tee_file_handle *fh, size_t len);
    TEE_Result (*remove)(struct tee_pobj *po);
    TEE_Result (*rename)(struct tee_pobj *old_po, struct tee_pobj *new_po);
};

// 运行时后端选择
static const struct tee_file_operations *select_backend(uint32_t storage_id)
{
    switch (storage_id) {
    case TEE_STORAGE_PRIVATE_REE:
        return &ree_fs_ops;
    case TEE_STORAGE_PRIVATE_RPMB:
        return &rpmb_fs_ops;
    default:
        return NULL;
    }
}

// 错误处理责任链
struct error_handler {
    TEE_Result (*handle)(TEE_Result error, void *context);
    struct error_handler *next;
};

static TEE_Result handle_storage_error(TEE_Result error)
{
    struct error_handler *handler = error_chain;
    
    while (handler) {
        TEE_Result res = handler->handle(error, NULL);
        if (res == TEE_SUCCESS) {
            return TEE_SUCCESS;  // 错误已处理
        }
        handler = handler->next;
    }
    
    return error;  // 无法处理的错误
}

// 存储事件通知系统
enum storage_event_type {
    STORAGE_EVENT_OBJECT_CREATED,
    STORAGE_EVENT_OBJECT_DELETED,
    STORAGE_EVENT_CACHE_MISS,
    STORAGE_EVENT_ERROR_OCCURRED
};

struct storage_observer {
    void (*notify)(enum storage_event_type event, void *data);
    struct storage_observer *next;
};

static void notify_storage_event(enum storage_event_type event, void *data)
{
    struct storage_observer *obs = observer_list;
    while (obs) {
        obs->notify(event, data);
        obs = obs->next;
    }
}