diff --git a/frameworks/innerkits/file_access/BUILD.gn b/frameworks/innerkits/file_access/BUILD.gn
index 6bd417ff821cca48a75408f3d77cdb57e1d7572a..1fd5425143ddaab43f594b741844a743e974514f 100644
--- a/frameworks/innerkits/file_access/BUILD.gn
+++ b/frameworks/innerkits/file_access/BUILD.gn
@@ -79,6 +79,7 @@ ohos_shared_library("file_access_extension_ability_kit") {
     "ability_runtime:runtime",
     "ability_runtime:wantagent_innerkits",
     "access_token:libaccesstoken_sdk",
+    "hitrace_native:hitrace_meter",
     "ipc:ipc_core",
     "ipc_js:rpc",
     "utils_base:utils",
diff --git a/frameworks/innerkits/file_access/src/file_access_ext_proxy.cpp b/frameworks/innerkits/file_access/src/file_access_ext_proxy.cpp
index 129d687d54585a4772b6fd838b654d5c41bab5a8..46a754421ce84381009fb7e909aa78647715ecc2 100644
--- a/frameworks/innerkits/file_access/src/file_access_ext_proxy.cpp
+++ b/frameworks/innerkits/file_access/src/file_access_ext_proxy.cpp
@@ -14,26 +14,32 @@
  */
 
 #include "file_access_ext_proxy.h"
+
 #include "file_access_framework_errno.h"
 #include "hilog_wrapper.h"
+#include "hitrace_meter.h"
 
 namespace OHOS {
 namespace FileAccessFwk {
 int FileAccessExtProxy::OpenFile(const Uri &uri, int flags)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "OpenFile");
     MessageParcel data;
     if (!data.WriteInterfaceToken(FileAccessExtProxy::GetDescriptor())) {
-        HILOG_ERROR("%{public}s WriteInterfaceToken failed", __func__);
+        HILOG_ERROR("WriteInterfaceToken failed");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
     if (!data.WriteParcelable(&uri)) {
-        HILOG_ERROR("%{public}s fail to WriteParcelable uri", __func__);
+        HILOG_ERROR("fail to WriteParcelable uri");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
     if (!data.WriteInt32(flags)) {
-        HILOG_ERROR("%{public}s fail to WriteString mode", __func__);
+        HILOG_ERROR("fail to WriteString mode");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
@@ -41,38 +47,47 @@ int FileAccessExtProxy::OpenFile(const Uri &uri, int flags)
     MessageOption option;
     int32_t err = Remote()->SendRequest(CMD_OPEN_FILE, data, reply, option);
     if (err != NO_ERROR) {
-        HILOG_ERROR("%{public}s fail to SendRequest. err: %d", __func__, err);
+        HILOG_ERROR("fail to SendRequest. err: %{public}d", err);
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
     int fd = reply.ReadFileDescriptor();
     if (fd <= ERR_ERROR) {
-        HILOG_ERROR("%{public}s fail to ReadFileDescriptor fd", __func__);
+        HILOG_ERROR("fail to ReadFileDescriptor fd");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
+
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return fd;
 }
 
 int FileAccessExtProxy::CreateFile(const Uri &parent, const std::string &displayName,  Uri &newFile)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CreateFile");
     MessageParcel data;
     if (!data.WriteInterfaceToken(FileAccessExtProxy::GetDescriptor())) {
-        HILOG_ERROR("%{public}s WriteInterfaceToken failed", __func__);
+        HILOG_ERROR("WriteInterfaceToken failed");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
     if (!data.WriteParcelable(&parent)) {
-        HILOG_ERROR("%{public}s fail to WriteParcelable parent", __func__);
+        HILOG_ERROR("fail to WriteParcelable parent");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
     if (!data.WriteString(displayName)) {
-        HILOG_ERROR("%{public}s fail to WriteString mode", __func__);
+        HILOG_ERROR("fail to WriteString mode");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
     if (!data.WriteParcelable(&newFile)) {
-        HILOG_ERROR("%{public}s fail to WriteParcelable newFile", __func__);
+        HILOG_ERROR("fail to WriteParcelable newFile");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
@@ -80,46 +95,55 @@ int FileAccessExtProxy::CreateFile(const Uri &parent, const std::string &display
     MessageOption option;
     int32_t err = Remote()->SendRequest(CMD_CREATE_FILE, data, reply, option);
     if (err != NO_ERROR) {
-        HILOG_ERROR("%{public}s fail to SendRequest. err: %d", __func__, err);
+        HILOG_ERROR("fail to SendRequest. err: %{public}d", err);
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
     int ret = reply.ReadInt32();
     if (ret < ERR_OK) {
-        HILOG_ERROR("%{public}s fail to ReadInt32 ret", __func__);
+        HILOG_ERROR("fail to ReadInt32 ret");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
     std::unique_ptr<Uri> tempUri(reply.ReadParcelable<Uri>());
     if (!tempUri) {
-        HILOG_ERROR("%{public}s ReadParcelable value is nullptr.", __func__);
+        HILOG_ERROR("ReadParcelable value is nullptr.");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
     newFile = Uri(*tempUri);
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return ret;
 }
 
 int FileAccessExtProxy::Mkdir(const Uri &parent, const std::string &displayName, Uri &newFile)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "Mkdir");
     MessageParcel data;
     if (!data.WriteInterfaceToken(FileAccessExtProxy::GetDescriptor())) {
-        HILOG_ERROR("%{public}s WriteInterfaceToken failed", __func__);
+        HILOG_ERROR("WriteInterfaceToken failed");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
     if (!data.WriteParcelable(&parent)) {
-        HILOG_ERROR("%{public}s fail to WriteParcelable parent", __func__);
+        HILOG_ERROR("fail to WriteParcelable parent");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
     if (!data.WriteString(displayName)) {
-        HILOG_ERROR("%{public}s fail to WriteString displayName", __func__);
+        HILOG_ERROR("fail to WriteString displayName");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
     if (!data.WriteParcelable(&newFile)) {
-        HILOG_ERROR("%{public}s fail to WriteParcelable newFile", __func__);
+        HILOG_ERROR("fail to WriteParcelable newFile");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
@@ -127,37 +151,44 @@ int FileAccessExtProxy::Mkdir(const Uri &parent, const std::string &displayName,
     MessageOption option;
     int32_t err = Remote()->SendRequest(CMD_MKDIR, data, reply, option);
     if (err != NO_ERROR) {
-        HILOG_ERROR("%{public}s fail to SendRequest. err: %d", __func__, err);
+        HILOG_ERROR("fail to SendRequest. err: %{public}d", err);
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
     int ret = reply.ReadInt32();
     if (ret < ERR_OK) {
-        HILOG_ERROR("%{public}s fail to ReadInt32 ret", __func__);
+        HILOG_ERROR("fail to ReadInt32 ret");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
     std::unique_ptr<Uri> tempUri(reply.ReadParcelable<Uri>());
     if (!tempUri) {
-        HILOG_ERROR("%{public}s ReadParcelable value is nullptr.", __func__);
+        HILOG_ERROR("ReadParcelable value is nullptr.");
         ret = ERR_IPC_ERROR;
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ret;
     }
 
     newFile = Uri(*tempUri);
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return ret;
 }
 
 int FileAccessExtProxy::Delete(const Uri &sourceFile)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "Delete");
     MessageParcel data;
     if (!data.WriteInterfaceToken(FileAccessExtProxy::GetDescriptor())) {
-        HILOG_ERROR("%{public}s WriteInterfaceToken failed", __func__);
+        HILOG_ERROR("WriteInterfaceToken failed");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
     if (!data.WriteParcelable(&sourceFile)) {
-        HILOG_ERROR("%{public}s fail to WriteParcelable sourceFile", __func__);
+        HILOG_ERROR("fail to WriteParcelable sourceFile");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
@@ -165,39 +196,47 @@ int FileAccessExtProxy::Delete(const Uri &sourceFile)
     MessageOption option;
     int32_t err = Remote()->SendRequest(CMD_DELETE, data, reply, option);
     if (err != NO_ERROR) {
-        HILOG_ERROR("%{public}s fail to SendRequest. err: %d", __func__, err);
+        HILOG_ERROR("fail to SendRequest. err: %{public}d", err);
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
     int ret = reply.ReadInt32();
     if (ret < ERR_OK) {
-        HILOG_ERROR("%{public}s fail to ReadInt32 ret", __func__);
+        HILOG_ERROR("fail to ReadInt32 ret");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return ret;
 }
 
 int FileAccessExtProxy::Move(const Uri &sourceFile, const Uri &targetParent, Uri &newFile)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "Move");
     MessageParcel data;
     if (!data.WriteInterfaceToken(FileAccessExtProxy::GetDescriptor())) {
-        HILOG_ERROR(" %{public}s WriteInterfaceToken failed", __func__);
+        HILOG_ERROR("WriteInterfaceToken failed");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
     if (!data.WriteParcelable(&sourceFile)) {
-        HILOG_ERROR(" %{public}s fail to WriteParcelable sourceFile", __func__);
+        HILOG_ERROR("fail to WriteParcelable sourceFile");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
     if (!data.WriteParcelable(&targetParent)) {
-        HILOG_ERROR(" %{public}s fail to WriteParcelable targetParent", __func__);
+        HILOG_ERROR("fail to WriteParcelable targetParent");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
     if (!data.WriteParcelable(&newFile)) {
-        HILOG_ERROR(" %{public}s fail to WriteParcelable newFile", __func__);
+        HILOG_ERROR("fail to WriteParcelable newFile");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
@@ -205,46 +244,55 @@ int FileAccessExtProxy::Move(const Uri &sourceFile, const Uri &targetParent, Uri
     MessageOption option;
     int32_t err = Remote()->SendRequest(CMD_MOVE, data, reply, option);
     if (err != NO_ERROR) {
-        HILOG_ERROR(" %{public}s fail to SendRequest. err: %d", __func__, err);
+        HILOG_ERROR("fail to SendRequest. err: %{public}d", err);
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
     int ret = reply.ReadInt32();
     if (ret < ERR_OK) {
-        HILOG_ERROR(" %{public}s fail to ReadInt32 ret", __func__);
+        HILOG_ERROR("fail to ReadInt32 ret");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ret;
     }
 
     std::unique_ptr<Uri> tempUri(reply.ReadParcelable<Uri>());
     if (!tempUri) {
-        HILOG_ERROR(" %{public}s ReadParcelable value is nullptr.", __func__);
+        HILOG_ERROR("ReadParcelable value is nullptr.");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
     newFile = Uri(*tempUri);
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return ret;
 }
 
 int FileAccessExtProxy::Rename(const Uri &sourceFile, const std::string &displayName, Uri &newFile)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "Rename");
     MessageParcel data;
     if (!data.WriteInterfaceToken(FileAccessExtProxy::GetDescriptor())) {
-        HILOG_ERROR("%{public}s WriteInterfaceToken failed", __func__);
+        HILOG_ERROR("WriteInterfaceToken failed");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
     if (!data.WriteParcelable(&sourceFile)) {
-        HILOG_ERROR("%{public}s fail to WriteParcelable sourceFile", __func__);
+        HILOG_ERROR("fail to WriteParcelable sourceFile");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
     if (!data.WriteString(displayName)) {
-        HILOG_ERROR("%{public}s fail to WriteString displayName", __func__);
+        HILOG_ERROR("fail to WriteString displayName");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
     if (!data.WriteParcelable(&newFile)) {
-        HILOG_ERROR("%{public}s fail to WriteParcelable newFile", __func__);
+        HILOG_ERROR("fail to WriteParcelable newFile");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
@@ -252,37 +300,44 @@ int FileAccessExtProxy::Rename(const Uri &sourceFile, const std::string &display
     MessageOption option;
     int32_t err = Remote()->SendRequest(CMD_RENAME, data, reply, option);
     if (err != NO_ERROR) {
-        HILOG_ERROR("%{public}s fail to SendRequest. err: %d", __func__, err);
+        HILOG_ERROR("fail to SendRequest. err: %{public}d", err);
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
     int ret = reply.ReadInt32();
     if (ret < ERR_OK) {
-        HILOG_ERROR("%{public}s fail to ReadInt32 ret", __func__);
+        HILOG_ERROR("fail to ReadInt32 ret");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
     std::unique_ptr<Uri> tempUri(reply.ReadParcelable<Uri>());
     if (!tempUri) {
-        HILOG_ERROR("%{public}s ReadParcelable value is nullptr.", __func__);
+        HILOG_ERROR("ReadParcelable value is nullptr.");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
     newFile = Uri(*tempUri);
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return ret;
 }
 
 std::vector<FileInfo> FileAccessExtProxy::ListFile(const Uri &sourceFile)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "ListFile");
     std::vector<FileInfo> vec;
     MessageParcel data;
     if (!data.WriteInterfaceToken(FileAccessExtProxy::GetDescriptor())) {
-        HILOG_ERROR("%{public}s WriteInterfaceToken failed", __func__);
+        HILOG_ERROR("WriteInterfaceToken failed");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return vec;
     }
 
     if (!data.WriteParcelable(&sourceFile)) {
-        HILOG_ERROR("%{public}s fail to WriteParcelable sourceFileUri", __func__);
+        HILOG_ERROR("fail to WriteParcelable sourceFileUri");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return vec;
     }
 
@@ -290,7 +345,8 @@ std::vector<FileInfo> FileAccessExtProxy::ListFile(const Uri &sourceFile)
     MessageOption option;
     int32_t err = Remote()->SendRequest(CMD_LIST_FILE, data, reply, option);
     if (err != NO_ERROR) {
-        HILOG_ERROR("%{public}s fail to SendRequest. err: %d", __func__, err);
+        HILOG_ERROR("fail to SendRequest. err: %{public}d", err);
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return vec;
     }
 
@@ -303,15 +359,18 @@ std::vector<FileInfo> FileAccessExtProxy::ListFile(const Uri &sourceFile)
         }
     }
 
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return vec;
 }
 
 std::vector<DeviceInfo> FileAccessExtProxy::GetRoots()
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "GetRoots");
     std::vector<DeviceInfo> vec;
     MessageParcel data;
     if (!data.WriteInterfaceToken(FileAccessExtProxy::GetDescriptor())) {
-        HILOG_ERROR("%{public}s WriteInterfaceToken failed", __func__);
+        HILOG_ERROR("WriteInterfaceToken failed");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return vec;
     }
 
@@ -319,7 +378,8 @@ std::vector<DeviceInfo> FileAccessExtProxy::GetRoots()
     MessageOption option;
     int32_t err = Remote()->SendRequest(CMD_GET_ROOTS, data, reply, option);
     if (err != NO_ERROR) {
-        HILOG_ERROR("%{public}s fail to SendRequest. err: %d", __func__, err);
+        HILOG_ERROR("fail to SendRequest. err: %{public}d", err);
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return vec;
     }
 
@@ -332,6 +392,7 @@ std::vector<DeviceInfo> FileAccessExtProxy::GetRoots()
         }
     }
 
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return vec;
 }
 } // namespace FileAccessFwk
diff --git a/frameworks/innerkits/file_access/src/file_access_ext_stub.cpp b/frameworks/innerkits/file_access/src/file_access_ext_stub.cpp
index a7a5b8c1c795288626130bcc3b6db765d25e7a6d..ddc2ee80dbd9a4f2cda1fe3aacc2db89dac76b80 100644
--- a/frameworks/innerkits/file_access/src/file_access_ext_stub.cpp
+++ b/frameworks/innerkits/file_access/src/file_access_ext_stub.cpp
@@ -18,6 +18,7 @@
 #include "accesstoken_kit.h"
 #include "file_access_framework_errno.h"
 #include "hilog_wrapper.h"
+#include "hitrace_meter.h"
 #include "ipc_skeleton.h"
 
 namespace OHOS {
@@ -45,231 +46,286 @@ FileAccessExtStub::~FileAccessExtStub()
 int FileAccessExtStub::OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply,
     MessageOption& option)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "OnRemoteRequest");
     if (!CheckCallingPermission(FILE_ACCESS_PERMISSION)) {
         HILOG_ERROR("permission error");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_PERMISSION_DENIED;
     }
 
     std::u16string descriptor = FileAccessExtStub::GetDescriptor();
     std::u16string remoteDescriptor = data.ReadInterfaceToken();
     if (descriptor != remoteDescriptor) {
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_INVALID_STATE;
     }
 
     const auto &itFunc = stubFuncMap_.find(code);
     if (itFunc != stubFuncMap_.end()) {
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return (this->*(itFunc->second))(data, reply);
     }
 
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
 }
 
 ErrCode FileAccessExtStub::CmdOpenFile(MessageParcel &data, MessageParcel &reply)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CmdOpenFile");
     std::shared_ptr<Uri> uri(data.ReadParcelable<Uri>());
     if (uri == nullptr) {
         HILOG_ERROR("uri is nullptr");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_INVALID_URI;
     }
 
     int flags = data.ReadInt32();
     if (flags < 0) {
         HILOG_ERROR("flags is invalid");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_ERROR;
     }
 
     int fd = OpenFile(*uri, flags);
     if (fd < 0) {
         HILOG_ERROR("OpenFile fail, fd is %{pubilc}d", fd);
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_INVALID_FD;
     }
 
     if (!reply.WriteFileDescriptor(fd)) {
         HILOG_ERROR("fail to WriteFileDescriptor fd");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
+
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return ERR_OK;
 }
 
 ErrCode FileAccessExtStub::CmdCreateFile(MessageParcel &data, MessageParcel &reply)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CmdCreateFile");
     std::shared_ptr<Uri> parent(data.ReadParcelable<Uri>());
     if (parent == nullptr) {
         HILOG_ERROR("parent is nullptr");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_INVALID_URI;
     }
 
     std::string displayName = data.ReadString();
     if (displayName.empty()) {
         HILOG_ERROR("displayName is nullptr");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_INVALID_PARAM;
     }
 
     std::shared_ptr<Uri> fileNew(data.ReadParcelable<Uri>());
     if (fileNew == nullptr) {
         HILOG_ERROR("fileNew is nullptr");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_INVALID_URI;
     }
 
     int ret = CreateFile(*parent, displayName, *fileNew);
     if (ret < 0) {
         HILOG_ERROR("CreateFile fail, ret is %{pubilc}d", ret);
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_FILEIO_FAIL;
     }
 
     if (!reply.WriteInt32(ret)) {
         HILOG_ERROR("fail to WriteInt32 ret");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
     if (!reply.WriteParcelable(&(*fileNew))) {
         HILOG_ERROR("fail to WriteParcelable type");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
+
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return ERR_OK;
 }
 
 ErrCode FileAccessExtStub::CmdMkdir(MessageParcel &data, MessageParcel &reply)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CmdMkdir");
     std::shared_ptr<Uri> parent(data.ReadParcelable<Uri>());
     if (parent == nullptr) {
         HILOG_ERROR("parent is nullptr");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_INVALID_URI;
     }
 
     std::string displayName = data.ReadString();
     if (displayName.empty()) {
         HILOG_ERROR("mode is nullptr");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_INVALID_PARAM;
     }
 
     std::shared_ptr<Uri> fileNew(data.ReadParcelable<Uri>());
     if (fileNew == nullptr) {
         HILOG_ERROR("fileNew is nullptr");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_INVALID_URI;
     }
 
     int ret = Mkdir(*parent, displayName, *fileNew);
     if (ret < 0) {
         HILOG_ERROR("Mkdir fail, ret is %{pubilc}d", ret);
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_FILEIO_FAIL;
     }
 
     if (!reply.WriteInt32(ret)) {
         HILOG_ERROR("fail to WriteInt32 ret");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
     if (!reply.WriteParcelable(&(*fileNew))) {
         HILOG_ERROR("fail to WriteParcelable type");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
+
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return ERR_OK;
 }
 
 ErrCode FileAccessExtStub::CmdDelete(MessageParcel &data, MessageParcel &reply)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CmdDelete");
     std::shared_ptr<Uri> uri(data.ReadParcelable<Uri>());
     if (uri == nullptr) {
         HILOG_ERROR("uri is nullptr");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_INVALID_URI;
     }
 
     int ret = Delete(*uri);
     if (ret < 0) {
         HILOG_ERROR("Delete fail, ret is %{pubilc}d", ret);
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_FILEIO_FAIL;
     }
 
     if (!reply.WriteInt32(ret)) {
         HILOG_ERROR("fail to WriteFileDescriptor ret");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
+
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return ERR_OK;
 }
 
 ErrCode FileAccessExtStub::CmdMove(MessageParcel &data, MessageParcel &reply)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CmdMove");
     std::shared_ptr<Uri> sourceFile(data.ReadParcelable<Uri>());
     if (sourceFile == nullptr) {
         HILOG_ERROR("sourceFile is nullptr");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_INVALID_URI;
     }
 
     std::shared_ptr<Uri> targetParent(data.ReadParcelable<Uri>());
     if (targetParent == nullptr) {
         HILOG_ERROR("targetParent is nullptr");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_INVALID_URI;
     }
 
     std::shared_ptr<Uri> fileNew(data.ReadParcelable<Uri>());
     if (fileNew == nullptr) {
         HILOG_ERROR(" fileNew is nullptr");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_INVALID_URI;
     }
 
     int ret = Move(*sourceFile, *targetParent, *fileNew);
     if (ret < 0) {
         HILOG_ERROR("Move fail, ret is %{pubilc}d", ret);
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_FILEIO_FAIL;
     }
 
     if (!reply.WriteInt32(ret)) {
         HILOG_ERROR("fail to WriteInt32 ret");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
     if (!reply.WriteParcelable(&(*fileNew))) {
         HILOG_ERROR("fail to WriteParcelable type");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
+
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return ERR_OK;
 }
 
 ErrCode FileAccessExtStub::CmdRename(MessageParcel &data, MessageParcel &reply)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CmdRename");
     std::shared_ptr<Uri> sourceFile(data.ReadParcelable<Uri>());
     if (sourceFile == nullptr) {
         HILOG_ERROR("sourceFileUri is nullptr");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_INVALID_URI;
     }
 
     std::string displayName = data.ReadString();
     if (displayName.empty()) {
         HILOG_ERROR("mode is nullptr");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_INVALID_PARAM;
     }
 
     std::shared_ptr<Uri> fileNew(data.ReadParcelable<Uri>());
     if (fileNew == nullptr) {
         HILOG_ERROR("fileUriNew is nullptr");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_INVALID_URI;
     }
 
     int ret = Rename(*sourceFile, displayName, *fileNew);
     if (ret < 0) {
         HILOG_ERROR("Rename fail, ret is %{pubilc}d", ret);
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_FILEIO_FAIL;
     }
 
     if (!reply.WriteInt32(ret)) {
         HILOG_ERROR("fail to WriteInt32 ret");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
     if (!reply.WriteParcelable(&(*fileNew))) {
         HILOG_ERROR("fail to WriteParcelable type");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return ERR_OK;
 }
 
 ErrCode FileAccessExtStub::CmdListFile(MessageParcel &data, MessageParcel &reply)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CmdListFile");
     std::shared_ptr<Uri> uri(data.ReadParcelable<Uri>());
     if (uri == nullptr) {
         HILOG_ERROR("uri is nullptr");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_INVALID_URI;
     }
 
@@ -277,46 +333,57 @@ ErrCode FileAccessExtStub::CmdListFile(MessageParcel &data, MessageParcel &reply
     uint64_t count {vec.size()};
     if (!reply.WriteUint64(count)) {
         HILOG_ERROR("fail to WriteInt32 count");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
     for (uint64_t i = 0; i < count; i++) {
         if (!reply.WriteParcelable(&vec[i])) {
             HILOG_ERROR("fail to WriteParcelable vec");
+            FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
             return ERR_IPC_ERROR;
         }
     }
 
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return ERR_OK;
 }
 
 ErrCode FileAccessExtStub::CmdGetRoots(MessageParcel &data, MessageParcel &reply)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CmdGetRoots");
     std::vector<DeviceInfo> vec = GetRoots();
     uint64_t count {vec.size()};
     if (!reply.WriteUint64(count)) {
         HILOG_ERROR("fail to WriteInt32 count");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ERR_IPC_ERROR;
     }
 
     for (uint64_t i = 0; i < count; i++) {
         if (!reply.WriteParcelable(&vec[i])) {
             HILOG_ERROR("fail to WriteParcelable ret");
+            FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
             return ERR_IPC_ERROR;
         }
     }
 
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return ERR_OK;
 }
 
 bool FileAccessExtStub::CheckCallingPermission(const std::string &permission)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CmdGetRoots");
     Security::AccessToken::AccessTokenID tokenCaller = IPCSkeleton::GetCallingTokenID();
     int res = Security::AccessToken::AccessTokenKit::VerifyAccessToken(tokenCaller, permission);
     if (res != Security::AccessToken::PermissionState::PERMISSION_GRANTED) {
         HILOG_ERROR("FileAccessExtStub::CheckCallingPermission have no fileAccess permission");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return false;
     }
+
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return true;
 }
 } // namespace FileAccessFwk
diff --git a/frameworks/innerkits/file_access/src/file_access_ext_stub_impl.cpp b/frameworks/innerkits/file_access/src/file_access_ext_stub_impl.cpp
index d7355fa734cf9a1e6755ea6de5335fd3ac5100cc..26fd26e2976157ed40236435964b6e91bd3c8ec8 100644
--- a/frameworks/innerkits/file_access/src/file_access_ext_stub_impl.cpp
+++ b/frameworks/innerkits/file_access/src/file_access_ext_stub_impl.cpp
@@ -15,8 +15,9 @@
 
 #include "file_access_ext_stub_impl.h"
 
-#include "hilog_wrapper.h"
 #include "file_access_framework_errno.h"
+#include "hilog_wrapper.h"
+#include "hitrace_meter.h"
 
 namespace OHOS {
 namespace FileAccessFwk {
@@ -27,99 +28,129 @@ std::shared_ptr<FileAccessExtAbility> FileAccessExtStubImpl::GetOwner()
 
 int FileAccessExtStubImpl::OpenFile(const Uri &uri, int flags)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "OpenFile");
     int ret = ERR_ERROR;
     auto extension = GetOwner();
     if (extension == nullptr) {
         HILOG_ERROR("get extension failed.");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ret;
     }
+
     ret = extension->OpenFile(uri, flags);
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return ret;
 }
 
 int FileAccessExtStubImpl::CreateFile(const Uri &parent, const std::string &displayName,  Uri &newFile)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CreateFile");
     int ret = ERR_ERROR;
     auto extension = GetOwner();
     if (extension == nullptr) {
         HILOG_ERROR("get extension failed.");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ret;
     }
+
     ret = extension->CreateFile(parent, displayName, newFile);
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return ret;
 }
 
 int FileAccessExtStubImpl::Mkdir(const Uri &parent, const std::string &displayName, Uri &newFile)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "Mkdir");
     int ret = ERR_ERROR;
     auto extension = GetOwner();
     if (extension == nullptr) {
         HILOG_ERROR("get extension failed.");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ret;
     }
+
     ret = extension->Mkdir(parent, displayName, newFile);
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return ret;
 }
 
 int FileAccessExtStubImpl::Delete(const Uri &sourceFile)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "Delete");
     int ret = ERR_ERROR;
     auto extension = GetOwner();
     if (extension == nullptr) {
         HILOG_ERROR("get extension failed.");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ret;
     }
+
     ret = extension->Delete(sourceFile);
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return ret;
 }
 
 int FileAccessExtStubImpl::Move(const Uri &sourceFile, const Uri &targetParent, Uri &newFile)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "Move");
     int ret = ERR_ERROR;
     auto extension = GetOwner();
     if (extension == nullptr) {
         HILOG_ERROR("get extension failed.");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ret;
     }
+
     ret = extension->Move(sourceFile, targetParent, newFile);
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return ret;
 }
 
 int FileAccessExtStubImpl::Rename(const Uri &sourceFile, const std::string &displayName, Uri &newFile)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "Rename");
     int ret = ERR_ERROR;
     auto extension = GetOwner();
     if (extension == nullptr) {
         HILOG_ERROR("get extension failed.");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ret;
     }
+
     ret = extension->Rename(sourceFile, displayName, newFile);
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return ret;
 }
 
 std::vector<FileInfo> FileAccessExtStubImpl::ListFile(const Uri &sourceFile)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "ListFile");
     std::vector<FileInfo> vec;
     auto extension = GetOwner();
     if (extension == nullptr) {
         HILOG_ERROR("get extension failed.");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return vec;
     }
 
     vec = extension->ListFile(sourceFile);
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return vec;
 }
 
 std::vector<DeviceInfo> FileAccessExtStubImpl::GetRoots()
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "GetRoots");
     std::vector<DeviceInfo> vec;
     auto extension = GetOwner();
     if (extension == nullptr) {
         HILOG_ERROR("get extension failed.");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return vec;
     }
 
     vec = extension->GetRoots();
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return vec;
 }
 } // namespace FileAccessFwk
diff --git a/frameworks/innerkits/file_access/src/file_access_helper.cpp b/frameworks/innerkits/file_access/src/file_access_helper.cpp
index 6e04cb8e01c379bba13bbf655de3cff069e5719e..39dd4886d3e169e81db4e2939bdfe224255cb2bc 100644
--- a/frameworks/innerkits/file_access/src/file_access_helper.cpp
+++ b/frameworks/innerkits/file_access/src/file_access_helper.cpp
@@ -17,6 +17,7 @@
 
 #include "file_access_framework_errno.h"
 #include "hilog_wrapper.h"
+#include "hitrace_meter.h"
 #include "ifile_access_ext_base.h"
 
 namespace OHOS {
@@ -87,7 +88,7 @@ std::shared_ptr<FileAccessHelper> FileAccessHelper::Creator(
     const std::shared_ptr<OHOS::AbilityRuntime::Context> &context, const AAFwk::Want &want)
 {
     if (context == nullptr) {
-        HILOG_ERROR("%{public}s failed, context == nullptr", __func__);
+        HILOG_ERROR("failed, context == nullptr");
         return nullptr;
     }
 
@@ -99,12 +100,12 @@ std::shared_ptr<FileAccessHelper> FileAccessHelper::Creator(
 
     fileAccessExtProxy = fileAccessExtConnection->GetFileExtProxy();
     if (fileAccessExtProxy == nullptr) {
-        HILOG_WARN("%{public}s get invalid fileAccessExtProxy", __func__);
+        HILOG_WARN("get invalid fileAccessExtProxy");
     }
 
     FileAccessHelper *ptrFileAccessHelper = new (std::nothrow) FileAccessHelper(context, want, fileAccessExtProxy);
     if (ptrFileAccessHelper == nullptr) {
-        HILOG_ERROR("%{public}s failed, create FileAccessHelper failed", __func__);
+        HILOG_ERROR(" failed, create FileAccessHelper failed");
         return nullptr;
     }
 
@@ -132,7 +133,7 @@ bool FileAccessHelper::GetProxy()
     }
 
     if (fileAccessExtProxy_ == nullptr) {
-        HILOG_ERROR("%{public}s failed with invalid fileAccessExtProxy_", __func__);
+        HILOG_ERROR("failed with invalid fileAccessExtProxy_");
         return false;
     }
     return true;
@@ -140,97 +141,121 @@ bool FileAccessHelper::GetProxy()
 
 int FileAccessHelper::OpenFile(Uri &uri, int flags)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "OpenFile");
     int fd = ERR_ERROR;
     if (!GetProxy()) {
-        HILOG_ERROR("%{public}s failed with invalid fileAccessExtProxy_", __func__);
+        HILOG_ERROR("failed with invalid fileAccessExtProxy_");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return fd;
     }
 
     fd = fileAccessExtProxy_->OpenFile(uri, flags);
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return fd;
 }
 
 int FileAccessHelper::CreateFile(Uri &parent, const std::string &displayName, Uri &newFile)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CreateFile");
     int index = ERR_ERROR;
     if (!GetProxy()) {
-        HILOG_ERROR("%{public}s failed with invalid fileAccessExtProxy_", __func__);
+        HILOG_ERROR("failed with invalid fileAccessExtProxy_");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return index;
     }
 
     index = fileAccessExtProxy_->CreateFile(parent, displayName, newFile);
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return index;
 }
 
 int FileAccessHelper::Mkdir(Uri &parent, const std::string &displayName, Uri &newDir)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "Mkdir");
     int index = ERR_ERROR;
     if (fileAccessExtProxy_ == nullptr) {
-        HILOG_ERROR("%{public}s failed with invalid fileAccessExtProxy_", __func__);
+        HILOG_ERROR("failed with invalid fileAccessExtProxy_");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return index;
     }
 
     index = fileAccessExtProxy_->Mkdir(parent, displayName, newDir);
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return index;
 }
 
 int FileAccessHelper::Delete(Uri &selectFile)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "Delete");
     int index = ERR_ERROR;
     if (!GetProxy()) {
-        HILOG_ERROR("%{public}s failed with invalid fileAccessExtProxy_", __func__);
+        HILOG_ERROR("failed with invalid fileAccessExtProxy_");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return index;
     }
 
     index = fileAccessExtProxy_->Delete(selectFile);
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return index;
 }
 
 int FileAccessHelper::Move(Uri &sourceFile, Uri &targetParent, Uri &newFile)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "Move");
     int index = ERR_ERROR;
     if (!GetProxy()) {
-        HILOG_ERROR("%{public}s failed with invalid fileAccessExtProxy_", __func__);
+        HILOG_ERROR("failed with invalid fileAccessExtProxy_");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return index;
     }
 
     index = fileAccessExtProxy_->Move(sourceFile, targetParent, newFile);
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return index;
 }
 
 int FileAccessHelper::Rename(Uri &sourceFile, const std::string &displayName, Uri &newFile)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "Rename");
     int index = ERR_ERROR;
     if (!GetProxy()) {
-        HILOG_ERROR("%{public}s failed with invalid fileAccessExtProxy_", __func__);
+        HILOG_ERROR("failed with invalid fileAccessExtProxy_");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return index;
     }
 
     index = fileAccessExtProxy_->Rename(sourceFile, displayName, newFile);
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return index;
 }
 
 std::vector<FileInfo> FileAccessHelper::ListFile(Uri &sourceFile)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "ListFile");
     std::vector<FileInfo> results;
     if (!GetProxy()) {
-        HILOG_ERROR("%{public}s failed with invalid fileAccessExtProxy_", __func__);
+        HILOG_ERROR("failed with invalid fileAccessExtProxy_");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return results;
     }
 
     results = fileAccessExtProxy_->ListFile(sourceFile);
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return results;
 }
 
 std::vector<DeviceInfo> FileAccessHelper::GetRoots()
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "GetRoots");
     std::vector<DeviceInfo> results;
     if (!GetProxy()) {
-        HILOG_ERROR("%{public}s failed with invalid fileAccessExtProxy_", __func__);
+        HILOG_ERROR("failed with invalid fileAccessExtProxy_");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return results;
     }
 
     results = fileAccessExtProxy_->GetRoots();
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return results;
 }
 
diff --git a/frameworks/innerkits/file_access/src/js_file_access_ext_ability.cpp b/frameworks/innerkits/file_access/src/js_file_access_ext_ability.cpp
index 9bdefbef080602a6182f5b3d416f5de4723682bf..30764f8d05040b5c9eec9b73f67c9335fc126a7d 100644
--- a/frameworks/innerkits/file_access/src/js_file_access_ext_ability.cpp
+++ b/frameworks/innerkits/file_access/src/js_file_access_ext_ability.cpp
@@ -21,6 +21,7 @@
 #include "file_access_ext_stub_impl.h"
 #include "file_access_framework_errno.h"
 #include "hilog_wrapper.h"
+#include "hitrace_meter.h"
 #include "ipc_skeleton.h"
 #include "js_runtime.h"
 #include "js_runtime_utils.h"
@@ -55,11 +56,13 @@ void JsFileAccessExtAbility::Init(const std::shared_ptr<AbilityLocalRecord> &rec
     const std::shared_ptr<OHOSApplication> &application, std::shared_ptr<AbilityHandler> &handler,
     const sptr<IRemoteObject> &token)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "Init");
     FileAccessExtAbility::Init(record, application, handler, token);
     std::string srcPath = "";
     GetSrcPath(srcPath);
     if (srcPath.empty()) {
-        HILOG_ERROR("%{public}s Failed to get srcPath", __func__);
+        HILOG_ERROR("Failed to get srcPath");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return;
     }
 
@@ -69,18 +72,24 @@ void JsFileAccessExtAbility::Init(const std::shared_ptr<AbilityLocalRecord> &rec
 
     jsObj_ = jsRuntime_.LoadModule(moduleName, srcPath);
     if (jsObj_ == nullptr) {
-        HILOG_ERROR("%{public}s Failed to get jsObj_", __func__);
+        HILOG_ERROR("Failed to get jsObj_");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return;
     }
+
     NativeObject* obj = ConvertNativeValueTo<NativeObject>(jsObj_->Get());
     if (obj == nullptr) {
-        HILOG_ERROR("%{public}s Failed to get JsFileAccessExtAbility object", __func__);
+        HILOG_ERROR("Failed to get JsFileAccessExtAbility object");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return;
     }
+
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
 }
 
 void JsFileAccessExtAbility::OnStart(const AAFwk::Want &want)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "OnStart");
     Extension::OnStart(want);
     HandleScope handleScope(jsRuntime_);
     napi_env env = reinterpret_cast<napi_env>(&jsRuntime_.GetNativeEngine());
@@ -88,25 +97,32 @@ void JsFileAccessExtAbility::OnStart(const AAFwk::Want &want)
     NativeValue* nativeWant = reinterpret_cast<NativeValue*>(napiWant);
     NativeValue* argv[] = {nativeWant};
     CallObjectMethod("onCreate", argv, ARGC_ONE);
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
 }
 
 sptr<IRemoteObject> JsFileAccessExtAbility::OnConnect(const AAFwk::Want &want)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "OnConnect");
     Extension::OnConnect(want);
     sptr<FileAccessExtStubImpl> remoteObject = new (std::nothrow) FileAccessExtStubImpl(
         std::static_pointer_cast<JsFileAccessExtAbility>(shared_from_this()),
         reinterpret_cast<napi_env>(&jsRuntime_.GetNativeEngine()));
     if (remoteObject == nullptr) {
-        HILOG_ERROR("%{public}s No memory allocated for FileExtStubImpl", __func__);
+        HILOG_ERROR("No memory allocated for FileExtStubImpl");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return nullptr;
     }
+
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return remoteObject->AsObject();
 }
 
 NativeValue* JsFileAccessExtAbility::CallObjectMethod(const char* name, NativeValue* const* argv, size_t argc)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CallObjectMethod");
     if (!jsObj_) {
         HILOG_ERROR("JsFileAccessExtAbility::CallObjectMethod jsObj Not found FileAccessExtAbility.js");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return nullptr;
     }
 
@@ -115,53 +131,69 @@ NativeValue* JsFileAccessExtAbility::CallObjectMethod(const char* name, NativeVa
 
     NativeValue* value = jsObj_->Get();
     if (value == nullptr) {
-        HILOG_ERROR("%{public}s Failed to get FileAccessExtAbility value", __func__);
+        HILOG_ERROR("Failed to get FileAccessExtAbility value");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return nullptr;
     }
 
     NativeObject* obj = ConvertNativeValueTo<NativeObject>(value);
     if (obj == nullptr) {
-        HILOG_ERROR("%{public}s Failed to get FileAccessExtAbility object", __func__);
+        HILOG_ERROR("Failed to get FileAccessExtAbility object");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return nullptr;
     }
 
     NativeValue* method = obj->GetProperty(name);
     if (method == nullptr) {
-        HILOG_ERROR("%{public}s Failed to get '%{public}s' from FileAccessExtAbility object", __func__, name);
+        HILOG_ERROR("Failed to get '%{public}s' from FileAccessExtAbility object", name);
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return nullptr;
     }
+
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return handleScope.Escape(nativeEngine.CallFunction(value, method, argv, argc));
 }
 
 static bool DoAsnycWork(CallbackParam *param)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "DoAsnycWork");
     if (param == nullptr || param->jsObj == nullptr) {
         HILOG_ERROR("Not found js file object");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return false;
     }
+
     HandleScope handleScope(param->jsRuntime);
     NativeValue* value = param->jsObj->Get();
     if (value == nullptr) {
         HILOG_ERROR("Failed to get native value object");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return false;
     }
+
     NativeObject* obj = ConvertNativeValueTo<NativeObject>(value);
     if (obj == nullptr) {
         HILOG_ERROR("Failed to get FileExtAbility object");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return false;
     }
+
     NativeValue* method = obj->GetProperty(param->funcName);
     if (method == nullptr) {
         HILOG_ERROR("Failed to get '%{public}s' from FileExtAbility object",  param->funcName);
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return false;
     }
+
     auto& nativeEngine = param->jsRuntime.GetNativeEngine();
     param->result = handleScope.Escape(nativeEngine.CallFunction(value, method, param->argv, param->argc));
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return true;
 }
 
 NativeValue* JsFileAccessExtAbility::AsnycCallObjectMethod(const char* name, NativeValue* const* argv, size_t argc)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "AsnycCallObjectMethod");
     std::shared_ptr<ThreadLockInfo> lockInfo = std::make_shared<ThreadLockInfo>();
     std::shared_ptr<CallbackParam> param = std::make_shared<CallbackParam>(CallbackParam {
         .lockInfo = lockInfo.get(),
@@ -174,6 +206,7 @@ NativeValue* JsFileAccessExtAbility::AsnycCallObjectMethod(const char* name, Nat
     });
     if (param == nullptr) {
         HILOG_ERROR("failed to new param");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return nullptr;
     }
     uv_loop_s *loop = nullptr;
@@ -181,6 +214,7 @@ NativeValue* JsFileAccessExtAbility::AsnycCallObjectMethod(const char* name, Nat
     std::shared_ptr<uv_work_t> work = std::make_shared<uv_work_t>();
     if (work == nullptr) {
         HILOG_ERROR("failed to new uv_work_t");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return nullptr;
     }
     work->data = reinterpret_cast<void *>(param.get());
@@ -193,13 +227,16 @@ NativeValue* JsFileAccessExtAbility::AsnycCallObjectMethod(const char* name, Nat
         param->lockInfo->isReady = true;
         param->lockInfo->fileOperateCondition.notify_all();
     });
+
     std::unique_lock<std::mutex> lock(param->lockInfo->fileOperateMutex);
     param->lockInfo->fileOperateCondition.wait(lock, [param]() { return param->lockInfo->isReady; });
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return std::move(param->result);
 }
 
 void JsFileAccessExtAbility::GetSrcPath(std::string &srcPath)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "GetSrcPath");
     if (!Extension::abilityInfo_->isStageBasedModel) {
         /* temporary compatibility api8 + config.json */
         srcPath.append(Extension::abilityInfo_->package);
@@ -208,6 +245,7 @@ void JsFileAccessExtAbility::GetSrcPath(std::string &srcPath)
             srcPath.append(Extension::abilityInfo_->srcPath);
         }
         srcPath.append("/").append(Extension::abilityInfo_->name).append(".abc");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return;
     }
 
@@ -217,10 +255,13 @@ void JsFileAccessExtAbility::GetSrcPath(std::string &srcPath)
         srcPath.erase(srcPath.rfind('.'));
         srcPath.append(".abc");
     }
+
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
 }
 
 int JsFileAccessExtAbility::OpenFile(const Uri &uri, int flags)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "OpenFile");
     HandleScope handleScope(jsRuntime_);
     napi_env env = reinterpret_cast<napi_env>(&jsRuntime_.GetNativeEngine());
 
@@ -235,15 +276,19 @@ int JsFileAccessExtAbility::OpenFile(const Uri &uri, int flags)
     NativeValue* nativeResult = AsnycCallObjectMethod("openFile", argv, ARGC_TWO);
     int ret = ERR_ERROR;
     if (nativeResult == nullptr) {
-        HILOG_ERROR("%{public}s call openFile with return null.", __func__);
+        HILOG_ERROR("call openFile with return null.");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ret;
     }
+
     ret = OHOS::AppExecFwk::UnwrapInt32FromJS(env, reinterpret_cast<napi_value>(nativeResult));
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return ret;
 }
 
 int JsFileAccessExtAbility::CreateFile(const Uri &parent, const std::string &displayName,  Uri &newFile)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "CreateFile");
     HandleScope handleScope(jsRuntime_);
     napi_env env = reinterpret_cast<napi_env>(&jsRuntime_.GetNativeEngine());
 
@@ -258,22 +303,27 @@ int JsFileAccessExtAbility::CreateFile(const Uri &parent, const std::string &dis
     NativeValue* nativeResult = AsnycCallObjectMethod("createFile", argv, ARGC_TWO);
     int ret = ERR_ERROR;
     if (nativeResult == nullptr) {
-        HILOG_ERROR("%{public}s call createFile with return null.", __func__);
+        HILOG_ERROR("call createFile with return null.");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ret;
     }
     std::string uriStr = OHOS::AppExecFwk::UnwrapStringFromJS(env, reinterpret_cast<napi_value>(nativeResult));
     if (uriStr.empty()) {
-        HILOG_ERROR("%{public}s call createFile with return empty.", __func__);
+        HILOG_ERROR("call createFile with return empty.");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ret;
     } else {
         ret = NO_ERROR;
     }
+
     newFile = Uri(uriStr);
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return ret;
 }
 
 int JsFileAccessExtAbility::Mkdir(const Uri &parent, const std::string &displayName, Uri &newFile)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "Mkdir");
     HandleScope handleScope(jsRuntime_);
     napi_env env = reinterpret_cast<napi_env>(&jsRuntime_.GetNativeEngine());
 
@@ -288,22 +338,27 @@ int JsFileAccessExtAbility::Mkdir(const Uri &parent, const std::string &displayN
     NativeValue* nativeResult = AsnycCallObjectMethod("mkdir", argv, ARGC_TWO);
     int ret = ERR_ERROR;
     if (nativeResult == nullptr) {
-        HILOG_ERROR("%{public}s call Mkdir with return null.", __func__);
+        HILOG_ERROR("call Mkdir with return null.");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ret;
     }
     std::string uriStr = OHOS::AppExecFwk::UnwrapStringFromJS(env, reinterpret_cast<napi_value>(nativeResult));
     if (uriStr.empty()) {
-        HILOG_ERROR("%{public}s call Mkdir with return empty.", __func__);
+        HILOG_ERROR("call Mkdir with return empty.");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ret;
     } else {
         ret = NO_ERROR;
     }
+
     newFile = Uri(uriStr);
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return ret;
 }
 
 int JsFileAccessExtAbility::Delete(const Uri &sourceFile)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "Delete");
     HandleScope handleScope(jsRuntime_);
     napi_env env = reinterpret_cast<napi_env>(&jsRuntime_.GetNativeEngine());
 
@@ -315,15 +370,19 @@ int JsFileAccessExtAbility::Delete(const Uri &sourceFile)
     NativeValue* nativeResult = AsnycCallObjectMethod("delete", argv, ARGC_ONE);
     int ret = ERR_ERROR;
     if (nativeResult == nullptr) {
-        HILOG_ERROR("%{public}s call delete with return null.", __func__);
+        HILOG_ERROR("call delete with return null.");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ret;
     }
+
     ret = OHOS::AppExecFwk::UnwrapInt32FromJS(env, reinterpret_cast<napi_value>(nativeResult));
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return ret;
 }
 
 int JsFileAccessExtAbility::Move(const Uri &sourceFile, const Uri &targetParent, Uri &newFile)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "Move");
     HandleScope handleScope(jsRuntime_);
     napi_env env = reinterpret_cast<napi_env>(&jsRuntime_.GetNativeEngine());
 
@@ -338,22 +397,27 @@ int JsFileAccessExtAbility::Move(const Uri &sourceFile, const Uri &targetParent,
     NativeValue* nativeResult = AsnycCallObjectMethod("move", argv, ARGC_TWO);
     int ret = ERR_ERROR;
     if (nativeResult == nullptr) {
-        HILOG_ERROR("%{public}s call move with return null.", __func__);
+        HILOG_ERROR("call move with return null.");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ret;
     }
     std::string uriStr = OHOS::AppExecFwk::UnwrapStringFromJS(env, reinterpret_cast<napi_value>(nativeResult));
     if (uriStr.empty()) {
-        HILOG_ERROR("%{public}s call move with return empty.", __func__);
+        HILOG_ERROR("call move with return empty.");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ret;
     } else {
         ret = NO_ERROR;
     }
+
     newFile = Uri(uriStr);
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return ret;
 }
 
 int JsFileAccessExtAbility::Rename(const Uri &sourceFile, const std::string &displayName, Uri &newFile)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "Rename");
     HandleScope handleScope(jsRuntime_);
     napi_env env = reinterpret_cast<napi_env>(&jsRuntime_.GetNativeEngine());
 
@@ -368,22 +432,27 @@ int JsFileAccessExtAbility::Rename(const Uri &sourceFile, const std::string &dis
     NativeValue* nativeResult = AsnycCallObjectMethod("rename", argv, ARGC_TWO);
     int ret = ERR_ERROR;
     if (nativeResult == nullptr) {
-        HILOG_ERROR("%{public}s call rename with return null.", __func__);
+        HILOG_ERROR("call rename with return null.");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ret;
     }
     std::string uriStr = OHOS::AppExecFwk::UnwrapStringFromJS(env, reinterpret_cast<napi_value>(nativeResult));
     if (uriStr.empty()) {
-        HILOG_ERROR("%{public}s call rename with return empty.", __func__);
+        HILOG_ERROR("call rename with return empty.");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return ret;
     } else {
         ret = NO_ERROR;
     }
+
     newFile = Uri(uriStr);
+    FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
     return ret;
 }
 
 std::vector<FileInfo> JsFileAccessExtAbility::ListFile(const Uri &sourceFile)
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "ListFile");
     HandleScope handleScope(jsRuntime_);
     napi_env env = reinterpret_cast<napi_env>(&jsRuntime_.GetNativeEngine());
 
@@ -395,19 +464,23 @@ std::vector<FileInfo> JsFileAccessExtAbility::ListFile(const Uri &sourceFile)
     NativeValue* argv[] = {nativeUri};
     NativeValue* nativeResult = AsnycCallObjectMethod("listFile", argv, ARGC_ONE);
     if (nativeResult == nullptr) {
-        HILOG_ERROR("%{public}s call listFile with return null.", __func__);
+        HILOG_ERROR("call listFile with return null.");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return vec;
     }
     if (UnwrapArrayFileInfoFromJS(env, reinterpret_cast<napi_value>(nativeResult), vec)) {
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return vec;
     } else {
-        HILOG_ERROR("%{public}s end with faild.", __func__);
+        HILOG_ERROR("end with faild.");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return vec;
     }
 }
 
 std::vector<DeviceInfo> JsFileAccessExtAbility::GetRoots()
 {
+    StartTrace(HITRACE_TAG_FILEMANAGEMENT, "GetRoots");
     HandleScope handleScope(jsRuntime_);
     napi_env env = reinterpret_cast<napi_env>(&jsRuntime_.GetNativeEngine());
 
@@ -415,13 +488,16 @@ std::vector<DeviceInfo> JsFileAccessExtAbility::GetRoots()
     NativeValue* argv[] = {};
     NativeValue* nativeResult = AsnycCallObjectMethod("getRoots", argv, ARGC_ZERO);
     if (nativeResult == nullptr) {
-        HILOG_ERROR("%{public}s call getRoots with return null.", __func__);
+        HILOG_ERROR("call getRoots with return null.");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return vec;
     }
     if (UnwrapArrayDeviceInfoFromJS(env, reinterpret_cast<napi_value>(nativeResult), vec)) {
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return vec;
     } else {
-        HILOG_ERROR("%{public}s end with faild.", __func__);
+        HILOG_ERROR("end with faild.");
+        FinishTrace(HITRACE_TAG_FILEMANAGEMENT);
         return vec;
     }
 }