--- ./source/private_module/smartcache/diagnose/ssdc_diagnose.c	2018-03-30 08:20:48.000000000 +0000
+++ ./source/private_module/smartcache/diagnose/ssdc_diagnose.c.hotpatch	2020-11-04 09:06:12.000000000 +0000
@@ -95,7 +95,7 @@
 
     return;
 }
-
+void getSubPtInfoPatch(uint32_t subPtId, SSDC_SUB_PARTITION_S *subPt, SSDC_SUB_PARTITION_INFO_S *subPtInfo);
 int32_t diagShowPtByPtId(uint32_t ptId)
 {
     uint32_t i = 0;
@@ -118,7 +118,7 @@
         return RETURN_OK;
     }
 
-    getSubPtInfo(g_subPt[subPtId], &subPtInfo);
+    getSubPtInfoPatch(subPtId, g_subPt[subPtId], &subPtInfo);
     printSubPtInfo(g_subPt[subPtId], &subPtInfo);
 
     return RETURN_OK;
@@ -135,7 +135,7 @@
         return RETURN_ERROR;
     }
 
-    getSubPtInfo(g_subPt[subPtId], &subPtInfo);
+    getSubPtInfoPatch(subPtId, g_subPt[subPtId], &subPtInfo);
     printSubPtInfo(g_subPt[subPtId], &subPtInfo);
 
     return RETURN_OK;
@@ -150,7 +150,7 @@
     {
         if (g_subPt[i]->isDefault)
         {
-            getSubPtInfo(g_subPt[i], &subPtInfo);
+            getSubPtInfoPatch(i, g_subPt[i], &subPtInfo);
             printSubPtInfo(g_subPt[i], &subPtInfo);
             break;
         }
@@ -185,7 +185,7 @@
 
     for (i = 0; i < SSDC_MAX_SUB_PARTITION; i++)
     {
-        getSubPtInfo(g_subPt[i], &subPtInfo);
+        getSubPtInfoPatch(i, g_subPt[i], &subPtInfo);
 
         if (INVALID_VALUE32 == subPtInfo.ptId)
         {
--- ./source/private_module/smartcache/partition_manage/ssdc_extent.c	2018-02-09 13:47:03.000000000 +0000
+++ ./source/private_module/smartcache/partition_manage/ssdc_extent.c.hotpatch	2020-11-04 09:06:12.000000000 +0000
@@ -141,7 +141,7 @@
 
     return;
 }
-
+void incSubPtTotalBlkSetNum(uint32_t subPtId);
 /**************************************************************************
      :  һblock setextentblock setβ
 
@@ -187,7 +187,7 @@
     }
 
     SYS_BUG_EXP(extent->blkSetNum < INVALID_VALUE16, SYS_BUG_MAJ, MODULE_FUNC_END, "");
-
+    incSubPtTotalBlkSetNum(subPtId);
     extent->blkSetNum++;
 
     return newBlkSet;
@@ -595,7 +595,7 @@
 
     return;
 }
-
+SSD_BLOCK_SET_S* forceDelBlkSetPatch(uint32_t subPtId, SSD_EXT_S *extent);
 /**************************************************************************
      :  Block, ͷŶBlockSet
  :  extent  :  Ŀextentṹ
@@ -609,12 +609,12 @@
 {
     SSD_BLOCK_SET_S *freeBlkSet = NULL;
 
-    freeBlkSet = forceDelBlkSet(ssdExt);
+    freeBlkSet = forceDelBlkSetPatch(subPtId, ssdExt);
     while (NULL != freeBlkSet)
     {
         freeBlockSetList(freeBlkSet, subPtId);
 
-        freeBlkSet = forceDelBlkSet(ssdExt);
+        freeBlkSet = forceDelBlkSetPatch(subPtId, ssdExt);
     }
 
     return;
@@ -918,4 +918,305 @@
     return;
 }
 
+void incSubPtTotalValidBlkNum(uint32_t subPtId);
+/**************************************************************************
+     :  һblockextentָblock setλá
+
+ :  subPtId : ӵĸsmartӷ
+            extent   :  ӵĸextent
+            blkSet   :  ӵĸblock set
+            volId    :  block - volume id
+            objId    :  block - obj id
+            objLba   :  block - obj lba
+            len      :  block - length
+            offset   :  block - offset
+
+ :  
+   ֵ:  
+     :  BlockkeyֵobjIdobjLba϶ɡ
+**************************************************************************/
+void addBlockToExtentPatch(uint32_t subPtId,
+                      SSD_EXT_S *extent,
+                      SSD_BLOCK_SET_S *blkSet,
+                      uint64_t volId,
+                      uint64_t objId,
+                      uint64_t objLba,
+                      uint32_t len,
+                      uint32_t offset)
+{
+    SSD_BLOCK_S *block = NULL;
+
+    block = getNextUnuseBlock(blkSet);
+
+    /* һҵ */
+    SSDC_DBG_ASSERT(NULL != block);
+
+    /* PC_lintָ,汣֤ǿָ */
+    if (NULL == block)
+    {
+        return;
+    }
+
+    block->volumeId = volId;
+    block->objId    = objId;
+    block->objLba   = objLba;
+    block->len      = (uint16_t)len;
+    block->offset   = (uint16_t)offset;
+
+    SYS_BUG_EXP(blkSet->validBlkNum < INVALID_VALUE16, SYS_BUG_MAJ, MODULE_FUNC_END, "");
+    SYS_BUG_EXP(extent->validBlkNum < INVALID_VALUE16, SYS_BUG_MAJ, MODULE_FUNC_END, "");
+    SYS_BUG_EXP(extent->copyRef < INVALID_VALUE16, SYS_BUG_MAJ, MODULE_FUNC_END, "");
+
+    blkSet->validBlkNum++;
+    incSubPtTotalValidBlkNum(subPtId);
+    extent->validBlkNum++;
+    
+    extent->copyRef++;
+
+    setBitmapInExtent(extent,
+                      offset,
+                      len);
+
+    return;
+}
+
+void decSubPtTotalValidBlkNum(uint32_t subPtId);
+void decSubPtTotalBlkSetNum(uint32_t subPtId);
+void addSubPtTotalBlkSetNum(uint32_t subPtId, int64_t num);
+
+/**************************************************************************
+     :  һSSD
+
+ :  ssdCtrl : ӷSSDƽṹָ
+            extent : Ŀextent
+            blkSet : ĿblkSet
+            block  : Ŀblock
+
+ :  
+   ֵ:  
+     :
+**************************************************************************/
+void deleteBlockFromExtentPatch(uint32_t subPtId,
+                           SSDC_SSD_CTRL_S *ssdCtrl,
+                           SSD_EXT_S *extent,
+                           SSD_BLOCK_SET_S *blkSet,
+                           SSD_BLOCK_S *block)
+{
+    uint32_t ssdId = 0;
+
+    ssdId  = GET_SSD_ID_FROM_EXTENT(extent);
+    SYS_BUG_EXP(ssdId < SSDC_MAX_SSD_NUM, SYS_BUG_CRI, MODULE_FUNC_END, "Invalid ssdId:%u.", ssdId);
+
+    clearBitmapInExtent(&(ssdCtrl->ssd[ssdId].freeBlkList),
+                        extent,
+                        block->offset,
+                        block->len);
+
+    initBlock(block);
+
+    SYS_BUG_EXP(0 < blkSet->validBlkNum, SYS_BUG_CRI, MODULE_FUNC_END, "");
+    blkSet->validBlkNum--;
+
+    SYS_BUG_EXP(0 < extent->validBlkNum, SYS_BUG_CRI, MODULE_FUNC_END, "");
+    decSubPtTotalValidBlkNum(subPtId);
+    extent->validBlkNum--;
+
+    return;
+}
+
+/**************************************************************************
+     :  ĳblock setûл飬ɾظblock setͷ
+
+ :  extent     : SSD extentָ
+            prevBlkSet : ɾblkSetǰһblock set
+            blkSet     : blkSetָ
+
+ :  
+   ֵ:  ɾBlockSet, NULLʱʾǰBlockSetɾ
+     :  prevBlkSetΪգΪʱʾɾblock setΪͷ
+**************************************************************************/
+SSD_BLOCK_SET_S* tryToDelBlkSetPatch(uint32_t subPtId,
+                                SSD_EXT_S *extent,
+                                SSD_BLOCK_SET_S *prevBlkSet,
+                                SSD_BLOCK_SET_S *blkSet)
+{
+    if (0 != blkSet->validBlkNum)
+    {
+        return NULL;
+    }
+
+    if (NULL == prevBlkSet)
+    {
+        extent->blkSet = blkSet->next;
+    }
+    else
+    {
+        prevBlkSet->next = blkSet->next;
+    }
+
+    SYS_BUG_EXP(extent->blkSetNum > 0, SYS_BUG_MAJ, MODULE_FUNC_END, "");
+    decSubPtTotalBlkSetNum(subPtId);
+    extent->blkSetNum--;
+    blkSet->next = NULL;
+
+    return blkSet;
+}
+
+/**************************************************************************
+     :  ժȡЧٵblock set
+
+ :  extent   :  Ŀextent
+
+ :  
+   ֵ:  
+     :
+**************************************************************************/
+static inline SSD_BLOCK_SET_S* removeMinBlkSetPatch(uint32_t subPtId,
+                                                             SSD_EXT_S *extent)
+{
+    SSD_BLOCK_SET_S *blkSet = NULL;
+    SSD_BLOCK_SET_S *minBlkSet = NULL;
+    SSD_BLOCK_SET_S *prevBlkSet = NULL;
+    SSD_BLOCK_SET_S *minBlkSetPrev = NULL;
+    uint32_t minBlkNum = INVALID_VALUE32;
+
+    blkSet = extent->blkSet;
+    minBlkSet = blkSet;
+
+    while (NULL != blkSet)
+    {
+        if (blkSet->validBlkNum < minBlkNum)
+        {
+            minBlkNum = blkSet->validBlkNum;
+            minBlkSet = blkSet;
+            minBlkSetPrev = prevBlkSet;
+        }
+        prevBlkSet = blkSet;
+        blkSet = blkSet->next;
+    }
+
+    /* extentժȡЧٵblock set */
+    if (NULL == minBlkSetPrev)
+    {
+        extent->blkSet = minBlkSet->next;
+    }
+    else
+    {
+        minBlkSetPrev->next = minBlkSet->next;
+    }
+    minBlkSet->next = NULL;
+
+    SYS_BUG_EXP(extent->blkSetNum > 0, SYS_BUG_MAJ, MODULE_FUNC_END, "");
+    decSubPtTotalBlkSetNum(subPtId);
+    extent->blkSetNum--;
+
+    return minBlkSet;
+}
+
+/**************************************************************************
+     :  ЧǷ񳬹block setblockǣ
+            һblock setͷŵ
+
+ :  extent   :  Ŀextent
+
+ :  
+   ֵ:  
+     :
+**************************************************************************/
+SSD_BLOCK_SET_S* forceDelBlkSetPatch(uint32_t subPtId,
+                                            SSD_EXT_S *extent)
+{
+    SSD_BLOCK_SET_S *blkSet = NULL;
+    uint32_t cnt = INVALID_VALUE32;
+    SSD_BLOCK_S *dstBlk = NULL;
+    uint32_t totalBlkNum = INVALID_VALUE32;
+    SSD_BLOCK_SET_S *minBlkSet = NULL;
+    SSD_BLOCK_S *minSSDBlk = NULL;
+
+    if (NULL == extent->blkSet)
+    {
+        SYS_BUG_EXP(0 == extent->blkSetNum,
+                    SYS_BUG_CRI, MODULE_FUNC_END,
+                    "Info:blkSetNum:%u.", extent->blkSetNum);
+
+        SYS_BUG_EXP(0 == extent->validBlkNum,
+                    SYS_BUG_CRI, MODULE_FUNC_END,
+                    "Info:validBlkNum:%u.", extent->validBlkNum);
+
+        return NULL;
+    }
+
+    if (0 == extent->validBlkNum)
+    {
+        blkSet = extent->blkSet;
+        SYS_BUG_EXP(0 == blkSet->validBlkNum,
+                    SYS_BUG_CRI, MODULE_FUNC_END,
+                    "Info:validBlkNum:%u.", blkSet->validBlkNum);
+
+        extent->blkSet = NULL;
+        addSubPtTotalBlkSetNum(subPtId, (int64_t)(0-extent->blkSetNum));
+        extent->blkSetNum = 0;
+
+        return blkSet;
+    }
+
+    totalBlkNum = extent->blkSetNum * SSDC_BLOCK_SET_BLOCK_NUM;
+
+    SYS_BUG_EXP(totalBlkNum >= extent->validBlkNum,
+                SYS_BUG_CRI, MODULE_FUNC_END,
+                "Info:totalBlkNum:%u, validBlkNum:%u.", totalBlkNum, extent->validBlkNum);
+
+    if ((totalBlkNum - extent->validBlkNum) < SSDC_BLOCK_SET_BLOCK_NUM)
+    {
+        return NULL;
+    }
+
+    /* ժȡЧٵblock set */
+    minBlkSet = removeMinBlkSetPatch(subPtId, extent);
+
+    minSSDBlk = minBlkSet->ssdBlk;
+    blkSet = extent->blkSet;
+
+    for (cnt = 0; cnt < SSDC_BLOCK_SET_BLOCK_NUM; cnt++)
+    {
+        if (INVALID_VALUE64 == minSSDBlk[cnt].volumeId)
+        {
+            continue;
+        }
+
+        /* ҵһBlock Set */
+        blkSet = getNextThinBlockSet(blkSet);
+
+        if (NULL != blkSet)
+        {
+            /* ҵһδʹõBlock */
+            dstBlk = getNextUnuseBlock(blkSet);
+
+            /* һҵ */
+            if (NULL != dstBlk)
+            {
+                memcpy(dstBlk, &(minSSDBlk[cnt]), sizeof(SSD_BLOCK_S));
+
+                initBlock(&minSSDBlk[cnt]);
+
+                blkSet->validBlkNum++;
+                minBlkSet->validBlkNum--;
+
+                continue;
+            }
+            /* һҵߵ쳣 */
+            SYS_BUG(SYS_BUG_CRI, MODULE_FUNC_END, "Info: NULL != dstBlk.");
+        }
+
+        /* һҵߵ쳣 */
+        SYS_BUG(SYS_BUG_CRI, MODULE_FUNC_END, "Info: NULL != blkSet.");
+    }
+
+    SYS_BUG_EXP(0 == minBlkSet->validBlkNum,
+                SYS_BUG_CRI, MODULE_FUNC_END,
+                "Info:validBlkNum:%u.", minBlkSet->validBlkNum);
+
+    return minBlkSet;
+}
+
 
--- ./source/private_module/smartcache/partition_manage/ssdc_partition.c	2018-04-27 09:42:16.000000000 +0000
+++ ./source/private_module/smartcache/partition_manage/ssdc_partition.c.hotpatch	2020-11-04 09:06:12.000000000 +0000
@@ -1128,7 +1128,7 @@
 
     return;
 }
-
+void getSubPtInfoPatch(uint32_t subPtId, SSDC_SUB_PARTITION_S *subPt, SSDC_SUB_PARTITION_INFO_S *subPtInfo);
 /******************************************************************************
      :  ѯӷϢ
  :  nodeId :  Ŀ
@@ -1205,7 +1205,7 @@
         }
         else
         {
-            getSubPtInfo(g_subPt[subPtId], subPtInfo);
+            getSubPtInfoPatch(subPtId, g_subPt[subPtId], subPtInfo);
         }
 
         ctx->state += 2;
@@ -3031,7 +3031,7 @@
     }
     else
     {
-        getSubPtInfo(g_subPt[subPtId], &subPtInfo);
+        getSubPtInfoPatch(subPtId, g_subPt[subPtId], &subPtInfo);
     }
 
     sendSsdcXnetResponse(msgData->opCode,
@@ -5245,7 +5245,7 @@
 
 
     *pttReadHitCount = (*pttReadHitCount > *pttTotalReadCount) ? *pttTotalReadCount : *pttReadHitCount;
-    getSubPtInfo(g_subPt[subPtId], &subPtInfo);
+    getSubPtInfoPatch(subPtId, g_subPt[subPtId], &subPtInfo);
     *pttCachedCapacity = (uint64_t)B_TO_KB(subPtInfo.cachedCap);
 
     g_ssdcLocalNid = getLocalNid();
@@ -5424,3 +5424,65 @@
     return;
 }
 
+
+typedef struct tagSSDC_SUBPT_ADJUST_TASK_STAT_PATCH_S
+{
+    atomic64_t totalBlkSetNum;       /* extentblkSetNumܺ*/
+    atomic64_t totalValidBlkNum;     /* extentValidBlkNumܺ*/
+}SSDC_SUBPT_ADJUST_TASK_STAT_PATCH_S;
+SSDC_SUBPT_ADJUST_TASK_STAT_PATCH_S g_subPtExtentInfo[SSDC_MAX_SUB_PARTITION];
+
+void incSubPtTotalBlkSetNum(uint32_t subPtId)
+{
+    atomic64_inc(&g_subPtExtentInfo[subPtId].totalBlkSetNum);
+    return;
+}
+
+void decSubPtTotalBlkSetNum(uint32_t subPtId)
+{
+    atomic64_dec(&g_subPtExtentInfo[subPtId].totalBlkSetNum);
+    return;
+}
+
+void addSubPtTotalBlkSetNum(uint32_t subPtId, int64_t num)
+{
+    atomic64_add(num, &g_subPtExtentInfo[subPtId].totalBlkSetNum);
+    return;
+}
+
+
+void incSubPtTotalValidBlkNum(uint32_t subPtId)
+{
+    atomic64_inc(&g_subPtExtentInfo[subPtId].totalValidBlkNum);
+    return;
+}
+
+void decSubPtTotalValidBlkNum(uint32_t subPtId)
+{
+    atomic64_dec(&g_subPtExtentInfo[subPtId].totalValidBlkNum);
+    return;
+}
+
+void addSubPtTotalValidBlkNum(uint32_t subPtId, int64_t num)
+{
+    atomic64_add(num, &g_subPtExtentInfo[subPtId].totalValidBlkNum);
+    return;
+}
+
+void clearSubPtAllExtentInfo(uint32_t subPtId)
+{
+    atomic64_set(&g_subPtExtentInfo[subPtId].totalBlkSetNum, 0UL);
+    atomic64_set(&g_subPtExtentInfo[subPtId].totalValidBlkNum, 0UL);
+    return;
+}
+
+int64_t getSubPtTotalBlkSetNum(uint32_t subPtId)
+{    
+    return atomic64_read(&g_subPtExtentInfo[subPtId].totalBlkSetNum);
+}
+
+int64_t getSubPtTotalValidBlkNum(uint32_t subPtId)
+{
+    return atomic64_read(&g_subPtExtentInfo[subPtId].totalValidBlkNum); 
+}
+
--- ./source/private_module/smartcache/partition_manage/ssdc_partition_mgr.c	2018-02-09 13:47:03.000000000 +0000
+++ ./source/private_module/smartcache/partition_manage/ssdc_partition_mgr.c.hotpatch	2020-11-04 09:06:12.000000000 +0000
@@ -792,7 +792,7 @@
 
     return TRUE;
 }
-
+void addBlockToExtentPatch(uint32_t subPtId, SSD_EXT_S *extent, SSD_BLOCK_SET_S *blkSet, uint64_t volId, uint64_t objId, uint64_t objLba, uint32_t len, uint32_t offset);
 /**************************************************************************
      :  ӵǰextentblock
 
@@ -848,14 +848,14 @@
     }
 
     curOffset = ssdCtrl->curOffset;
-
-    addBlockToExtent(extent,
-                     blkSet,
-                     volId,
-                     objId,
-                     objLba,
-                     len,
-                     curOffset);
+    addBlockToExtentPatch(subPtId,
+                          extent,
+                          blkSet,
+                          volId,
+                          objId,
+                          objLba,
+                          len,
+                          curOffset);
 
     /* ÷ֵ */
     *ssdId  = GET_SSD_ID_FROM_EXTENT(extent);
@@ -1425,7 +1425,7 @@
 
     return;
 }
-
+void addSubPtTotalBlkSetNum(uint32_t subPtId, int64_t num);
 /**************************************************************************
      :  һʹextentͷŵС
  :  ssdCtrl  :  Ŀӷ
@@ -1454,8 +1454,8 @@
 
     freeBlockSetList(extent->blkSet, subPtId);
     extent->blkSet = NULL;
+    addSubPtTotalBlkSetNum(subPtId, (int64_t)(0-extent->blkSetNum));
     extent->blkSetNum = 0;
-
     /* extentӷʹժ */
     list_del(&extent->kickListNode);
 
@@ -1771,14 +1771,14 @@
                 return;
             }
         }
-
-        addBlockToExtent(findExt,
-                         blkSet,
-                         volId,
-                         objId,
-                         objLba,
-                         len,
-                         extOffset);
+        addBlockToExtentPatch(subPtId,
+                              findExt,
+                              blkSet,
+                              volId,
+                              objId,
+                              objLba,
+                              len,
+                              extOffset);
 
         /* ÷ֵ */
         *ssdId  = idx;
@@ -1797,4 +1797,133 @@
 
     return;
 }
+
+
+bool g_needCalcAllExtentInfo[SSDC_MAX_SUB_PARTITION] = {TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE};
+void clearSubPtAllExtentInfo(uint32_t subPtId);
+void addSubPtTotalValidBlkNum(uint32_t subPtId, int64_t num);
+int64_t getSubPtTotalBlkSetNum(uint32_t subPtId);
+int64_t getSubPtTotalValidBlkNum(uint32_t subPtId);
+
+/**************************************************************************
+     :  ȡӷԴϢ
+ :  subPtId  :  ĿӷID
+                          subPt     :  Ŀӷ
+ :  subPtInfo :  ӷԴϢ
+   ֵ:  
+     :
+**************************************************************************/
+void getSubPtInfoPatch(uint32_t subPtId,
+                  SSDC_SUB_PARTITION_S *subPt,
+                  SSDC_SUB_PARTITION_INFO_S *subPtInfo)
+{
+    SSDC_SSD_CTRL_S *ssdCtrl = NULL;
+    SSDC_OBJ_CTRL_S *objCtrl = NULL;
+    RBTREE_NODE_S *node = NULL;
+    SSD_EXT_S *extent = NULL;
+    SSDC_OBJ_S *obj = NULL;
+    uint32_t i = 0;
+
+    SSDC_DBG_ASSERT(NULL != subPt);
+
+    memset(subPtInfo, 0, sizeof(SSDC_SUB_PARTITION_INFO_S));
+
+    ssdCtrl = &subPt->ssdCtrl;
+    objCtrl = &subPt->objCtrl;
+
+    spin_lock(&subPt->lock);
+
+    subPtInfo->ptId = subPt->id;
+    subPtInfo->configMaxExtNum = ssdCtrl->configMaxExtNum;
+    subPtInfo->validMaxExtNum  = ssdCtrl->validMaxExtNum;
+
+    /* һʹøӷڴķں̨ɾ,
+       ʱûпģѯķϢ0 */
+    if (subPt->isDel)
+    {
+        subPtInfo->allocExtNum = 0;
+        subPtInfo->usedExtNum  = 0;
+        subPtInfo->freeExtNum  = 0;
+        
+        subPtInfo->blkSetNum   = 0;
+        subPtInfo->validBlkNum = 0;
+
+        subPtInfo->totalReadIoNum  = 0;
+        subPtInfo->hitReadIoNum    = 0;
+        subPtInfo->totalWriteIoNum = 0;
+
+        subPtInfo->cachedCap = 0;
+
+        subPtInfo->totalReadRealTimeIoNum = 0;
+        subPtInfo->hitReadRealTimeIoNum = 0;
+        spin_unlock(&subPt->lock);
+
+        return;
+    }
+
+    if (g_needCalcAllExtentInfo[subPtId] == TRUE)
+    {
+        clearSubPtAllExtentInfo(subPtId);
+    }
+
+    for (i = 0; i < SSDC_MAX_SSD_NUM; i++)
+    {
+        if (isValidSsd(i))
+        {
+            subPtInfo->allocExtNum += ssdCtrl->ssd[i].allocExtNum;
+            subPtInfo->freeExtNum  += ssdCtrl->ssd[i].freeExtNum;
+            subPtInfo->usedExtNum  += (ssdCtrl->ssd[i].allocExtNum
+                                       - ssdCtrl->ssd[i].freeExtNum);
+
+            /*ڴȲÿsmart cacheӷһν̨ͳʱ
+                    㲢ӷextentۼӼڳʼ*/
+            if (g_needCalcAllExtentInfo[subPtId] == TRUE)
+            {
+                getFirstNodeInRbTree(&(ssdCtrl->ssd[i].root), &node);
+                while (NULL != node)
+                {
+                    extent = (SSD_EXT_S *)VOL_OBJ_ENTRY(node, SSD_EXT_S, node);
+                    addSubPtTotalBlkSetNum(subPtId, (int64_t)extent->blkSetNum);
+                    addSubPtTotalValidBlkNum(subPtId, (int64_t)extent->validBlkNum);
+                
+                    getNextNodeInRbTree(node, &node);
+                }            
+            }
+        }        
+    }
+
+    g_needCalcAllExtentInfo[subPtId] = FALSE;
+    subPtInfo->blkSetNum = (uint32_t)getSubPtTotalBlkSetNum(subPtId);
+    subPtInfo->validBlkNum = (uint32_t)getSubPtTotalValidBlkNum(subPtId);
+
+    /* curExtûп鱻ʹãcurExtǿ */
+    if ((subPtInfo->usedExtNum > 0)
+        && (NULL != ssdCtrl->curExt)
+        && (0 == ssdCtrl->curExt->blkSetNum))
+    {
+        subPtInfo->usedExtNum--;
+        subPtInfo->freeExtNum++;
+    }
+
+    getFirstNodeInRbTree(&objCtrl->root, &node);
+    while (NULL != node)
+    {
+        obj = (SSDC_OBJ_S *)VOL_OBJ_ENTRY(node, SSDC_OBJ_S, objNode);
+
+        subPtInfo->totalReadIoNum  += atomic64_read(&obj->totalIoNum[SSDC_IO_TYPE_READ]);
+        subPtInfo->hitReadIoNum    += atomic64_read(&obj->ssdIoNum[SSDC_IO_TYPE_READ]);
+        subPtInfo->totalWriteIoNum += atomic64_read(&obj->totalIoNum[SSDC_IO_TYPE_WRITE]);
+        subPtInfo->totalWriteIoNum += atomic64_read(&obj->totalIoNum[SSDC_IO_TYPE_COVER_WRITE]);
+
+        subPtInfo->cachedCap += SECTOR_TO_BYTE(obj->cachedCap);
+        subPtInfo->totalReadRealTimeIoNum += atomic64_read(&obj->totalRealTimeIoNum[SSDC_IO_TYPE_READ]);
+        subPtInfo->hitReadRealTimeIoNum   += atomic64_read(&obj->ssdRealTimeIoNum[SSDC_IO_TYPE_READ]);
+
+        getNextNodeInRbTree(node, &node);
+    }
+
+    spin_unlock(&subPt->lock);
+
+    return;
+}
 
--- ./source/private_module/smartcache/partition_manage/ssdc_resource.c	2018-04-27 09:42:16.000000000 +0000
+++ ./source/private_module/smartcache/partition_manage/ssdc_resource.c.hotpatch	2020-11-04 09:06:12.000000000 +0000
@@ -392,7 +392,9 @@
 
     return;
 }
-
+void deleteBlockFromExtentPatch(uint32_t subPtId, SSDC_SSD_CTRL_S *ssdCtrl, SSD_EXT_S *extent, SSD_BLOCK_SET_S *blkSet, SSD_BLOCK_S *block);
+SSD_BLOCK_SET_S* tryToDelBlkSetPatch(uint32_t subPtId, SSD_EXT_S *extent, SSD_BLOCK_SET_S *prevBlkSet, SSD_BLOCK_SET_S *blkSet);
+SSD_BLOCK_SET_S* forceDelBlkSetPatch(uint32_t subPtId, SSD_EXT_S *extent);
 /**************************************************************************
      :  SSD extentɾӦ
 
@@ -404,9 +406,7 @@
             objLba   :  lba
             isForceDelBlkSet : ϲͷblock setʱǷǿͷ;
                                ǿƣֻͷûлblock set
-
  :  
-
    ֵ:  
      :
 **************************************************************************/
@@ -468,14 +468,14 @@
                 continue;
             }
 
-            deleteBlockFromExtent(ssdCtrl, ssdExt, blkSet, &ssdBlk[i]);
+            deleteBlockFromExtentPatch(subPtId, ssdCtrl, ssdExt, blkSet, &ssdBlk[i]);
 
-            freeBlkSetList = tryToDelBlkSet(ssdExt, prevBlkSet, blkSet);
+            freeBlkSetList = tryToDelBlkSetPatch(subPtId, ssdExt, prevBlkSet, blkSet);
 
             /* һֻҪɾһ */
             if ((isForceDelBlkSet) && (NULL == freeBlkSetList))
             {
-                freeBlkSetList = forceDelBlkSet(ssdExt);
+                freeBlkSetList = forceDelBlkSetPatch(subPtId, ssdExt);
             }
 
             /* ǵǰExtent, Blockȫͷţ
@@ -2806,9 +2806,9 @@
             return;
         }
 
-        deleteBlockFromExtent(ssdCtrl, ssdExt, blkSet, block);
+        deleteBlockFromExtentPatch(subPtId, ssdCtrl, ssdExt, blkSet, block);
 
-        freeBlkSetList = tryToDelBlkSet(ssdExt, prevBlkSet, blkSet);
+        freeBlkSetList = tryToDelBlkSetPatch(subPtId, ssdExt, prevBlkSet, blkSet);
 
         /* ǵǰExtent, Blockȫͷţ
         ͷExtentг */
