@ohos-graphics/stability-code-review 0.1.0

package/references/GraphicsStability/StabilityCodeReview_GraphicsStability_008.md

@@ -0,0 +1,153 @@
+---
+rule_id: "StabilityCodeReview_GraphicsStability_008"
+name: "GetBackendTexture线程限制"
+category: "图形稳定性"
+severity: "HIGH"
+language: ["cpp", "c++"]
+author: "OH-Department7 Stability Team"
+---
+
+# GetBackendTexture线程限制
+
+## 问题描述
+
+Surface/Image只能在其创建的线程中使用GetBackendTexture。在非创建线程调用GetBackendTexture会导致GPU资源状态不一致，引发纹理损坏或崩溃。
+
+## 检测示例
+
+### 错误示例
+
+```cpp
+// 错误示例1：IO线程创建Surface，渲染线程GetBackendTexture
+class TextureLoader {
+public:
+    void LoadOnIOThread() {
+        // IO线程创建Surface
+        surface_ = Surface::MakeRenderTarget(contextIO, info);  // IO线程创建
+    }
+    
+    void GetTextureOnRenderThread() {
+        // 错误：渲染线程调用GetBackendTexture
+        BackendTexture backend = surface_->GetBackendTexture();  // 错误：跨线程
+    }
+    
+private:
+    sk_sp<Surface> surface_;
+};
+
+// 错误示例2：主线程创建Image，其他线程GetBackendTexture
+void MainThread_CreateImage()
+{
+    g_image = Image::MakeFromEncoded(encodedData);  // 主线程创建
+}
+
+void WorkerThread_GetBackendTexture()
+{
+    // 错误：Worker线程调用GetBackendTexture
+    BackendTexture backend = g_image->GetBackendTexture();  // 错误：跨线程
+}
+
+// 错误示例3：异步回调中使用GetBackendTexture
+void OnSurfaceReady(Surface* surface)
+{
+    // 在回调线程（非创建线程）中调用
+    BackendTexture backend = surface->GetBackendTexture();  // 错误
+}
+```
+
+### 正确示例
+
+```cpp
+// 正确示例1：创建线程调用GetBackendTexture
+void RenderThread_Lifecycle()
+{
+    // 正确：渲染线程创建
+    auto surface = Surface::MakeRenderTarget(context, info);
+    
+    // 正确：渲染线程调用GetBackendTexture
+    BackendTexture backend = surface->GetBackendTexture();  // 正确：同线程
+    
+    // 使用backend创建新资源
+    auto newSurface = Surface::MakeFromBackendTexture(context, backend, ...);
+}
+
+// 正确示例2：在创建Surface的线程传递BackendTexture
+class SafeTextureManager {
+public:
+    void CreateAndExport() {
+        // 主线程创建
+        surface_ = Surface::MakeRenderTarget(context_, info_);
+        
+        // 正确：主线程获取BackendTexture
+        BackendTexture backend = surface_->GetBackendTexture();  // 正确
+        
+        // 正确：传递BackendTexture给其他线程使用
+        SendBackendTextureToRenderThread(backend);
+    }
+    
+private:
+    sk_sp<Surface> surface_;
+};
+
+// 正确示例3：每个线程独立创建和访问
+void ThreadA_OwnedSurface()
+{
+    auto surface = Surface::MakeRenderTarget(contextA, info);
+    BackendTexture backend = surface->GetBackendTexture();  // 正确：同线程
+}
+
+void ThreadB_OwnedSurface()
+{
+    auto surface = Surface::MakeRenderTarget(contextB, info);
+    BackendTexture backend = surface->GetBackendTexture();  // 正确：同线程
+}
+```
+
+## 风险流分析（RiskFlow）
+
+- **RISK_SOURCE**: GetBackendTexture跨线程调用
+- **RISK_TYPE**: 线程安全违规
+- **RISK_PATH**: 在非创建线程调用GetBackendTexture -> GPU资源状态不一致 -> 纹理损坏
+- **IMPACT_POINT**: GPU崩溃、纹理损坏、渲染异常
+
+## 影响分析（ImpactAnalysis）
+
+- **Trigger**: 非创建线程调用GetBackendTexture
+- **Propagation**: GPU资源状态不一致
+- **Consequence**: GPU崩溃、纹理损坏、渲染异常
+- **Mitigation**: GetBackendTexture只能在创建Surface/Image的线程调用
+
+## 误报排除
+
+| 场景 | 识别特征 | 处理方式 |
+|------|----------|----------|
+| NOPROTECT 标记 | 有 // NOPROTECT 注释 | 不报 |
+| 同线程创建访问 | 上下文分析确认同线程 | 不报 |
+| 传递BackendTexture | 通过参数传递BackendTexture | 不报 |
+## 测试用例
+
+### 触发用例（应该报）
+
+```cpp
+// IOThread创建，RenderThread调用GetBackendTexture
+void IOThread_Create()
+{
+    g_surface = Surface::MakeRenderTarget(...);
+}
+
+void RenderThread_GetBackend()
+{
+    BackendTexture backend = g_surface->GetBackendTexture();  // 应该报：跨线程
+}
+```
+
+### 安全用例（不应该报）
+
+```cpp
+// 同一线程创建和GetBackendTexture
+void RenderThread_CreateAndGet()
+{
+    sk_sp<Surface> surface = Surface::MakeRenderTarget(...);  // 渲染线程创建
+    BackendTexture backend = surface->GetBackendTexture();  // 不报：同线程
+}
+```

package/references/GraphicsStability/StabilityCodeReview_GraphicsStability_009.md

@@ -0,0 +1,144 @@
+---
+rule_id: "StabilityCodeReview_GraphicsStability_009"
+name: "RSRenderNodeMap线程访问限制"
+category: "图形稳定性"
+severity: "HIGH"
+language: ["cpp", "c++"]
+author: "OH-Department7 Stability Team"
+---
+
+# RSRenderNodeMap线程访问限制
+
+## 问题描述
+
+RSRenderNodeMap只能在RSMainThread类（主线程）访问，不允许在其它线程访问。**RSMainThread类负责渲染的Prepare阶段**，需要访问RenderNodeMap进行节点遍历、遮挡计算等操作。RenderNodeMap存储渲染节点映射关系，是RSMainThread类的核心数据结构。RSUniRenderThread类（Process阶段）或其他线程访问会导致数据竞争和状态不一致。
+
+**渲染流程说明**：
+- RSMainThread类：负责Prepare及以前阶段，可以访问RenderNodeMap进行节点管理
+- RSUniRenderThread类：负责Process及以后阶段，不应直接访问RenderNodeMap，应使用副本数据
+
+## 检测示例
+
+### 错误示例
+
+```cpp
+// 错误示例1：RSUniRenderThread类访问RenderNodeMap
+void RSUniRenderThread::ProcessRender()
+{
+    // 错误：RSUniRenderThread类访问RenderNodeMap
+    auto nodeMap = GetRenderNodeMap();  // 错误：非RSMainThread类访问
+    auto node = nodeMap->GetNode(surfaceId);  // 错误
+}
+
+// 错误示例2：IO线程访问RenderNodeMap
+void IOThread::OnDataReceived()
+{
+    // 错误：IO线程访问RenderNodeMap
+    auto node = renderNodeMap_->FindNodeById(nodeId);  // 错误
+    node->UpdateFromData(data);  // 错误
+}
+
+// 错误示例3：Worker线程操作RenderNodeMap
+class RenderWorker {
+public:
+    void DoWork() {
+        // 错误：Worker线程修改RenderNodeMap
+        g_renderNodeMap->RegisterNode(newNode);  // 错误
+    }
+};
+
+// 错误示例4：回调中访问RenderNodeMap
+void OnSurfaceCreatedCallback(SurfaceId id)
+{
+    // 错误：回调可能在非主线程执行
+    auto node = renderNodeMap_->GetNode(id);  // 错误
+}
+```
+
+### 正确示例
+
+```cpp
+// 正确示例1：RS主线程访问RenderNodeMap
+void RSMainThread::HandleSurfaceCreated(SurfaceId id)
+{
+    // 正确：主线程访问RenderNodeMap
+    auto nodeMap = GetRenderNodeMap();  // 正确
+    auto node = nodeMap->GetNode(id);  // 正确
+    node->Initialize();
+}
+
+// 正确示例2：通过命令传递到主线程
+void IOThread::OnDataReceived(NodeId id, const Data& data)
+{
+    // 正确：通过命令传递
+    UpdateNodeCommand cmd;
+    cmd.nodeId = id;
+    cmd.data = data;
+    
+    SubmitToMainThread(cmd);  // 正确：发送到主线程处理
+}
+
+// 正确示例3：主线程处理回调
+void RSMainThread::OnCallbackReceived(const Callback& cb)
+{
+    // 正确：主线程处理回调中的RenderNodeMap操作
+    if (cb.type == UPDATE_NODE) {
+        auto node = renderNodeMap_->GetNode(cb.nodeId);  // 正确
+        node->UpdateFromCallback(cb);
+    }
+}
+
+// 正确示例4：RSUniRenderThread类使用副本数据
+void RSUniRenderThread::RenderFrame()
+{
+    // 正确：使用RSMainThread类传递的副本数据
+    auto renderList = GetRenderListCopy();  // 正确：不直接访问Map
+    
+    for (auto& item : renderList) {
+        RenderItem(item);
+    }
+}
+```
+
+## 风险流分析（RiskFlow）
+
+- **RISK_SOURCE**: 非RSMainThread类（RS主线程）访问RSRenderNodeMap
+- **RISK_TYPE**: 线程安全违规
+- **RISK_PATH**: 非RSMainThread类访问RSRenderNodeMap -> 数据竞争 -> 渲染状态不一致
+- **IMPACT_POINT**: 渲染异常、崩溃
+
+## 影响分析（ImpactAnalysis）
+
+- **Trigger**: 非RSMainThread类访问RSRenderNodeMap
+- **Propagation**: 数据竞争、状态不一致
+- **Consequence**: 渲染异常、界面错乱、崩溃
+- **Mitigation**: RSRenderNodeMap只能在RSMainThread类访问
+
+## 误报排除
+
+| 场景 | 识别特征 | 处理方式 |
+|------|----------|----------|
+| NOPROTECT 标记 | 有 // NOPROTECT 注释 | 不报 |
+| 主线程上下文 | RSMainThread:: | 不报 |
+| 使用副本数据 | GetRenderListCopy() | 不报 |
+## 测试用例
+
+### 触发用例（应该报）
+
+```cpp
+// RSUniRenderThread类访问RenderNodeMap
+void RSUniRenderThread::OnRender()
+{
+    auto node = renderNodeMap->GetNode(id);  // 应该报：非RSMainThread类访问
+}
+```
+
+### 安全用例（不应该报）
+
+```cpp
+// RSMainThread类访问RenderNodeMap
+void RSMainThread::HandleNode()
+{
+    auto node = renderNodeMap->GetNode(id);  // 不报：RSMainThread类访问
+}
+```

package/references/GraphicsStability/StabilityCodeReview_GraphicsStability_010.md

@@ -0,0 +1,152 @@
+---
+rule_id: "StabilityCodeReview_GraphicsStability_010"
+name: "回调函数执行进程限制"
+category: "图形稳定性"
+severity: "HIGH"
+language: ["cpp", "c++"]
+author: "OH-Department7 Stability Team"
+---
+
+# 回调函数执行进程限制
+
+## 问题描述
+
+应用进程传入的回调函数不能在RS进程中执行，只能在应用进程执行。RS进程和应用进程有独立的地址空间和执行上下文，直接在RS进程执行应用回调会导致回调在错误的上下文中执行，引发崩溃或状态不一致。
+
+## 检测示例
+
+### 错误示例
+
+```cpp
+// 错误示例1：RS进程直接执行应用回调
+void RSProcess::OnRenderComplete(SurfaceId id)
+{
+    auto callback = GetAppCallback(id);
+    
+    // 错误：RS进程直接执行应用回调
+    callback->OnComplete();  // 错误：回调在错误进程执行
+}
+
+// 错误示例2：RS服务直接调用应用监听器
+class RenderService {
+public:
+    void NotifyAppListener(RenderResult result)
+    {
+        auto listener = appListener_;  // 应用传入的监听器
+        
+        // 错误：RS服务直接调用应用监听器
+        listener->OnResult(result);  // 错误：跨进程调用
+    }
+};
+
+// 错误示例3：RS线程执行应用回调函数
+void RSRenderThread::HandleCallback()
+{
+    std::function<void()> appCallback = GetPendingCallback();
+    
+    // 错误：RS线程执行应用回调
+    appCallback();  // 错误：回调在RS进程执行
+}
+
+// 错误示例4：RS进程的回调处理
+void RenderServiceProcess::ProcessCallbacks()
+{
+    for (auto& cb : pendingCallbacks_) {
+        // 错误：在RS进程执行应用回调
+        cb.execute();  // 错误
+    }
+}
+```
+
+### 正确示例
+
+```cpp
+// 正确示例1：通过IPC发送回调到应用进程
+void RSProcess::OnRenderComplete(SurfaceId id)
+{
+    auto callback = GetAppCallback(id);
+    
+    // 正确：通过IPC发送到应用进程执行
+    PostCallbackToApp(callback);  // 正确：IPC通知应用
+}
+
+// 正确示例2：使用消息机制通知应用
+class RenderService {
+public:
+    void NotifyAppListener(RenderResult result)
+    {
+        // 正确：通过IPC消息发送结果
+        SendResultToApp(result);  // 正确
+        
+        // 应用进程收到消息后执行回调
+    }
+};
+
+// 正确示例3：应用进程处理回调
+void AppProcess::HandleRSMessage(const RSMessage& msg)
+{
+    if (msg.type == RENDER_COMPLETE) {
+        // 正确：应用进程执行回调
+        auto callback = GetCallback(msg.surfaceId);
+        callback->OnComplete();  // 正确：在应用进程执行
+    }
+}
+
+// 正确示例4：使用Binder IPC传递
+void RSProcess::ScheduleAppCallback(std::function<void()> callback)
+{
+    // 正确：通过Binder IPC发送
+    BinderCallbackToken token = RegisterCallback(callback);
+    SendCallbackTokenToApp(token);  // 正确
+    
+    // 应用进程根据token执行回调
+}
+```
+
+## 风险流分析（RiskFlow）
+
+- **RISK_SOURCE**: RS进程直接执行应用回调函数
+- **RISK_TYPE**: 进程边界违规
+- **RISK_PATH**: RS进程执行应用回调 -> 回调在错误进程上下文执行 -> 状态不一致
+- **IMPACT_POINT**: 回调失败、进程崩溃
+
+## 影响分析（ImpactAnalysis）
+
+- **Trigger**: RS进程直接调用应用传入的回调
+- **Propagation**: 回调在错误进程上下文执行
+- **Consequence**: 回调失败、进程通信异常、崩溃
+- **Mitigation**: 通过IPC将回调发送到应用进程执行
+
+## 误报排除
+
+| 场景 | 识别特征 | 处理方式 |
+|------|----------|----------|
+| NOPROTECT 标记 | 有 // NOPROTECT 注释 | 不报 |
+| IPC发送 | PostToApp、SendToApp | 不报 |
+| 应用进程上下文 | AppProcess:: | 不报 |
+## 测试用例
+
+### 触发用例（应该报）
+
+```cpp
+// RSProcess中直接执行应用回调
+void RSProcess::OnComplete()
+{
+    appCallback->OnComplete();  // 应该报：在RS进程执行应用回调
+}
+```
+
+### 安全用例（不应该报）
+
+```cpp
+// RSProcess通过IPC发送回调
+void RSProcess::OnComplete()
+{
+    PostCallbackToApp(appCallback);  // 不报：通过IPC发送
+    
+// 应用进程执行回调
+void AppProcess::HandleCallback()
+{
+    appCallback->OnComplete();  // 不报：在应用进程执行
+}
+```

package/references/GraphicsStability/StabilityCodeReview_GraphicsStability_011.md

@@ -0,0 +1,221 @@
+---
+rule_id: "StabilityCodeReview_GraphicsStability_011"
+name: "Vulkan信号量导出fd生命周期管理"
+category: "图形稳定性"
+severity: "HIGH"
+language: ["cpp", "c++"]
+author: "OH-Department7 Stability Team"
+---
+
+# Vulkan信号量导出fd生命周期管理
+
+## 问题描述
+
+使用GetFenceFdFromSemaphore、vkGetSemaphoreFdKHR等接口从vulkan信号量中导出fd后,fd由调用方负责关闭。**最佳实践是**在判断fd合法后,**立刻**(无任何中间代码)用sptr<SyncFence>智能指针包裹,由该智能指针接管fd生命周期,在智能指针释放时会自动关闭fd。**注意:强调"立刻"二字,意味着在fd导出后、判断合法后,必须立即创建智能指针,中间不能有任何其他代码语句,以确保fd在任何代码路径下都不会泄漏。**若实在无法使用SyncFence类型,须非常谨慎处理每一处函数/作用域出口,确保手动释放fd,避免fd泄漏。
+
+## 检测示例
+
+### 错误示例
+
+```cpp
+// 错误示例1:导出fd后未关闭
+void ProcessVulkanSemaphore(VkSemaphore semaphore)
+{
+    int fd = GetFenceFdFromSemaphore(semaphore);
+    if (fd < 0) {
+        return;  // 错误:fd未关闭
+    }
+    // 使用fd...
+    // 错误:函数结束时fd未关闭
+}
+
+// 错误示例2:多个退出路径遗漏关闭
+int ExportAndUseFd(VkSemaphore sem)
+{
+    int fd = vkGetSemaphoreFdKHR(device, sem, &info);
+    if (fd < 0) {
+        return -1;
+    }
+    
+    if (!CheckCondition()) {
+        return -2;  // 错误:fd未关闭
+    }
+    
+    if (!ProcessFd(fd)) {
+        return -3;  // 错误:fd未关闭
+    }
+    
+    close(fd);
+    return 0;
+}
+
+// 错误示例3:异常分支fd泄漏
+void HandleSemaphore(VkSemaphore sem)
+{
+    int fd = GetFenceFdFromSemaphore(sem);
+    
+    auto result = DoSomething(fd);
+    if (!result) {
+        LOGE("Operation failed");
+        return;  // 错误:fd泄漏
+    }
+    
+    close(fd);
+}
+
+// 错误示例4:导出fd后未立刻用智能指针管理
+void DelayedFenceWrap(VkSemaphore sem)
+{
+    int fd = GetFenceFdFromSemaphore(sem);
+    if (fd < 0) {
+        return;
+    }
+    
+    // 错误:在创建智能指针之前插入了其他代码
+    DoSomeOtherWork();  // 如果这里抛异常或出错,fd会泄漏
+    
+    // 虽然后续使用了智能指针,但不是"立刻"创建
+    sptr<SyncFence> fence = new SyncFence(fd);
+}
+```
+
+### 正确示例
+
+```cpp
+// 正确示例1:使用SyncFence智能指针管理fd生命周期
+void ProcessVulkanSemaphore(VkSemaphore semaphore)
+{
+    int fd = GetFenceFdFromSemaphore(semaphore);
+    if (fd < 0) {
+        LOGE("GetFenceFdFromSemaphore failed, fd=%{public}d", fd);
+        return;
+    }
+    
+    // 正确:判断fd合法后,立刻(无中间代码)使用sptr<SyncFence>智能指针管理fd
+    sptr<SyncFence> fence = new SyncFence(fd);
+    // fd现在由fence管理,无需手动close
+}
+
+// 正确示例2:所有退出路径都正确关闭fd
+int ExportAndUseFd(VkSemaphore sem)
+{
+    int fd = vkGetSemaphoreFdKHR(device, sem, &info);
+    if (fd < 0) {
+        LOGE("vkGetSemaphoreFdKHR failed, fd=%{public}d", fd);
+        return -1;
+    }
+    
+    // 正确:使用RAII方式管理fd
+    auto fdGuard = [](int* fd) { if (*fd >= 0) close(*fd); };
+    std::unique_ptr<int, decltype(fdGuard)> fdHolder(&fd, fdGuard);
+    
+    if (!CheckCondition()) {
+        return -2;  // fd会自动关闭
+    }
+    
+    if (!ProcessFd(fd)) {
+        return -3;  // fd会自动关闭
+    }
+    
+    return 0;
+}
+
+// 正确示例3:使用SyncFence统一管理
+void HandleSemaphore(VkSemaphore sem)
+{
+    int fd = GetFenceFdFromSemaphore(sem);
+    if (fd < 0) {
+        LOGE("GetFenceFdFromSemaphore failed, fd=%{public}d", fd);
+        return;
+    }
+    
+    // 正确:判断fd合法后,立刻(无中间代码)智能指针接管生命周期
+    sptr<SyncFence> fence = new SyncFence(fd);
+    
+    auto result = DoSomething(fd);
+    if (!result) {
+        LOGE("Operation failed");
+        return;  // 正确:fence析构时自动关闭fd
+    }
+}
+```
+
+## 检测范围
+
+检查以下API/函数/模式:
+
+- `GetFenceFdFromSemaphore()`、`vkGetSemaphoreFdKHR()`
+- `GetSemaphoreFd()`、`ImportSemaphoreFdKHR()`
+- 所有从Vulkan信号量导出fd的接口
+
+## 检测要点
+
+1. 识别从Vulkan信号量导出fd的调用
+2. **检查导出的fd是否在判断合法后立刻(无中间代码)被SyncFence智能指针管理**
+   - **关键检测点:** 从fd导出到创建智能指针之间,是否存在其他代码语句
+   - **违规示例:** fd导出 → 判断合法 → 中间有其他代码 → 创建智能指针 (应报错)
+   - **合规示例:** fd导出 → 判断合法 → 立即创建智能指针 (正确)
+3. 若未使用智能指针,检查所有退出路径是否都正确关闭fd
+4. 重点关注异常分支、提前返回、错误处理等场景
+5. **特别强调:** "立刻"意味着在获取有效fd后,下一行代码就应该创建智能指针,不允许在中间插入任何业务逻辑代码
+
+## 风险流分析(RiskFlow)
+
+- **RISK_SOURCE**: 从Vulkan信号量导出fd后未**立刻**用智能指针管理生命周期
+- **RISK_TYPE**: 文件描述符泄漏
+- **RISK_PATH**: fd导出 → 未**立刻**用智能指针管理 → 中间代码异常 → fd泄漏累积
+- **IMPACT_POINT**: 系统fd资源耗尽,导致无法打开新文件/设备
+
+## 影响分析(ImpactAnalysis)
+
+- **Trigger**: 调用GetFenceFdFromSemaphore等接口导出fd
+- **Propagation**: fd未**立刻**用智能指针管理,判断合法和创建智能指针之间插入其他代码,异常分支遗漏关闭
+- **Consequence**: fd泄漏累积,系统资源耗尽,程序崩溃或功能异常
+- **Mitigation**: 在判断fd合法后**立刻**(无任何中间代码)用sptr<SyncFence>智能指针管理fd生命周期
+
+## 误报排除
+
+| 场景 | 识别特征 | 处理方式 |
+|------|----------|----------|
+| fd立即传递给其他函数管理 | fd作为参数传递给接管函数 | 不报 |
+| 使用RAII类管理fd | unique_ptr/shared_ptr/sptr包裹 | 不报(但需检查是否**立刻**创建) |
+| 有明确的close调用 | 所有退出路径都有close(fd) | 不报 |
+| fd所有权转移 | 有注释说明fd所有权转移 | 不报 |
+
+**注意:** 即使使用了智能指针管理,如果在判断fd合法后到创建智能指针之间插入了其他代码语句,仍应报错,因为这违反了"立刻"的要求。
+
+## 测试用例
+
+### 触发用例(应该报)
+
+```cpp
+// test_StabilityCodeReview_GraphicsStability_011_trigger.cpp
+void TriggerFdLeak(VkSemaphore semaphore)
+{
+    int fd = GetFenceFdFromSemaphore(semaphore);
+    if (fd < 0) {
+        return;  // 应该报:未使用智能指针,异常分支未关闭fd
+    }
+    
+    // 使用fd...
+    // 应该报:函数结束未关闭fd
+}
+```
+
+### 安全用例(不应该报)
+
+```cpp
+// test_StabilityCodeReview_GraphicsStability_011_safe.cpp
+void SafeFdManagement(VkSemaphore semaphore)
+{
+    int fd = GetFenceFdFromSemaphore(semaphore);
+    if (fd < 0) {
+        LOGE("GetFenceFdFromSemaphore failed, fd=%{public}d", fd);
+        return;  // 不报:fd无效,打印日志后返回
+    }
+    
+    // 不报:判断fd合法后,立刻(无中间代码)使用智能指针管理fd
+    sptr<SyncFence> fence = new SyncFence(fd);
+    // fd由fence管理,自动关闭
+}
+```