diff --git a/services/cloudsyncservice/include/data_sync/gallery_data_sync/file_data_handler.h b/services/cloudsyncservice/include/data_sync/gallery_data_sync/file_data_handler.h
index b18bca21a4698b01830e21c1173dc777a81fccb6..0af4e1e0e6da53b1a76e51b23beb39c4fe523226 100644
--- a/services/cloudsyncservice/include/data_sync/gallery_data_sync/file_data_handler.h
+++ b/services/cloudsyncservice/include/data_sync/gallery_data_sync/file_data_handler.h
@@ -95,6 +95,9 @@ public:
     /* reset */
     void Reset();
 
+    /* check */
+    void SetCheckReportStatus();
+
 private:
     int32_t OnCreateRecordSuccess(const std::pair<DriveKit::DKRecordId, DriveKit::DKRecordOperResult> &entry,
         const std::unordered_map<std::string, LocalInfo> &localMap);
@@ -153,6 +156,19 @@ private:
     int32_t CheckSyncStatusConsistency(NativeRdb::ResultSet &resultSet);
     int32_t SetSyncStatusConsistency(std::string &filePath, bool thumbLocal,
         bool lcdLocal, int32_t thumbStatus, int32_t syncStatus);
+    
+    /* report check */
+    int32_t GetFilePosStat(std::vector<uint64_t> &filePosStat);
+    int32_t GetCloudThmStat(std::vector<uint64_t> &cloudThmStat);
+    int32_t GetDirtyTypeStat(std::vector<uint64_t> &dirtyTypeStat);
+    int32_t QueryDataStat(const NativeRdb::AbsRdbPredicates &predicates, const std::string &queryData,
+        const int32_t &value, int &num);
+    int32_t QueryFilePosStat(const int32_t &position, int &num);
+    int32_t QueryCloudThmStat(const int32_t &cloudThmStat, int &num);
+    int32_t QueryDirtyTypeStat(const int32_t &dirtyType, int &num);
+    void ReportFilePosStat();
+    void ReportCloudThmStat();
+    void ReportDirtyTypeStat();
 
     static inline const std::string TABLE_NAME = Media::PhotoColumn::PHOTOS_TABLE;
     static inline const int32_t LIMIT_SIZE = 5;
diff --git a/services/cloudsyncservice/include/data_sync/gallery_data_sync/gallery_sysevent.h b/services/cloudsyncservice/include/data_sync/gallery_data_sync/gallery_sysevent.h
index 00de271da894c02cdd70a6665d9546487b985564..e207f31adc991feb1641186d14d6ed3c46f9ca9e 100644
--- a/services/cloudsyncservice/include/data_sync/gallery_data_sync/gallery_sysevent.h
+++ b/services/cloudsyncservice/include/data_sync/gallery_data_sync/gallery_sysevent.h
@@ -35,6 +35,11 @@ namespace CloudSync {
 #define DOWNLOAD_LCD_LEN 5
 #define UPLOAD_ALBUM_LEN 4
 #define DOWNLOAD_ALBUM_LEN 4
+#define META_LEN 5
+#define FILE_POSITION_LEN 3
+#define CLOUD_THM_STAT_LEN 4
+#define DIRTY_TYPE_LEN 5
+#define UPLOAD_META_ERR_LEN 8
 
 /* stat index */
 enum MetaStatIndex {
@@ -86,6 +91,17 @@ enum AlbumStatIndex {
     INDEX_DL_ALBUM_ERROR_RDB,
 };
 
+enum UploadMetaErrIndex {
+    INDEX_UL_META_ERR_SUCCESS,
+    INDEX_UL_META_ERR_PERMISSION,
+    INDEX_UL_META_ERR_STORAGE,
+    INDEX_UL_META_ERR_NETWORK,
+    INDEX_UL_META_ERR_ERR1,
+    INDEX_UL_META_ERR_ERR2,
+    INDEX_UL_META_ERR_ERR3,
+    INDEX_UL_META_ERR_OTHER,
+};
+
 class GallerySyncStat : public SyncStat {
 public:
     GallerySyncStat() : uploadMeta_(UPLOAD_META_LEN),
@@ -93,7 +109,8 @@ public:
         downloadThumb_(DOWNLOAD_THUMB_LEN),
         downloadLcd_(DOWNLOAD_LCD_LEN),
         uploadAlbum_(UPLOAD_ALBUM_LEN),
-        downloadAlbum_(DOWNLOAD_ALBUM_LEN)
+        downloadAlbum_(DOWNLOAD_ALBUM_LEN),
+        uploadMetaErr_(UPLOAD_META_ERR_LEN)
     {
     }
 
@@ -126,6 +143,11 @@ public:
         }
     }
 
+    void UpdateUploadMetaErr(uint32_t index, uint64_t diff)
+    {
+        uploadMetaErr_[index] += diff;
+    }
+
 protected:
     std::vector<std::atomic<uint64_t>> uploadMeta_;
     std::vector<std::atomic<uint64_t>> downloadMeta_;
@@ -133,6 +155,7 @@ protected:
     std::vector<std::atomic<uint64_t>> downloadLcd_;
     std::vector<std::atomic<uint64_t>> uploadAlbum_;
     std::vector<std::atomic<uint64_t>> downloadAlbum_;
+    std::vector<std::atomic<uint64_t>> uploadMetaErr_;
 };
 
 class GalleryFullSyncStat : public GallerySyncStat {
@@ -158,6 +181,7 @@ public:
             "download_lcd", vector_atomic_to_origin<uint64_t>(downloadLcd_),
             "upload_album", vector_atomic_to_origin<uint64_t>(uploadAlbum_),
             "download_album", vector_atomic_to_origin<uint64_t>(downloadAlbum_),
+            "upload_meta_err", vector_atomic_to_origin<uint64_t>(uploadMetaErr_),
             "sync_info", sync_info_);
         if (ret != E_OK) {
             LOGE("report CLOUD_SYNC_FULL_STAT error %{public}d", ret);
@@ -246,6 +270,36 @@ enum GalleryCheckStatIndex {
     INDEX_CHECK_FIXED,
 };
 
+enum FilePositionIndex {
+    LOCAL,
+    CLOUD,
+    BOTH,
+};
+
+enum MetaIndex {
+    TOTAL,
+    LOCAL_EMPTY,
+    CLOUD_EMPTY,
+    LOCAL_CLOUD,
+    DIFF,
+    FIX,
+};
+
+enum CloudThmStatIndex {
+    DOWNLOADED,
+    LCD_TO_DOWNLOAD,
+    THM_TO_DOWNLOAD,
+    TO_DOWNLOAD,
+};
+
+enum DirtyTypeIndex {
+    SYNCED,
+    NEW,
+    MDIRTY,
+    FDIRTY,
+    DELETED,
+};
+
 #define GALLERY_CHECK_STAT_LEN 2
 
 class GalleryCheckSatat : public SyncStat {
@@ -253,7 +307,11 @@ public:
     GalleryCheckSatat() : file_(GALLERY_CHECK_STAT_LEN),
         album_(GALLERY_CHECK_STAT_LEN),
         map_(GALLERY_CHECK_STAT_LEN),
-        attachment_(GALLERY_CHECK_STAT_LEN)
+        attachment_(GALLERY_CHECK_STAT_LEN),
+        filePos_(FILE_POSITION_LEN),
+        meta_(META_LEN),
+        cloudThmStat_(CLOUD_THM_STAT_LEN),
+        dirtyType_(DIRTY_TYPE_LEN)
     {
     }
 
@@ -267,6 +325,10 @@ public:
             "album", album_,
             "map", map_,
             "attachment", attachment_,
+            "file_position", filePos_,
+            "meta", meta_,
+            "cloud_thm_status", cloudThmStat_,
+            "dirty_type", dirtyType_,
             "check_info", checkInfo_);
         if (ret != E_OK) {
             LOGE("report CLOUD_SYNC_CHECK error %{public}d", ret);
@@ -293,12 +355,36 @@ public:
         attachment_[index] += diff;
     }
 
+    void UpdateFilePos(uint32_t index, uint64_t diff)
+    {
+        filePos_[index] += diff;
+    }
+
+    void UpdateMeta(uint32_t index, uint64_t diff)
+    {
+        meta_[index] += diff;
+    }
+
+    void UpdateCloudThmStat(uint32_t index, uint64_t diff)
+    {
+        cloudThmStat_[index] += diff;
+    }
+
+    void UpdateDirtyType(uint32_t index, uint64_t diff)
+    {
+        dirtyType_[index] += diff;
+    }
+
 private:
     std::vector<uint64_t> file_;
     std::vector<uint64_t> album_;
     std::vector<uint64_t> map_;
     std::vector<uint64_t> attachment_;
     std::string checkInfo_;
+    std::vector<uint64_t> filePos_;
+    std::vector<uint64_t> meta_;
+    std::vector<uint64_t> cloudThmStat_;
+    std::vector<uint64_t> dirtyType_;
 };
 
 class GalleryCheckStatContainer : public CheckStatContainer<GalleryCheckSatat> {
@@ -334,6 +420,38 @@ public:
             stat->UpdateAttachment(index, diff);
         }
     }
+
+    void UpdateCheckFilePos(uint32_t index, uint64_t diff)
+    {
+        std::shared_ptr<GalleryCheckSatat> stat = GetCheckStat();
+        if (stat != nullptr) {
+            stat->UpdateFilePos(index, diff);
+        }
+    }
+
+    void UpdateCheckMeta(uint32_t index, uint64_t diff)
+    {
+        std::shared_ptr<GalleryCheckSatat> stat = GetCheckStat();
+        if (stat != nullptr) {
+            stat->UpdateMeta(index, diff);
+        }
+    }
+
+    void UpdateCheckCloudThmStat(uint32_t index, uint64_t diff)
+    {
+        std::shared_ptr<GalleryCheckSatat> stat = GetCheckStat();
+        if (stat != nullptr) {
+            stat->UpdateCloudThmStat(index, diff);
+        }
+    }
+
+    void UpdateCheckDirtyType(uint32_t index, uint64_t diff)
+    {
+        std::shared_ptr<GalleryCheckSatat> stat = GetCheckStat();
+        if (stat != nullptr) {
+            stat->UpdateDirtyType(index, diff);
+        }
+    }
 };
 } // namespace CloudSync
 } // namespace FileManagement
diff --git a/services/cloudsyncservice/src/data_sync/gallery_data_sync/file_data_handler.cpp b/services/cloudsyncservice/src/data_sync/gallery_data_sync/file_data_handler.cpp
index ff3184e571e0a73afa3f93a820d7074e6b2e98b4..1ea54a839b5f2ec93ade7292a54e0656ae287b66 100644
--- a/services/cloudsyncservice/src/data_sync/gallery_data_sync/file_data_handler.cpp
+++ b/services/cloudsyncservice/src/data_sync/gallery_data_sync/file_data_handler.cpp
@@ -3728,6 +3728,184 @@ int64_t FileDataHandler::UTCTimeSeconds()
     return static_cast<int64_t>(ts.tv_sec);
 }
 
+
+int32_t FileDataHandler::GetFilePosStat(std::vector<uint64_t> &filePosStat)
+{
+    if (filePosStat.size() != FILE_POSITION_LEN) {
+        LOGE("file position stat size is wrong with %{public}zu", filePosStat.size());
+        return E_DATA;
+    }
+
+    /* get local file status */
+    int num = 0;
+    QueryFilePosStat(POSITION_LOCAL, num);
+    filePosStat[FilePositionIndex::LOCAL] = num;
+
+    /* get cloud file status */
+    QueryFilePosStat(POSITION_CLOUD, num);
+    filePosStat[FilePositionIndex::CLOUD] = num;
+
+    /* get both file status */
+    QueryFilePosStat(POSITION_BOTH, num);
+    filePosStat[FilePositionIndex::BOTH] = num;
+
+    return E_OK;
+}
+
+int32_t FileDataHandler::GetCloudThmStat(std::vector<uint64_t> &cloudThmStat)
+{
+    if (cloudThmStat.size() != CLOUD_THM_STAT_LEN) {
+        LOGE("cloud thm stat size is wrong with %{public}zu", cloudThmStat.size());
+        return E_DATA;
+    }
+
+    /* get DOWNLOADED thm status */
+    int num = 0;
+    QueryCloudThmStat(static_cast<int32_t>(ThumbState::DOWNLOADED), num);
+    cloudThmStat[CloudThmStatIndex::DOWNLOADED] = num;
+
+    /* get LCD_TO_DOWNLOAD thm status */
+    QueryCloudThmStat(static_cast<int32_t>(ThumbState::LCD_TO_DOWNLOAD), num);
+    cloudThmStat[CloudThmStatIndex::LCD_TO_DOWNLOAD] = num;
+
+    /* get THM_TO_DOWNLOAD thm status */
+    QueryCloudThmStat(static_cast<int32_t>(ThumbState::THM_TO_DOWNLOAD), num);
+    cloudThmStat[CloudThmStatIndex::THM_TO_DOWNLOAD] = num;
+
+    /* get TO_DOWNLOAD thm status */
+    QueryCloudThmStat(static_cast<int32_t>(ThumbState::TO_DOWNLOAD), num);
+    cloudThmStat[CloudThmStatIndex::TO_DOWNLOAD] = num;
+
+    return E_OK;
+}
+
+int32_t FileDataHandler::GetDirtyTypeStat(std::vector<uint64_t> &dirtyTypeStat)
+{
+    if (dirtyTypeStat.size() != DIRTY_TYPE_LEN) {
+        LOGE("dirty type size is wrong with %{public}zu", dirtyTypeStat.size());
+        return E_DATA;
+    }
+
+    /* get synced dirty type status */
+    int num = 0;
+    QueryDirtyTypeStat(static_cast<int32_t>(DirtyType::TYPE_SYNCED), num);
+    dirtyTypeStat[DirtyTypeIndex::SYNCED] = num;
+
+    /* get new dirty type status */
+    QueryDirtyTypeStat(static_cast<int32_t>(DirtyType::TYPE_NEW), num);
+    dirtyTypeStat[DirtyTypeIndex::NEW] = num;
+
+    /* get mdirty dirty type status */
+    QueryDirtyTypeStat(static_cast<int32_t>(DirtyType::TYPE_MDIRTY), num);
+    dirtyTypeStat[DirtyTypeIndex::MDIRTY] = num;
+
+    /* get fdirty dirty type status */
+    QueryDirtyTypeStat(static_cast<int32_t>(DirtyType::TYPE_FDIRTY), num);
+    dirtyTypeStat[DirtyTypeIndex::FDIRTY] = num;
+
+    /* get deleted dirty type status */
+    QueryDirtyTypeStat(static_cast<int32_t>(DirtyType::TYPE_DELETED), num);
+    dirtyTypeStat[DirtyTypeIndex::DELETED] = num;
+
+    return E_OK;
+}
+
+int32_t FileDataHandler::QueryDataStat(const NativeRdb::AbsRdbPredicates &predicates,
+    const std::string &queryData, const int32_t &value, int &num)
+{
+    auto results = Query(predicates, { queryData });
+    if (results == nullptr) {
+        LOGE("get nullptr, query %{public}s value:%{public}d failed!", queryData.c_str(), value);
+        return E_RDB;
+    }
+
+    int32_t ret = results->GetRowCount(num);
+    if (ret != 0) {
+        LOGE("get row count failed ret is %{public}d", ret);
+        return E_RDB;
+    }
+
+    LOGI("query data status success type:%{public}s value:%{public}d num:%{public}d",
+        queryData.c_str(), value, num);
+    return E_OK;
+}
+
+int32_t FileDataHandler::QueryFilePosStat(const int32_t &position, int &num)
+{
+    num = 0;
+    NativeRdb::AbsRdbPredicates predicates = NativeRdb::AbsRdbPredicates(TABLE_NAME);
+    predicates.EqualTo(PhotoColumn::PHOTO_POSITION, position);
+    return QueryDataStat(predicates, PhotoColumn::PHOTO_POSITION, position, num);
+}
+
+int32_t FileDataHandler::QueryCloudThmStat(const int32_t &cloudThmStat, int &num)
+{
+    num = 0;
+    NativeRdb::AbsRdbPredicates predicates = NativeRdb::AbsRdbPredicates(TABLE_NAME);
+    predicates.EqualTo(PhotoColumn::PHOTO_THUMB_STATUS, cloudThmStat)
+              ->And()
+              ->BeginWrap()
+              ->EqualTo(PhotoColumn::PHOTO_POSITION, POSITION_CLOUD)
+              ->Or()
+              ->EqualTo(PhotoColumn::PHOTO_POSITION, POSITION_BOTH)
+              ->EndWrap();
+    return QueryDataStat(predicates, PhotoColumn::PHOTO_THUMB_STATUS, cloudThmStat, num);
+}
+
+int32_t FileDataHandler::QueryDirtyTypeStat(const int32_t &dirtyType, int &num)
+{
+    num = 0;
+    NativeRdb::AbsRdbPredicates predicates = NativeRdb::AbsRdbPredicates(TABLE_NAME);
+    predicates.EqualTo(PhotoColumn::PHOTO_DIRTY, dirtyType);
+    return QueryDataStat(predicates, PhotoColumn::PHOTO_DIRTY, dirtyType, num);
+}
+
+void FileDataHandler::ReportFilePosStat()
+{
+    std::vector<uint64_t> filePosStat(FILE_POSITION_LEN);
+    GetFilePosStat(filePosStat);
+    UpdateCheckFilePos(FilePositionIndex::LOCAL, filePosStat[FilePositionIndex::LOCAL]);
+    UpdateCheckFilePos(FilePositionIndex::CLOUD, filePosStat[FilePositionIndex::CLOUD]);
+    UpdateCheckFilePos(FilePositionIndex::BOTH, filePosStat[FilePositionIndex::BOTH]);
+}
+
+void FileDataHandler::ReportCloudThmStat()
+{
+    std::vector<uint64_t> dirtyTypeStat(CLOUD_THM_STAT_LEN);
+    GetCloudThmStat(dirtyTypeStat);
+    UpdateCheckCloudThmStat(CloudThmStatIndex::DOWNLOADED,
+        dirtyTypeStat[CloudThmStatIndex::DOWNLOADED]);
+    UpdateCheckCloudThmStat(CloudThmStatIndex::LCD_TO_DOWNLOAD,
+        dirtyTypeStat[CloudThmStatIndex::LCD_TO_DOWNLOAD]);
+    UpdateCheckCloudThmStat(CloudThmStatIndex::THM_TO_DOWNLOAD,
+        dirtyTypeStat[CloudThmStatIndex::THM_TO_DOWNLOAD]);
+    UpdateCheckCloudThmStat(CloudThmStatIndex::TO_DOWNLOAD,
+        dirtyTypeStat[CloudThmStatIndex::TO_DOWNLOAD]);
+}
+
+void FileDataHandler::ReportDirtyTypeStat()
+{
+    std::vector<uint64_t> dirtyTypeStat(DIRTY_TYPE_LEN);
+    GetDirtyTypeStat(dirtyTypeStat);
+    UpdateCheckDirtyType(DirtyTypeIndex::SYNCED, dirtyTypeStat[DirtyTypeIndex::SYNCED]);
+    UpdateCheckDirtyType(DirtyTypeIndex::NEW, dirtyTypeStat[DirtyTypeIndex::NEW]);
+    UpdateCheckDirtyType(DirtyTypeIndex::MDIRTY, dirtyTypeStat[DirtyTypeIndex::MDIRTY]);
+    UpdateCheckDirtyType(DirtyTypeIndex::FDIRTY, dirtyTypeStat[DirtyTypeIndex::FDIRTY]);
+    UpdateCheckDirtyType(DirtyTypeIndex::DELETED, dirtyTypeStat[DirtyTypeIndex::DELETED]);
+}
+
+void FileDataHandler::SetCheckReportStatus()
+{
+    /* set report file position status */
+    ReportFilePosStat();
+
+    /* set report dirty type status */
+    ReportDirtyTypeStat();
+
+    /* set report cloud thm status */
+    ReportCloudThmStat();
+}
+
 int32_t FileDataHandler::OptimizeStorage(const int32_t agingDays)
 {
     int64_t totalSize = GetTotalSize();
diff --git a/services/cloudsyncservice/src/data_sync/gallery_data_sync/gallery_data_syncer.cpp b/services/cloudsyncservice/src/data_sync/gallery_data_sync/gallery_data_syncer.cpp
index 34839476e31d7934b554f0e9a0176cf499ff9e9e..1bc34eef65371e50e94ba4c5ea5e053c9c3c86fa 100644
--- a/services/cloudsyncservice/src/data_sync/gallery_data_sync/gallery_data_syncer.cpp
+++ b/services/cloudsyncservice/src/data_sync/gallery_data_sync/gallery_data_syncer.cpp
@@ -276,6 +276,11 @@ int32_t GalleryDataSyncer::Complete(bool isNeedNotify)
         LOGW("clean remain record failed");
         return ret;
     }
+
+    if (checkStat_ != nullptr) {
+        fileHandler_->SetCheckReportStatus();
+    }
+
     DataSyncer::CompleteAll(isNeedNotify);
     return E_OK;
 }