diff --git a/services/cloudfiledaemon.cfg b/services/cloudfiledaemon.cfg
index ca6c19acdc6d9bc439892f0c5277d986001904a9..491d1d18ee0ed534c1b0b690386667363d48c724 100644
--- a/services/cloudfiledaemon.cfg
+++ b/services/cloudfiledaemon.cfg
@@ -1,10 +1,20 @@
 {
+    # "jobs": [{
+    #     "name" : "services:cloudfiledaemon",
+    #     "cmds" : [
+    #     "mkdir /data/service/el1/public/cloudfile/io 0711 dfs dfs",
+    #     "restorecon /data/service/el1/public/cloudfile/io"
+    #     ]
+    # }],
     "services": [{
         "name": "cloudfiledaemon",
         "path": ["/system/bin/sa_main", "/system/profile/cloudfiledaemon.json"],
         "uid": "1009",
         "gid": ["dfs", "user_data_rw", "ddms", "netsys_socket", "dfs_share", "readproc"],
         "sandbox": 0,
+        # "jobs" : {
+        #     "on-start" : "services:cloudfiledaemon"
+        # },
         "secon": "u:r:cloudfiledaemon:s0",
         "apl": "system_basic",
         "permission" : [
diff --git a/services/cloudfiledaemon/include/cloud_disk/io_message_listener.h b/services/cloudfiledaemon/include/cloud_disk/io_message_listener.h
index 655fe644aa1891991644c85dde2225236652e8f0..534258b8716deeb3d36b160f2354b7065c8422d5 100644
--- a/services/cloudfiledaemon/include/cloud_disk/io_message_listener.h
+++ b/services/cloudfiledaemon/include/cloud_disk/io_message_listener.h
@@ -51,6 +51,7 @@ class IoMessageManager {
 private:
     std::string currentBundleName = "";
     std::atomic<bool> isThreadRunning{false};
+    std::atomic<bool> reportThreadRunning{false};
     std::thread ioThread;
     std::mutex sleepMutex;
     std::mutex cvMute;
@@ -61,11 +62,24 @@ private:
     IoDataToWrite dataToWrite;
     AppExecFwk::AppStateData lastestAppStateData;
 
+    std::vector<std::string> ioTimes;
+    std::vector<std::string> ioBundleName;
+    std::vector<std::string> ioReadCharDiff;
+    std::vector<std::string> ioSyscReadDiff;
+    std::vector<std::string> ioReadBytesDiff;
+    std::vector<std::string> ioSyscOpenDiff;
+    std::vector<std::string> ioSyscStatDiff;
+    std::vector<std::string> ioResult;
+
     bool ReadIoDataFromFile(const std::string &path);
     void RecordDataToFile(const std::string &path);
     bool IsFirstLineHeader(const std::string &path);
     void RecordIoData();
     void ProcessIoData(const std::string &path);
+    void PushData(const std::vector<std::string> &fields);
+    void ReadAndReportIoMessage();
+    void CheckMaxSizeAndReport();
+    void Report();
 
 public:
     static IoMessageManager &GetInstance();
diff --git a/services/cloudfiledaemon/src/cloud_disk/io_message_listener.cpp b/services/cloudfiledaemon/src/cloud_disk/io_message_listener.cpp
index 8bf0b017ab9a40da677bd3a1cd3c651790bf754b..c19ee8674a218a68af120f2a8b4ba5ef68aed60c 100644
--- a/services/cloudfiledaemon/src/cloud_disk/io_message_listener.cpp
+++ b/services/cloudfiledaemon/src/cloud_disk/io_message_listener.cpp
@@ -14,6 +14,7 @@
  */
 #include "io_message_listener.h"
 
+#include "hisysevent.h"
 #include "utils_log.h"
 
 using namespace std;
@@ -28,9 +29,13 @@ const int32_t GET_FREQUENCY = 5;
 const int32_t READ_THRESHOLD = 1000;
 const int32_t OPEN_THRESHOLD = 1000;
 const int32_t STAT_THRESHOLD = 1000;
-const string IO_DATA_FILE_PATH = "/data/service/el1/public/cloudfile/rdb/io_message.csv";
+const string IO_DATA_FILE_PATH = "/data/service/el1/public/cloudfile/io/";
+const string IO_FILE_NAME = "io_message.csv";
+const string IO_NEED_REPORT_PREFIX = "wait_report_";
 const int32_t TYPE_FRONT = 2;
 const int32_t TYPE_BACKGROUND = 4;
+const int32_t MAX_IO_FILE_SIZE = 128 * 1024;
+int32_t MAX_IO_REPORT_NUMBER = 100;
 
 IoMessageManager &IoMessageManager::GetInstance()
 {
@@ -110,6 +115,148 @@ void IoMessageManager::RecordDataToFile(const string &path)
     LOGI("Write io data success");
 }
 
+static vector<const char*> ConvertToCStringArray(const vector<string>& vec)
+{
+    vector<const char*> cstrVec;
+    for (const auto& str : vec) {
+        cstrVec.push_back(str.c_str());
+    }
+    return cstrVec;
+}
+
+void IoMessageManager::Report()
+{
+    auto charIoTimes = ConvertToCStringArray(ioTimes);
+    auto charIoBundleName = ConvertToCStringArray(ioBundleName);
+    auto charIoReadCharDiff = ConvertToCStringArray(ioReadCharDiff);
+    auto charIoSyscReadDiff = ConvertToCStringArray(ioSyscReadDiff);
+    auto charIoReadBytesDiff = ConvertToCStringArray(ioReadBytesDiff);
+    auto charIoSyscOpenDiff = ConvertToCStringArray(ioSyscOpenDiff);
+    auto charIoSyscStatDiff = ConvertToCStringArray(ioSyscStatDiff);
+    auto charIoResult = ConvertToCStringArray(ioResult);
+
+    HiSysEventParam params[] = {
+        { "time", HISYSEVENT_STRING_ARRAY, { .array = charIoTimes.data() },
+            static_cast<int>(charIoTimes.size()) },
+        { "BundleName", HISYSEVENT_STRING_ARRAY, { .array = charIoBundleName.data() },
+            static_cast<int>(charIoBundleName.size()) },
+        { "ReadCharDiff", HISYSEVENT_STRING_ARRAY, { .array = charIoReadCharDiff.data() },
+            static_cast<int>(charIoReadCharDiff.size()) },
+        { "SyscReadDiff", HISYSEVENT_STRING_ARRAY, { .array = charIoSyscReadDiff.data() },
+            static_cast<int>(charIoSyscReadDiff.size()) },
+        { "ReadBytesDiff", HISYSEVENT_STRING_ARRAY, { .array = charIoReadBytesDiff.data() },
+            static_cast<int>(charIoReadBytesDiff.size()) },
+        { "SyscOpenDiff", HISYSEVENT_STRING_ARRAY, { .array = charIoSyscOpenDiff.data() },
+            static_cast<int>(charIoSyscOpenDiff.size()) },
+        { "SyscStatDiff", HISYSEVENT_STRING_ARRAY, { .array = charIoSyscStatDiff.data() },
+            static_cast<int>(charIoSyscStatDiff.size()) },
+        { "Result", HISYSEVENT_STRING_ARRAY, { .array = charIoResult.data() },
+            static_cast<int>(charIoResult.size()) },
+    };
+
+    auto ret = OH_HiSysEvent_Write(
+        "KERNEL_VENDOR",
+        "CLOUD_DISK_IO",
+        HISYSEVENT_FAULT,
+        params,
+        sizeof(params) / sizeof(params[0])
+    );
+
+    if (ret != 0) {
+        LOGE("Report failed, err : %{public}d", ret);
+    }
+
+    ioTimes.clear();
+    ioBundleName.clear();
+    ioReadCharDiff.clear();
+    ioSyscReadDiff.clear();
+    ioReadBytesDiff.clear();
+    ioSyscOpenDiff.clear();
+    ioSyscStatDiff.clear();
+    ioResult.clear();
+}
+
+void IoMessageManager::PushData(const vector<string> &fields)
+{
+    static const std::map<int32_t, std::function<void(const std::string&)>> fieldMap = {
+        { 0, [this](const std::string& value) { ioTimes.push_back(value); }},
+        { 1, [this](const std::string& value) { ioBundleName.push_back(value); }},
+        { 2, [this](const std::string& value) { ioReadCharDiff.push_back(value); }},
+        { 3, [this](const std::string& value) { ioSyscReadDiff.push_back(value); }},
+        { 4, [this](const std::string& value) { ioReadBytesDiff.push_back(value); }},
+        { 5, [this](const std::string& value) { ioSyscOpenDiff.push_back(value); }},
+        { 6, [this](const std::string& value) { ioSyscStatDiff.push_back(value); }},
+        { 7, [this](const std::string& value) { ioResult.push_back(value); }},
+    };
+    for (int i = 0; i < fields.size(); ++i) {
+        auto it = fieldMap.find(i);
+        if (it == fieldMap.end()) {
+            LOGE("Unknow field index: %{public}d", i);
+            continue;
+        }
+        it->second(fields[i]);
+    }
+}
+
+void IoMessageManager::ReadAndReportIoMessage()
+{
+    ifstream localData(IO_DATA_FILE_PATH + IO_NEED_REPORT_PREFIX + IO_FILE_NAME);
+    if (!localData) {
+        LOGE("Open cloud data statistic local data fail : %{public}d", errno);
+        return;
+    }
+
+    string line;
+    int32_t reportCount = 0;
+    while (getline(localData, line)) {
+        vector<string> fields;
+        istringstream iss(line);
+        string token;
+
+        while (getline(iss, token, ',')) {
+            fields.push_back(token);
+        }
+
+        PushData(fields);
+        reportCount++;
+
+        if (reportCount >= MAX_IO_REPORT_NUMBER) {
+            Report();
+            reportCount = 0;
+        }
+    }
+    if (reportCount > 0) {
+        Report();
+    }
+    bool ret = filesystem::remove(IO_DATA_FILE_PATH + IO_NEED_REPORT_PREFIX + IO_FILE_NAME);
+    if (!ret) {
+        LOGE("Failed to remove need_report_io_file, err:%{public}d", errno);
+    }
+    reportThreadRunning.store(false);
+}
+
+void IoMessageManager::CheckMaxSizeAndReport()
+{
+    try {
+        auto fileSize = filesystem::file_size(IO_DATA_FILE_PATH + IO_FILE_NAME);
+        if (fileSize >= MAX_IO_FILE_SIZE) {
+            if (filesystem::exists(IO_DATA_FILE_PATH + IO_NEED_REPORT_PREFIX + IO_FILE_NAME)) {
+                LOGI("Report file exist");
+            }
+            filesystem::rename(IO_DATA_FILE_PATH + IO_FILE_NAME,
+                IO_DATA_FILE_PATH + IO_NEED_REPORT_PREFIX + IO_FILE_NAME);
+            if (!reportThreadRunning.load()) {
+                reportThreadRunning.store(true);
+                LOGI("Start report io data");
+                thread reportThread(&IoMessageManager::ReadAndReportIoMessage, this);
+                reportThread.detach();
+            }
+        }
+    } catch (const filesystem::filesystem_error& e) {
+        LOGE("Rename or get file size failed, err: %{public}s", e.what());
+    }
+}
+
 void IoMessageManager::ProcessIoData(const string &path)
 {
     if (currentBundleName != lastestAppStateData.bundleName) {
@@ -141,7 +288,8 @@ void IoMessageManager::ProcessIoData(const string &path)
     if (dataToWrite.result >= READ_THRESHOLD ||
         dataToWrite.syscopenDiff >= OPEN_THRESHOLD ||
         dataToWrite.syscstatDiff >= STAT_THRESHOLD) {
-        RecordDataToFile(IO_DATA_FILE_PATH);
+        CheckMaxSizeAndReport();
+        RecordDataToFile(IO_DATA_FILE_PATH + IO_FILE_NAME);
     }
 
     preData = currentData;
diff --git a/services/cloudfiledaemon/src/ipc/cloud_daemon.cpp b/services/cloudfiledaemon/src/ipc/cloud_daemon.cpp
index fbbca08b47800783862823f2ad0b0949e23664a8..208515873a3be7579fb0175a4e54fd0099f74ae4 100644
--- a/services/cloudfiledaemon/src/ipc/cloud_daemon.cpp
+++ b/services/cloudfiledaemon/src/ipc/cloud_daemon.cpp
@@ -44,6 +44,7 @@ using namespace std;
 using namespace CloudDisk;
 
 namespace {
+    // static const string IO_MESSAGE_DIR = "/data/service/el1/public/cloudfile/io/";
     static const string LOCAL_PATH_DATA_SERVICE_EL2 = "/data/service/el2/";
     static const string LOCAL_PATH_HMDFS_DENTRY_CACHE = "/hmdfs/cache/account_cache/dentry_cache/";
     static const string LOCAL_PATH_HMDFS_CACHE_CLOUD = "/hmdfs/cache/account_cache/dentry_cache/cloud";
@@ -121,6 +122,14 @@ void CloudDaemon::OnStart()
     ConcurrentQueue::GetInstance().Init(ffrt_qos_user_initiated, MAX_CONCURRENT_THREADS);
     
     std::thread listenThread([&] {
+        // if (!filesystem::create_directories(IO_MESSAGE_DIR)) {
+        //     try {
+        //         filesystem::create_directories(IO_MESSAGE_DIR);
+        //     } catch (const filesystem::filesystem_error& e) {
+        //         LOGI("Mkdir for io failed");
+        //         return;
+        //     }
+        // }
         vector<string> bundleNameList = {};
         CloudDisk::AppStateObserverManager::GetInstance().SubscribeAppState(bundleNameList);
     });
diff --git a/test/unittests/cloud_disk/io_message_listener_test.cpp b/test/unittests/cloud_disk/io_message_listener_test.cpp
index 89faf55bb45687eb4413d3406c7b6a06067c4dea..82f0cae653eb607019e1a450f2c169380855ffc1 100644
--- a/test/unittests/cloud_disk/io_message_listener_test.cpp
+++ b/test/unittests/cloud_disk/io_message_listener_test.cpp
@@ -17,6 +17,7 @@
 
 #include <cstring>
 #include <fcntl.h>
+#include <fstream>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include <unistd.h>
@@ -38,6 +39,9 @@ const int32_t THREAD_SLEEP_TIME = 100;
 const int32_t FRONT_EVENT = 2;
 const int32_t BACKGROUND_EVENT = 4;
 const int32_t UNKNOWN_EVENT = 8;
+const string IO_REPORT_FILE = "/data/service/el1/public/cloudfile/io/wait_report_io_message.csv";
+const string IO_FILE = "/data/service/el1/public/cloudfile/io/io_message.csv";
+
 
 class IoMessageListenerTest : public testing::Test {
 public:
@@ -1338,4 +1342,413 @@ HWTEST_F(IoMessageListenerTest, OnReceiveEventTest005, TestSize.Level1)
     GTEST_LOG_(INFO) << "OnReceiveEventTest005 End";
 }
 
+/**
+ * @tc.name: Report001
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, Report001, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "Report001 Start";
+    for (int i = 0; i <= 101; i++) {
+        ioMessageManager_->ioTimes.push_back("tdd");
+        ioMessageManager_->ioBundleName.push_back("tdd");
+        ioMessageManager_->ioReadCharDiff.push_back("tdd");
+        ioMessageManager_->ioSyscReadDiff.push_back("tdd");
+        ioMessageManager_->ioReadBytesDiff.push_back("tdd");
+        ioMessageManager_->ioSyscOpenDiff.push_back("tdd");
+        ioMessageManager_->ioSyscStatDiff.push_back("tdd");
+        ioMessageManager_->ioResult.push_back("tdd");
+    }
+    try {
+        ioMessageManager_->Report();
+        EXPECT_FALSE(false);
+    } catch (...) {
+        EXPECT_FALSE(true);
+        GTEST_LOG_(INFO) << "Report001 ERROR";
+    }
+    GTEST_LOG_(INFO) << "Report001 End";
+}
+
+/**
+ * @tc.name: Report002
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, Report002, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "Report002 Start";
+    for (int i = 0; i <= 10; i++) {
+        ioMessageManager_->ioTimes.push_back("tdd");
+        ioMessageManager_->ioBundleName.push_back("tdd");
+        ioMessageManager_->ioReadCharDiff.push_back("tdd");
+        ioMessageManager_->ioSyscReadDiff.push_back("tdd");
+        ioMessageManager_->ioReadBytesDiff.push_back("tdd");
+        ioMessageManager_->ioSyscOpenDiff.push_back("tdd");
+        ioMessageManager_->ioSyscStatDiff.push_back("tdd");
+        ioMessageManager_->ioResult.push_back("tdd");
+    }
+    try {
+        ioMessageManager_->Report();
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "Report002 ERROR";
+    }
+    GTEST_LOG_(INFO) << "Report002 End";
+}
+
+/**
+ * @tc.name: PushData001
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, PushData001, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "PushData001 Start";
+    vector<string> fields;
+    try {
+        ioMessageManager_->PushData(fields);
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "PushData001 ERROR";
+    }
+    GTEST_LOG_(INFO) << "PushData001 End";
+}
+
+/**
+ * @tc.name: PushData002
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, PushData002, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "PushData002 Start";
+    vector<string> fields;
+    fields.push_back("tdd,tdd,tdd,tdd,tdd,tdd,tdd,tdd");
+    try {
+        ioMessageManager_->PushData(fields);
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "PushData002 ERROR";
+    }
+    GTEST_LOG_(INFO) << "PushData002 End";
+}
+
+/**
+ * @tc.name: PushData003
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, PushData003, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "PushData003 Start";
+    vector<string> fields;
+    fields.push_back("tdd,tdd,tdd,tdd,tdd,tdd,tdd,tdd,tdd");
+    try {
+        ioMessageManager_->PushData(fields);
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "PushData003 ERROR";
+    }
+    GTEST_LOG_(INFO) << "PushData003 End";
+}
+
+/**
+ * @tc.name: ReadAndReportIoMessage001
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, ReadAndReportIoMessage001, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ReadAndReportIoMessage001 Start";
+    
+    try {
+        if (filesystem::exists(IO_REPORT_FILE)) {
+            filesystem::remove(IO_REPORT_FILE);
+        }
+        ioMessageManager_->Report();
+        EXPECT_FALSE(false);
+    } catch (...) {
+        EXPECT_FALSE(true);
+        GTEST_LOG_(INFO) << "ReadAndReportIoMessage001 ERROR";
+    }
+    GTEST_LOG_(INFO) << "ReadAndReportIoMessage001 End";
+}
+
+/**
+ * @tc.name: ReadAndReportIoMessage002
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, ReadAndReportIoMessage002, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ReadAndReportIoMessage002 Start";
+    
+    try {
+        int fd = -1;
+        if (!filesystem::exists(IO_REPORT_FILE)) {
+            fd = open(IO_REPORT_FILE.c_str(), O_CREAT | O_WRONLY | O_TRUNC, 0644);
+            close(fd);
+        }
+
+        ioMessageManager_->ReadAndReportIoMessage();
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ReadAndReportIoMessage002 ERROR";
+    }
+    unlink(IO_REPORT_FILE.c_str());
+    GTEST_LOG_(INFO) << "ReadAndReportIoMessage002 End";
+}
+
+/**
+ * @tc.name: ReadAndReportIoMessage003
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, ReadAndReportIoMessage003, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ReadAndReportIoMessage003 Start";
+    
+    try {
+        int fd = -1;
+        if (!filesystem::exists(IO_REPORT_FILE)) {
+            fd = open(IO_REPORT_FILE.c_str(), O_CREAT | O_WRONLY | O_TRUNC, 0644);
+        }
+        string line1 = "tdd tdd tdd tdd tdd tdd tdd tdd\n";
+        write(fd, line1.c_str(), line1.size());
+        close(fd);
+
+        ioMessageManager_->ReadAndReportIoMessage();
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ReadAndReportIoMessage003 ERROR";
+    }
+    unlink(IO_REPORT_FILE.c_str());
+    GTEST_LOG_(INFO) << "ReadAndReportIoMessage003 End";
+}
+
+/**
+ * @tc.name: ReadAndReportIoMessage004
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, ReadAndReportIoMessage004, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ReadAndReportIoMessage004 Start";
+    
+    try {
+        int fd = -1;
+        if (!filesystem::exists(IO_REPORT_FILE)) {
+            fd = open(IO_REPORT_FILE.c_str(), O_CREAT | O_WRONLY | O_TRUNC, 0644);
+        }
+        string line1 = "tdd,tdd,tdd,tdd,tdd,tdd,tdd,tdd\n";
+        write(fd, line1.c_str(), line1.size());
+        close(fd);
+
+        ioMessageManager_->ReadAndReportIoMessage();
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ReadAndReportIoMessage004 ERROR";
+    }
+    unlink(IO_REPORT_FILE.c_str());
+    GTEST_LOG_(INFO) << "ReadAndReportIoMessage004 End";
+}
+
+/**
+ * @tc.name: ReadAndReportIoMessage005
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, ReadAndReportIoMessage005, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ReadAndReportIoMessage005 Start";
+    
+    try {
+        int fd = -1;
+        if (!filesystem::exists(IO_REPORT_FILE)) {
+            fd = open(IO_REPORT_FILE.c_str(), O_CREAT | O_WRONLY | O_TRUNC, 0644);
+        }
+        for (int i = 0; i <= 101; i++) {
+            string line = "tdd,tdd,tdd,tdd,tdd,tdd,tdd,tdd\n";
+            write(fd, line.c_str(), line.size());
+        }
+        close(fd);
+
+        ioMessageManager_->ReadAndReportIoMessage();
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ReadAndReportIoMessage005 ERROR";
+    }
+    unlink(IO_REPORT_FILE.c_str());
+    GTEST_LOG_(INFO) << "ReadAndReportIoMessage005 End";
+}
+
+/**
+ * @tc.name: CheckMaxSizeAndReport001
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, CheckMaxSizeAndReport001, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "CheckMaxSizeAndReport001 Start";
+    
+    try {
+        int fd = -1;
+        if (filesystem::exists(IO_FILE)) {
+            unlink(IO_FILE.c_str());
+        }
+
+        ioMessageManager_->CheckMaxSizeAndReport();
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "CheckMaxSizeAndReport001 ERROR";
+    }
+    GTEST_LOG_(INFO) << "CheckMaxSizeAndReport001 End";
+}
+
+/**
+ * @tc.name: CheckMaxSizeAndReport002
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, CheckMaxSizeAndReport002, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "CheckMaxSizeAndReport002 Start";
+    
+    try {
+        int fd = -1;
+        if (filesystem::exists(IO_FILE)) {
+            unlink(IO_FILE.c_str());
+        }
+        fd = open(IO_FILE.c_str(), O_CREAT | O_WRONLY | O_TRUNC, 0644);
+        string line = "tdd,tdd,tdd,tdd,tdd,tdd,tdd,tdd\n";
+        write(fd, line.c_str(), line.size());
+        close(fd);
+
+        ioMessageManager_->CheckMaxSizeAndReport();
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "CheckMaxSizeAndReport002 ERROR";
+    }
+    unlink(IO_FILE.c_str());
+    GTEST_LOG_(INFO) << "CheckMaxSizeAndReport002 End";
+}
+
+/**
+ * @tc.name: CheckMaxSizeAndReport003
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, CheckMaxSizeAndReport003, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "CheckMaxSizeAndReport003 Start";
+    
+    try {
+        int fd = -1;
+        if (filesystem::exists(IO_FILE)) {
+            unlink(IO_FILE.c_str());
+        }
+        fd = open(IO_FILE.c_str(), O_CREAT | O_WRONLY | O_TRUNC, 0644);
+        for (int i = 0; i <= 20000; i++) {
+            string line = "tdd,tdd,tdd,tdd,tdd,tdd,tdd,tdd\n";
+            write(fd, line.c_str(), line.size());
+        }
+        close(fd);
+
+        if (!filesystem::exists(IO_REPORT_FILE)) {
+            int fd = open(IO_REPORT_FILE.c_str(), O_CREAT | O_WRONLY | O_TRUNC, 0644);
+            close(fd);
+        }
+        ioMessageManager_->CheckMaxSizeAndReport();
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "CheckMaxSizeAndReport003 ERROR";
+    }
+    unlink(IO_FILE.c_str());
+    unlink(IO_REPORT_FILE.c_str());
+    GTEST_LOG_(INFO) << "CheckMaxSizeAndReport003 End";
+}
+
+/**
+ * @tc.name: CheckMaxSizeAndReport004
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, CheckMaxSizeAndReport004, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "CheckMaxSizeAndReport004 Start";
+    
+    try {
+        int fd = -1;
+        if (filesystem::exists(IO_FILE)) {
+            unlink(IO_FILE.c_str());
+        }
+        fd = open(IO_FILE.c_str(), O_CREAT | O_WRONLY | O_TRUNC, 0644);
+        for (int i = 0; i <= 20000; i++) {
+            string line = "tdd,tdd,tdd,tdd,tdd,tdd,tdd,tdd\n";
+            write(fd, line.c_str(), line.size());
+        }
+        close(fd);
+
+        if (filesystem::exists(IO_REPORT_FILE)) {
+            unlink(IO_REPORT_FILE.c_str());
+        }
+        ioMessageManager_->CheckMaxSizeAndReport();
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "CheckMaxSizeAndReport004 ERROR";
+    }
+    unlink(IO_FILE.c_str());
+    unlink(IO_REPORT_FILE.c_str());
+    GTEST_LOG_(INFO) << "CheckMaxSizeAndReport004 End";
+}
+
+/**
+ * @tc.name: CheckMaxSizeAndReport005
+ * @tc.desc: Report IO data
+ * @tc.type: FUNC
+ */
+HWTEST_F(IoMessageListenerTest, CheckMaxSizeAndReport005, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "CheckMaxSizeAndReport005 Start";
+    
+    try {
+        int fd = -1;
+        if (filesystem::exists(IO_FILE)) {
+            unlink(IO_FILE.c_str());
+        }
+        fd = open(IO_FILE.c_str(), O_CREAT | O_WRONLY | O_TRUNC, 0644);
+        for (int i = 0; i <= 20000; i++) {
+            string line = "tdd,tdd,tdd,tdd,tdd,tdd,tdd,tdd\n";
+            write(fd, line.c_str(), line.size());
+        }
+        close(fd);
+
+        if (filesystem::exists(IO_REPORT_FILE)) {
+            unlink(IO_REPORT_FILE.c_str());
+        }
+        ioMessageManager_->reportThreadRunning.store(true);
+        ioMessageManager_->CheckMaxSizeAndReport();
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "CheckMaxSizeAndReport005 ERROR";
+    }
+    unlink(IO_FILE.c_str());
+    unlink(IO_REPORT_FILE.c_str());
+    GTEST_LOG_(INFO) << "CheckMaxSizeAndReport005 End";
+}
+
 } // namespace OHOS::FileManagement::CloudDisk::Test
\ No newline at end of file