diff --git a/interfaces/innerkits/native/src/usb_request.cpp b/interfaces/innerkits/native/src/usb_request.cpp
index 9a50011..1330b0f 100644
--- a/interfaces/innerkits/native/src/usb_request.cpp
+++ b/interfaces/innerkits/native/src/usb_request.cpp
@@ -25,8 +25,7 @@ int32_t UsbRequest::Initialize(const USBDevicePipe &pipe, const USBEndpoint &end
     this->endpoint_ = endpoint;
     int32_t ret = UsbSrvClient::GetInstance().RequestInitialize(*this);
     if (ERR_OK != ret) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "UsbRequest::%{public}s:%{public}d failed with ret = %{public}d.", __func__,
-                   __LINE__, ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "RequestInitialize failed with ret = %{public}d.", ret);
     }
     return ret;
 }
@@ -35,8 +34,7 @@ int32_t UsbRequest::Queue()
 {
     int32_t ret = UsbSrvClient::GetInstance().RequestQueue(*this);
     if (ERR_OK != ret) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "UsbRequest::%{public}s:%{public}d failed with ret = %{public}d.", __func__,
-                   __LINE__, ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "RequestQueue failed with ret = %{public}d.", ret);
     }
     return ret;
 }
@@ -45,8 +43,7 @@ int32_t UsbRequest::Free()
 {
     int32_t ret = UsbSrvClient::GetInstance().RequestFree(*this);
     if (ERR_OK != ret) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "UsbRequest::%{public}s:%{public}d failed with ret = %{public}d.", __func__,
-                   __LINE__, ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "RequestFree failed with ret = %{public}d.", ret);
     }
     return ret;
 }
@@ -55,8 +52,7 @@ int32_t UsbRequest::Abort()
 {
     int32_t ret = UsbSrvClient::GetInstance().RequestAbort(*this);
     if (ERR_OK != ret) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "UsbRequest::%{public}s:%{public}d failed with ret = %{public}d.", __func__,
-                   __LINE__, ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "RequestAbort failed with ret = %{public}d.", ret);
     }
     return ret;
 }
diff --git a/interfaces/innerkits/native/src/usb_srv_client.cpp b/interfaces/innerkits/native/src/usb_srv_client.cpp
index 10ccd8e..3b58daf 100644
--- a/interfaces/innerkits/native/src/usb_srv_client.cpp
+++ b/interfaces/innerkits/native/src/usb_srv_client.cpp
@@ -14,7 +14,6 @@
  */
 
 #include "usb_srv_client.h"
-#include <sstream>
 #include "datetime_ex.h"
 #include "if_system_ability_manager.h"
 #include "ipc_skeleton.h"
@@ -42,7 +41,7 @@ int32_t UsbSrvClient::Connect()
     }
     sptr<ISystemAbilityManager> sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
     if (sm == nullptr) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s:fail to get Registry", __func__);
+        USB_HILOGE(MODULE_USB_INNERKIT, "fail to get SystemAbilityManager");
         return UEC_INTERFACE_GET_SYSTEM_ABILITY_MANAGER_FAILED;
     }
     sptr<IRemoteObject> remoteObject_ = sm->CheckSystemAbility(USB_SYSTEM_ABILITY_ID);
@@ -51,7 +50,7 @@ int32_t UsbSrvClient::Connect()
         return UEC_INTERFACE_GET_USB_SERVICE_FAILED;
     }
     proxy_ = iface_cast<IUsbSrv>(remoteObject_);
-    USB_HILOGI(MODULE_USB_INNERKIT, "%{public}s :Connect UsbService ok.", __func__);
+    USB_HILOGI(MODULE_USB_INNERKIT, "Connect UsbService ok.");
     return UEC_OK;
 }
 
@@ -78,11 +77,11 @@ void UsbSrvClient::UsbSrvDeathRecipient::OnRemoteDied(const wptr<IRemoteObject>
 
 int32_t UsbSrvClient::OpenDevice(const UsbDevice &device, USBDevicePipe &pipe)
 {
-    USB_HILOGI(MODULE_USB_INNERKIT, " Calling OpenDevice Start!");
+    USB_HILOGI(MODULE_USB_INNERKIT, "Calling OpenDevice Start!");
     RETURN_IF_WITH_RET(Connect() != UEC_OK, UEC_INTERFACE_NO_INIT);
     int32_t ret = proxy_->OpenDevice(device.GetBusNum(), device.GetDevAddr());
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s : failed width ret = %{public}d !", __func__, ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "OpenDevice failed with ret = %{public}d !", ret);
         return ret;
     }
 
@@ -93,7 +92,7 @@ int32_t UsbSrvClient::OpenDevice(const UsbDevice &device, USBDevicePipe &pipe)
 
 bool UsbSrvClient::HasRight(std::string deviceName)
 {
-    USB_HILOGI(MODULE_USB_INNERKIT, " Calling HasRight Start!");
+    USB_HILOGI(MODULE_USB_INNERKIT, "Calling HasRight Start!");
     RETURN_IF_WITH_RET(Connect() != UEC_OK, false);
     return proxy_->HasRight(deviceName);
 }
@@ -103,7 +102,7 @@ int32_t UsbSrvClient::RequestRight(std::string deviceName)
     RETURN_IF_WITH_RET(Connect() != UEC_OK, UEC_INTERFACE_NO_INIT);
     int32_t ret = proxy_->RequestRight(deviceName);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_INNERKIT, " Calling RequestRight False!");
+        USB_HILOGE(MODULE_USB_INNERKIT, "Calling RequestRight failed with ret = %{public}d !", ret);
     }
     return ret;
 }
@@ -113,7 +112,7 @@ int32_t UsbSrvClient::RemoveRight(std::string deviceName)
     RETURN_IF_WITH_RET(Connect() != UEC_OK, UEC_INTERFACE_NO_INIT);
     int32_t ret = proxy_->RemoveRight(deviceName);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_INNERKIT, " Calling RequestRight False!");
+        USB_HILOGE(MODULE_USB_INNERKIT, "Calling RequestRight failed with ret = %{public}d !", ret);
     }
     return ret;
 }
@@ -123,9 +122,9 @@ int32_t UsbSrvClient::GetDevices(std::vector<UsbDevice> &deviceList)
     RETURN_IF_WITH_RET(Connect() != UEC_OK, UEC_INTERFACE_NO_INIT);
     int32_t ret = proxy_->GetDevices(deviceList);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s failed ret = %{public}d!", __func__, ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "GetDevices failed ret = %{public}d!", ret);
     }
-    USB_HILOGI(MODULE_USB_INNERKIT, "%{public}s list size = %{public}zu!", __func__, deviceList.size());
+    USB_HILOGI(MODULE_USB_INNERKIT, "list size = %{public}zu!", deviceList.size());
     return ret;
 }
 
@@ -134,7 +133,7 @@ int32_t UsbSrvClient::GetCurrentFunctions(int32_t &funcs)
     RETURN_IF_WITH_RET(Connect() != UEC_OK, UEC_INTERFACE_NO_INIT);
     int32_t ret = proxy_->GetCurrentFunctions(funcs);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s failed ret = %{public}d!", __func__, ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "failed ret = %{public}d!", ret);
     }
     USB_HILOGI(MODULE_USB_INNERKIT, " Calling GetCurrentFunctions Success!");
     return ret;
@@ -145,7 +144,7 @@ int32_t UsbSrvClient::SetCurrentFunctions(int32_t funcs)
     RETURN_IF_WITH_RET(Connect() != UEC_OK, false);
     int32_t ret = proxy_->SetCurrentFunctions(funcs);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s failed ret = %{public}d!", __func__, ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "failed ret = %{public}d!", ret);
         return ret;
     }
     USB_HILOGI(MODULE_USB_INNERKIT, " Calling SetCurrentFunctions Success!");
@@ -175,7 +174,7 @@ int32_t UsbSrvClient::GetPorts(std::vector<UsbPort> &usbports)
     USB_HILOGI(MODULE_USB_INNERKIT, " Calling GetPorts");
     int32_t ret = proxy_->GetPorts(usbports);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s failed ret = %{public}d!", __func__, ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "failed ret = %{public}d!", ret);
     }
     return ret;
 }
@@ -186,7 +185,7 @@ int32_t UsbSrvClient::GetSupportedModes(int32_t portId, int32_t &result)
     USB_HILOGI(MODULE_USB_INNERKIT, " Calling GetSupportedModes");
     int32_t ret = proxy_->GetSupportedModes(portId, result);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s failed ret = %{public}d!", __func__, ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "failed ret = %{public}d!", ret);
     }
     return ret;
 }
@@ -194,10 +193,10 @@ int32_t UsbSrvClient::GetSupportedModes(int32_t portId, int32_t &result)
 int32_t UsbSrvClient::SetPortRole(int32_t portId, int32_t powerRole, int32_t dataRole)
 {
     RETURN_IF_WITH_RET(Connect() != UEC_OK, UEC_INTERFACE_NO_INIT);
-    USB_HILOGI(MODULE_USB_INNERKIT, " Calling SetPortRole");
+    USB_HILOGI(MODULE_USB_INNERKIT, "Calling SetPortRole");
     int32_t ret = proxy_->SetPortRole(portId, powerRole, dataRole);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s failed ret = %{public}d!", __func__, ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "failed ret = %{public}d!", ret);
     }
     return ret;
 }
@@ -207,7 +206,7 @@ int32_t UsbSrvClient::ClaimInterface(USBDevicePipe &pipe, const UsbInterface &in
     RETURN_IF_WITH_RET(proxy_ == nullptr, UEC_INTERFACE_NO_INIT);
     int32_t ret = proxy_->ClaimInterface(pipe.GetBusNum(), pipe.GetDevAddr(), interface.GetId(), force);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s : failed width ret = %{public}d !", __func__, ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "failed width ret = %{public}d !", ret);
     }
     return ret;
 }
@@ -217,7 +216,7 @@ int32_t UsbSrvClient::ReleaseInterface(USBDevicePipe &pipe, const UsbInterface &
     RETURN_IF_WITH_RET(proxy_ == nullptr, UEC_INTERFACE_NO_INIT);
     int32_t ret = proxy_->ReleaseInterface(pipe.GetBusNum(), pipe.GetDevAddr(), interface.GetId());
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s : failed width ret = %{public}d !", __func__, ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "failed width ret = %{public}d !", ret);
     }
     return ret;
 }
@@ -235,7 +234,7 @@ int32_t UsbSrvClient::BulkTransfer(USBDevicePipe &pipe, const USBEndpoint &endpo
         ret = proxy_->BulkTransferWrite(tdev, tpipe, bufferData, timeOut);
     }
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s : failed width ret = %{public}d !", __func__, ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "failed width ret = %{public}d !", ret);
     }
     return ret;
 }
@@ -247,7 +246,7 @@ int32_t UsbSrvClient::ControlTransfer(USBDevicePipe &pipe, const UsbCtrlTransfer
     const UsbDev dev = {pipe.GetBusNum(), pipe.GetDevAddr()};
     int32_t ret = proxy_->ControlTransfer(dev, ctrl, bufferData);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s : failed width ret = %{public}d !", __func__, ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "failed width ret = %{public}d !", ret);
     }
 
     return ret;
@@ -272,7 +271,7 @@ int32_t UsbSrvClient::GetRawDescriptors(USBDevicePipe &pipe, std::vector<uint8_t
     RETURN_IF_WITH_RET(Connect() != UEC_OK, UEC_INTERFACE_NO_INIT);
     int32_t ret = proxy_->GetRawDescriptor(pipe.GetBusNum(), pipe.GetDevAddr(), bufferData);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s failed ret = %{public}d!", __func__, ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "failed ret = %{public}d!", ret);
     }
     return ret;
 }
@@ -282,7 +281,7 @@ int32_t UsbSrvClient::GetFileDescriptor(USBDevicePipe &pipe, int32_t &fd)
     RETURN_IF_WITH_RET(Connect() != UEC_OK, UEC_INTERFACE_NO_INIT);
     int32_t ret = proxy_->GetFileDescriptor(pipe.GetBusNum(), pipe.GetDevAddr(), fd);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s failed ret = %{public}d!", __func__, ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "failed ret = %{public}d!", ret);
     }
     return ret;
 }
@@ -302,8 +301,7 @@ int32_t UsbSrvClient::PipeRequestWait(USBDevicePipe &pipe, int64_t timeOut, UsbR
     const UsbDev tdev = {pipe.GetBusNum(), pipe.GetDevAddr()};
     int32_t ret = proxy_->RequestWait(tdev, timeOut, clientData, bufferData);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "UsbSrvClient::%{public}s:%{public}d :failed width ret = %{public}d.", __func__,
-                   __LINE__, ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "failed width ret = %{public}d.", ret);
         return ret;
     }
 
@@ -354,7 +352,7 @@ int32_t UsbSrvClient::RegBulkCallback(USBDevicePipe &pip, const USBEndpoint &end
     const UsbPipe tpipe = {endpoint.GetInterfaceId(), endpoint.GetAddress()};
     int32_t ret = proxy_->RegBulkCallback(tdev, tpipe, cb);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s : failed width ret = %{public}d !", __func__, ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "failed width ret = %{public}d !", ret);
     }
     return ret;
 }
@@ -366,7 +364,7 @@ int32_t UsbSrvClient::UnRegBulkCallback(USBDevicePipe &pip, const USBEndpoint &e
     const UsbPipe tpipe = {endpoint.GetInterfaceId(), endpoint.GetAddress()};
     int32_t ret = proxy_->UnRegBulkCallback(tdev, tpipe);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s : failed width ret = %{public}d !", __func__, ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "failed width ret = %{public}d !", ret);
     }
     return ret;
 }
@@ -378,7 +376,7 @@ int32_t UsbSrvClient::BulkRead(USBDevicePipe &pip, const USBEndpoint &endpoint,
     const UsbPipe tpipe = {endpoint.GetInterfaceId(), endpoint.GetAddress()};
     int32_t ret = proxy_->BulkRead(tdev, tpipe, ashmem);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s : failed width ret = %{public}d !", __func__, ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "failed width ret = %{public}d !", ret);
     }
     return ret;
 }
@@ -390,7 +388,7 @@ int32_t UsbSrvClient::BulkWrite(USBDevicePipe &pip, const USBEndpoint &endpoint,
     const UsbPipe tpipe = {endpoint.GetInterfaceId(), endpoint.GetAddress()};
     int32_t ret = proxy_->BulkWrite(tdev, tpipe, ashmem);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s : failed width ret = %{public}d !", __func__, ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "failed width ret = %{public}d !", ret);
     }
     return ret;
 }
@@ -402,7 +400,7 @@ int32_t UsbSrvClient::BulkCancel(USBDevicePipe &pip, const USBEndpoint &endpoint
     const UsbPipe tpipe = {endpoint.GetInterfaceId(), endpoint.GetAddress()};
     int32_t ret = proxy_->BulkCancel(tdev, tpipe);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s : failed width ret = %{public}d !", __func__, ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "failed width ret = %{public}d !", ret);
     }
     return ret;
 }
diff --git a/interfaces/innerkits/native/src/usbd_bulk_callback.cpp b/interfaces/innerkits/native/src/usbd_bulk_callback.cpp
index e0528f5..789a8eb 100644
--- a/interfaces/innerkits/native/src/usbd_bulk_callback.cpp
+++ b/interfaces/innerkits/native/src/usbd_bulk_callback.cpp
@@ -24,45 +24,44 @@ int32_t UsbdBulkCallBack::OnRemoteRequest(uint32_t code, MessageParcel &data, Me
     switch (code) {
         case CMD_USBD_BULK_CALLBACK_WRITE: {
             if (data.ReadInterfaceToken() != GetObjectDescriptor()) {
-                USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s: checkout interface descriptor failed!", __func__);
+                USB_HILOGE(MODULE_USB_INNERKIT, "check interface token failed, code=%{public}u", code);
                 return UEC_SERVICE_WRITE_PARCEL_ERROR;
             }
 
             int32_t status;
             int32_t actLength;
             if (!data.ReadInt32(status)) {
-                USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s:%{public}d get status error", __func__, __LINE__);
+                USB_HILOGE(MODULE_USB_INNERKIT, "get status error");
                 return UEC_SERVICE_WRITE_PARCEL_ERROR;
             }
             if (!data.ReadInt32(actLength)) {
-                USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s:%{public}d get actLength error", __func__, __LINE__);
+                USB_HILOGE(MODULE_USB_INNERKIT, "get actLength error");
                 return UEC_SERVICE_WRITE_PARCEL_ERROR;
             }
 
-            USB_HILOGI(MODULE_USB_INNERKIT, "%{public}s:%{public}d status:%{public}d actLength:%{public}d", __func__,
-                __LINE__, status, actLength);
+            USB_HILOGI(MODULE_USB_INNERKIT, "status:%{public}d actLength:%{public}d", status, actLength);
             OnBulkWriteCallback(status, actLength);
             break;
         }
         case CMD_USBD_BULK_CALLBACK_READ: {
             if (data.ReadInterfaceToken() != GetObjectDescriptor()) {
-                USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s: checkout interface descriptor failed!", __func__);
+                USB_HILOGE(MODULE_USB_INNERKIT, "check interface token failed, code=%{public}u", code);
                 return UEC_SERVICE_WRITE_PARCEL_ERROR;
             }
 
             int32_t status;
             int32_t actLength;
             if (!data.ReadInt32(status)) {
-                USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s:%{public}d get status error", __func__, __LINE__);
+                USB_HILOGE(MODULE_USB_INNERKIT, "get status error code=%{public}u", code);
                 return UEC_SERVICE_WRITE_PARCEL_ERROR;
             }
             if (!data.ReadInt32(actLength)) {
-                USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s:%{public}d get actLength error", __func__, __LINE__);
+                USB_HILOGE(MODULE_USB_INNERKIT, "get actLength error code=%{public}u", code);
                 return UEC_SERVICE_WRITE_PARCEL_ERROR;
             }
 
-            USB_HILOGI(MODULE_USB_INNERKIT, "%{public}s:%{public}d status:%{public}d actLength:%{public}d", __func__,
-                __LINE__, status, actLength);
+            USB_HILOGI(MODULE_USB_INNERKIT, "%{public}d status:%{public}d actLength:%{public}d", __LINE__, status,
+                actLength);
             OnBulkReadCallback(status, actLength);
             break;
         }
diff --git a/interfaces/kits/js/napi/src/napi_util.cpp b/interfaces/kits/js/napi/src/napi_util.cpp
index dac2fab..2429a0e 100644
--- a/interfaces/kits/js/napi/src/napi_util.cpp
+++ b/interfaces/kits/js/napi/src/napi_util.cpp
@@ -27,7 +27,7 @@ const int32_t MAX_STR_LENGTH = 1024;
 void NapiUtil::JsValueToString(const napi_env &env, const napi_value &value, const int32_t bufLen, std::string &target)
 {
     if (bufLen <= 0 || bufLen > MAX_STR_LENGTH) {
-        USB_HILOGE(MODULE_JS_NAPI, "%{public}s string too long malloc failed", __func__);
+        USB_HILOGE(MODULE_JS_NAPI, "string too long malloc failed");
         return;
     }
 
@@ -67,7 +67,7 @@ void NapiUtil::JsObjectToString(const napi_env &env, const napi_value &object, s
         napi_get_value_string_utf8(env, field, buf.get(), bufLen, &result);
         fieldRef = buf.get();
     } else {
-        USB_HILOGW(MODULE_JS_NAPI, "%{public}s js to str no property: %{public}s", __func__, fieldStr.c_str());
+        USB_HILOGW(MODULE_JS_NAPI, "js to str no property: %{public}s", fieldStr.c_str());
     }
 }
 
@@ -79,7 +79,7 @@ bool NapiUtil::JsObjectGetProperty(const napi_env &env, const napi_value &object
     if (hasProperty) {
         napi_get_named_property(env, object, fieldStr.c_str(), &value);
     } else {
-        USB_HILOGW(MODULE_JS_NAPI, "%{public}s js object has no property: %{public}s", __func__, fieldStr.c_str());
+        USB_HILOGW(MODULE_JS_NAPI, "js object has no property: %{public}s", fieldStr.c_str());
     }
     return hasProperty;
 }
@@ -97,7 +97,7 @@ void NapiUtil::JsObjectToInt(const napi_env &env, const napi_value &object, std:
         NAPI_ASSERT_RETURN_VOID(env, valueType == napi_number, "Wrong argument type. Number expected.");
         napi_get_value_int32(env, field, &fieldRef);
     } else {
-        USB_HILOGW(MODULE_JS_NAPI, "%{public}s js to int32_t no property: %{public}s", __func__, fieldStr.c_str());
+        USB_HILOGW(MODULE_JS_NAPI, "js to int32_t no property: %{public}s", fieldStr.c_str());
     }
 }
 
@@ -106,7 +106,7 @@ bool NapiUtil::JsUint8ArrayParse(const napi_env &env, const napi_value &object,
 {
     bool isTypedArray = false;
     if (napi_is_typedarray(env, object, &isTypedArray) != napi_ok || !isTypedArray) {
-        USB_HILOGW(MODULE_JS_NAPI, "%{public}s invalid type", __func__);
+        USB_HILOGW(MODULE_JS_NAPI, "invalid type");
         return false;
     }
 
@@ -116,17 +116,17 @@ bool NapiUtil::JsUint8ArrayParse(const napi_env &env, const napi_value &object,
     napi_status infoStatus = napi_get_typedarray_info(env, object, &type, &bufferSize,
         reinterpret_cast<void **>(uint8Buffer), &buffer, &offset);
     if (infoStatus != napi_ok) {
-        USB_HILOGW(MODULE_JS_NAPI, "%{public}s get typedarray info failed, status: %{public}d", __func__, infoStatus);
+        USB_HILOGW(MODULE_JS_NAPI, "get typedarray info failed, status: %{public}d", infoStatus);
         return false;
     }
 
     if (type != napi_uint8_array) {
-        USB_HILOGW(MODULE_JS_NAPI, "%{public}s not Uint8Array type: %{public}d", __func__, type);
+        USB_HILOGW(MODULE_JS_NAPI, "not Uint8Array type: %{public}d", type);
         return false;
     }
 
     if (bufferSize == 0) {
-        USB_HILOGW(MODULE_JS_NAPI, "%{public}s:%{public}d bufferSize error", __func__, __LINE__);
+        USB_HILOGW(MODULE_JS_NAPI, "bufferSize error");
         return false;
     }
 
@@ -142,7 +142,7 @@ void NapiUtil::Uint8ArrayToJsValue(const napi_env &env, std::vector<uint8_t> &ui
 
     errno_t ret = memcpy_s(nativeArraybuffer, bufferSize, uint8Buffer.data(), bufferSize);
     if (ret != EOK) {
-        USB_HILOGE(MODULE_JS_NAPI, "%{public}s:%{public}d memcpy_s failed\n", __func__, __LINE__);
+        USB_HILOGE(MODULE_JS_NAPI, "memcpy_s failed\n");
         return;
     }
 
diff --git a/interfaces/kits/js/napi/src/usb_info.cpp b/interfaces/kits/js/napi/src/usb_info.cpp
index bcd25d0..5237eb6 100644
--- a/interfaces/kits/js/napi/src/usb_info.cpp
+++ b/interfaces/kits/js/napi/src/usb_info.cpp
@@ -190,14 +190,14 @@ static bool ParseEndpointsObjs(const napi_env env, const napi_value interfaceObj
     napi_value endpointsObjs;
     bool isGetObjSuccess = NapiUtil::JsObjectGetProperty(env, interfaceObj, "endpoints", endpointsObjs);
     if (!isGetObjSuccess) {
-        USB_HILOGE(MODULE_JS_NAPI, "%{public}s, get endpoints failed.", __func__);
+        USB_HILOGE(MODULE_JS_NAPI, "get endpoints failed.");
         return false;
     }
 
     bool result = false;
     napi_status status = napi_is_array(env, endpointsObjs, &result);
     if (!result || status != napi_ok) {
-        USB_HILOGE(MODULE_JS_NAPI, "%{public}s, invalid endpoints.", __func__);
+        USB_HILOGE(MODULE_JS_NAPI, "invalid endpoints.");
         return false;
     }
 
@@ -212,7 +212,7 @@ static bool ParseEndpointsObjs(const napi_env env, const napi_value interfaceObj
         napi_value endpointObj;
         status = napi_get_element(env, endpointsObjs, k, &endpointObj);
         if (status != napi_ok) {
-            USB_HILOGE(MODULE_JS_NAPI, "%{public}s, get endpoints element failed k=%u.", __func__, k);
+            USB_HILOGE(MODULE_JS_NAPI, "get endpoints element failed k=%u.", k);
             return false;
         }
         USBEndpoint ep;
@@ -289,21 +289,21 @@ static bool ParseInterfacesObjs(const napi_env env, const napi_value configObj,
     napi_value interfacesObjs;
     bool isGetObjSuccess = NapiUtil::JsObjectGetProperty(env, configObj, "interfaces", interfacesObjs);
     if (!isGetObjSuccess) {
-        USB_HILOGE(MODULE_JS_NAPI, "%{public}s, get interfaces failed.", __func__);
+        USB_HILOGE(MODULE_JS_NAPI, "get interfaces failed.");
         return false;
     }
 
     bool result = false;
     napi_status status = napi_is_array(env, interfacesObjs, &result);
     if (!result || status != napi_ok) {
-        USB_HILOGE(MODULE_JS_NAPI, "%{public}s, invalid param.", __func__);
+        USB_HILOGE(MODULE_JS_NAPI, "invalid param.");
         return false;
     }
 
     uint32_t interfaceCount = 0;
     status = napi_get_array_length(env, interfacesObjs, &interfaceCount);
     if (status != napi_ok) {
-        USB_HILOGE(MODULE_JS_NAPI, "%{public}s, get len failed.", __func__);
+        USB_HILOGE(MODULE_JS_NAPI, "get len failed.");
         return false;
     }
 
@@ -311,7 +311,7 @@ static bool ParseInterfacesObjs(const napi_env env, const napi_value configObj,
         napi_value interfaceObj;
         status = napi_get_element(env, interfacesObjs, i, &interfaceObj);
         if (status != napi_ok) {
-            USB_HILOGE(MODULE_JS_NAPI, "%{public}s, get element failed,i=%{public}u.", __func__, i);
+            USB_HILOGE(MODULE_JS_NAPI, "get element failed,i=%{public}u.", i);
             return false;
         }
         UsbInterface interface;
@@ -403,7 +403,7 @@ static napi_value CoreGetDevices(napi_env env, napi_callback_info info)
     napi_value result;
     if (ret != UEC_OK) {
         napi_get_undefined(env, &result);
-        USB_HILOGE(MODULE_JS_NAPI, "end call %{public}s, get device failed ret : %{public}d", __func__, ret);
+        USB_HILOGE(MODULE_JS_NAPI, "end call get device failed ret : %{public}d", ret);
         return result;
     }
 
@@ -634,7 +634,7 @@ static napi_value CoreGetCurrentFunctions(napi_env env, napi_callback_info info)
     napi_value result;
     if (ret != UEC_OK) {
         napi_get_undefined(env, &result);
-        USB_HILOGE(MODULE_JS_NAPI, "end call %{public}s, get ports failed ret : %{public}d", __func__, ret);
+        USB_HILOGE(MODULE_JS_NAPI, "end call get ports failed ret : %{public}d", ret);
         return result;
     }
     napi_create_int32(env, cfuncs, &result);
@@ -655,7 +655,7 @@ static napi_value CoreGetPorts(napi_env env, napi_callback_info info)
     napi_value result;
     if (ret != UEC_OK) {
         napi_get_undefined(env, &result);
-        USB_HILOGE(MODULE_JS_NAPI, "end call %{public}s, get ports failed ret : %{public}d", __func__, ret);
+        USB_HILOGE(MODULE_JS_NAPI, "end call get ports failed ret : %{public}d", ret);
         return result;
     }
 
@@ -696,7 +696,7 @@ static napi_value PortGetSupportedModes(napi_env env, napi_callback_info info)
     napi_get_value_int32(env, args[INDEX_0], &id);
     int32_t ret = g_usbClient.GetSupportedModes(id, result);
     if (ret) {
-        USB_HILOGD(MODULE_JS_NAPI, "%{public}s:false ret = %{public}d", __func__, ret);
+        USB_HILOGD(MODULE_JS_NAPI, "false ret = %{public}d", ret);
     }
     napi_value napiValue = nullptr;
     NAPI_CALL(env, napi_create_int32(env, result, &napiValue));
@@ -1041,14 +1041,14 @@ static napi_value PipeControlTransfer(napi_env env, napi_callback_info info)
     if ((asyncContext->reqType & USB_ENDPOINT_DIR_MASK) == USB_ENDPOINT_DIR_OUT) {
         uint8_t *nativeArraybuffer = new(std::nothrow) uint8_t[controlParam.dataLength];
         if (nativeArraybuffer == nullptr) {
-            USB_HILOGE(MODULE_JS_NAPI, "%{public}s:%{public}d, new failed", __func__, __LINE__);
+            USB_HILOGE(MODULE_JS_NAPI, "new failed");
             delete asyncContext;
             return nullptr;
         }
 
         errno_t ret = memcpy_s(nativeArraybuffer, controlParam.dataLength, controlParam.data, controlParam.dataLength);
         if (ret != EOK) {
-            USB_HILOGE(MODULE_JS_NAPI, "%{public}s:%{public}d, memcpy_s failed\n", __func__, __LINE__);
+            USB_HILOGE(MODULE_JS_NAPI, "memcpy_s failed\n");
             delete asyncContext;
             delete []nativeArraybuffer;
             return nullptr;
@@ -1160,7 +1160,7 @@ static bool GetBulkTransferParams(napi_env env, napi_callback_info info, USBBulk
 
         errno_t ret = memcpy_s(nativeArraybuffer, bufferSize, buffer, bufferSize);
         if (ret != EOK) {
-            USB_HILOGE(MODULE_JS_NAPI, "%{public}s:%{public}d, memcpy_s failed\n", __func__, __LINE__);
+            USB_HILOGE(MODULE_JS_NAPI, "memcpy_s failed\n");
             delete []nativeArraybuffer;
             return false;
         }
@@ -1182,7 +1182,7 @@ static napi_value PipeBulkTransfer(napi_env env, napi_callback_info info)
     napi_value result = nullptr;
     napi_create_promise(env, &asyncContext->deferred, &result);
     if (!GetBulkTransferParams(env, info, *asyncContext)) {
-        USB_HILOGE(MODULE_JS_NAPI, "end call %{public}s %{public}d : invalid arg", __func__, __LINE__);
+        USB_HILOGE(MODULE_JS_NAPI, "end call invalid arg");
         asyncContext->status = napi_invalid_arg;
         napi_value queryResult = nullptr;
         napi_create_int32(env, -1, &queryResult);
@@ -1197,7 +1197,7 @@ static napi_value PipeBulkTransfer(napi_env env, napi_callback_info info)
     napi_status status = napi_create_async_work(env, nullptr, resource, g_bulkTransferExecute, g_bulkTransferComplete,
                                                 reinterpret_cast<void *>(asyncContext), &asyncContext->work);
     if (status != napi_ok) {
-        USB_HILOGE(MODULE_JS_NAPI, "%{public}s, create async work failed", __func__);
+        USB_HILOGE(MODULE_JS_NAPI, "create async work failed");
         return result;
     }
     napi_queue_async_work(env, asyncContext->work);
@@ -1230,7 +1230,7 @@ static napi_value PipeClose(napi_env env, napi_callback_info info)
 static napi_value GetVersion(napi_env env, napi_callback_info info)
 {
     auto version = g_usbClient.GetVersion();
-    USB_HILOGD(MODULE_JS_NAPI, "call %{public}s, version is %{public}s", __func__, version.c_str());
+    USB_HILOGD(MODULE_JS_NAPI, "version is %{public}s", version.c_str());
     napi_value result;
     napi_create_string_utf8(env, version.c_str(), NAPI_AUTO_LENGTH, &result);
     return result;
diff --git a/services/native/src/usb_descriptor_parser.cpp b/services/native/src/usb_descriptor_parser.cpp
index 6aa1abe..2c732d0 100644
--- a/services/native/src/usb_descriptor_parser.cpp
+++ b/services/native/src/usb_descriptor_parser.cpp
@@ -40,22 +40,21 @@ int32_t UsbDescriptorParser::ParseDeviceDescriptor(const uint8_t *buffer, uint32
 {
     uint32_t cursor = 0;
     if (buffer == nullptr || length == 0) {
-        USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: buffer is null", __func__);
+        USB_HILOGE(MODULE_USB_SERVICE, "buffer is null");
         return UEC_SERVICE_INVALID_VALUE;
     }
 
-    USB_HILOGI(MODULE_USB_SERVICE, "%{public}s:  parse begin length=%{public}u, cursor=%{public}u",
-               __func__, length, cursor);
+    USB_HILOGI(MODULE_USB_SERVICE, "parse begin length=%{public}u, cursor=%{public}u", length, cursor);
     uint32_t deviceDescriptorSize = sizeof(UsbdDeviceDescriptor);
     if (length < deviceDescriptorSize) {
-        USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: buffer size error", __func__);
+        USB_HILOGE(MODULE_USB_SERVICE, "buffer size error");
         return UEC_SERVICE_INVALID_VALUE;
     }
 
     UsbdDeviceDescriptor deviceDescriptor = *(UsbdDeviceDescriptor *)buffer;
     cursor += deviceDescriptorSize;
     if (deviceDescriptor.bLength != deviceDescriptorSize) {
-        USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: UsbdDeviceDescriptor size error", __func__);
+        USB_HILOGE(MODULE_USB_SERVICE, "UsbdDeviceDescriptor size error");
         return UEC_SERVICE_INVALID_VALUE;
     }
 
@@ -81,18 +80,17 @@ int32_t UsbDescriptorParser::ParseConfigDescriptor(const uint8_t *buffer, uint32
         return UEC_SERVICE_INVALID_VALUE;
     }
 
-    USB_HILOGI(MODULE_USB_SERVICE, "%{public}s:  parse begin length=%{public}u, cursor=%{public}u",
-               __func__, length, cursor);
+    USB_HILOGI(MODULE_USB_SERVICE, "parse begin length=%{public}u, cursor=%{public}u", length, cursor);
     uint32_t configDescriptorSize = sizeof(UsbdConfigDescriptor);
     if (length < configDescriptorSize) {
-        USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:  buffer size error", __func__);
+        USB_HILOGE(MODULE_USB_SERVICE, "buffer size error");
         return UEC_SERVICE_INVALID_VALUE;
     }
 
     UsbdConfigDescriptor configDescriptor = *(UsbdConfigDescriptor *)buffer;
     cursor += configDescriptorSize;
     if (configDescriptor.bLength != configDescriptorSize) {
-        USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:  UsbdDeviceDescriptor size error", __func__);
+        USB_HILOGE(MODULE_USB_SERVICE, "UsbdDeviceDescriptor size error");
         return UEC_SERVICE_INVALID_VALUE;
     }
 
@@ -129,25 +127,25 @@ int32_t UsbDescriptorParser::ParseInterfaceDescriptor(const uint8_t *buffer, uin
     uint32_t descriptorHeaderSize = sizeof(UsbdDescriptorHeader);
     while ((uint32_t)cursor < length) {
         if (descriptorHeaderSize >= length) {
-            USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: descriptor size error", __func__);
+            USB_HILOGE(MODULE_USB_SERVICE, "length error");
             return UEC_SERVICE_INVALID_VALUE;
         }
         UsbdDescriptorHeader descriptorHeader = *(UsbdDescriptorHeader *)(buffer + cursor);
         if (descriptorHeader.bLength > length) {
-            USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: descriptor size error", __func__);
+            USB_HILOGE(MODULE_USB_SERVICE, "descriptor size error");
             return UEC_SERVICE_INVALID_VALUE;
         }
         if (descriptorHeader.bDescriptorType == static_cast<uint8_t>(DescriptorType::DESCRIPTOR_TYPE_INTERFACE)) {
             break;
         }
         cursor += descriptorHeader.bLength;
-        USB_HILOGI(MODULE_USB_SERVICE, "%{public}s: type = %{public}d, length=%{public}d", __func__,
-                   descriptorHeader.bDescriptorType, descriptorHeader.bLength);
+        USB_HILOGI(MODULE_USB_SERVICE, "type = %{public}d, length=%{public}d", descriptorHeader.bDescriptorType,
+            descriptorHeader.bLength);
     }
 
     UsbdInterfaceDescriptor interfaceDescriptor = *(UsbdInterfaceDescriptor *)(buffer + cursor);
     if (interfaceDescriptor.bLength != sizeof(UsbdInterfaceDescriptor)) {
-        USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: UsbdInterfaceDescriptor size error", __func__);
+        USB_HILOGE(MODULE_USB_SERVICE, "UsbdInterfaceDescriptor size error");
         return UEC_SERVICE_INVALID_VALUE;
     }
     cursor += interfaceDescriptor.bLength;
@@ -175,8 +173,7 @@ int32_t UsbDescriptorParser::ParseInterfaceDescriptor(const uint8_t *buffer, uin
 int32_t UsbDescriptorParser::ParseEndpointDescriptor(const uint8_t *buffer, uint32_t length, uint32_t &cursor,
     USBEndpoint &ep)
 {
-    USB_HILOGI(MODULE_USB_SERVICE, "%{public}s:  parse begin, length=%{public}u, cursor=%{public}u",
-               __func__, length, cursor);
+    USB_HILOGI(MODULE_USB_SERVICE, "parse begin, length=%{public}u, cursor=%{public}u", length, cursor);
     if (buffer == nullptr || length == 0) {
         return UEC_SERVICE_INVALID_VALUE;
     }
@@ -184,26 +181,25 @@ int32_t UsbDescriptorParser::ParseEndpointDescriptor(const uint8_t *buffer, uint
     uint32_t descriptorHeaderSize = sizeof(UsbdDescriptorHeader);
     while ((uint32_t)cursor < length) {
         if (descriptorHeaderSize >= length) {
-            USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: descriptor size error", __func__);
+            USB_HILOGE(MODULE_USB_SERVICE, "length error");
             return UEC_SERVICE_INVALID_VALUE;
         }
         UsbdDescriptorHeader descriptorHeader = *(UsbdDescriptorHeader *)(buffer + cursor);
         if (descriptorHeader.bLength > length) {
-            USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: descriptor size error", __func__);
+            USB_HILOGE(MODULE_USB_SERVICE, "descriptor size error");
             return UEC_SERVICE_INVALID_VALUE;
         }
         if (descriptorHeader.bDescriptorType == static_cast<uint8_t>(DescriptorType::DESCRIPTOR_TYPE_ENDPOINT)) {
             break;
         }
         cursor += descriptorHeader.bLength;
-        USB_HILOGI(MODULE_USB_SERVICE, "%{public}s: error type = %{public}d, length=%{public}d", __func__,
-                   descriptorHeader.bDescriptorType, descriptorHeader.bLength);
+        USB_HILOGI(MODULE_USB_SERVICE, "error type = %{public}d, length=%{public}d", descriptorHeader.bDescriptorType,
+            descriptorHeader.bLength);
     }
 
     UsbdEndpointDescriptor endpointDescriptor = *(UsbdEndpointDescriptor *)(buffer + cursor);
     if (endpointDescriptor.bLength != sizeof(UsbdEndpointDescriptor)) {
-        USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:  Endpoint descriptor size error, length=%{public}d", __func__,
-                   endpointDescriptor.bLength);
+        USB_HILOGE(MODULE_USB_SERVICE, "Endpoint descriptor size error, length=%{public}d", endpointDescriptor.bLength);
         return UEC_SERVICE_INVALID_VALUE;
     }
     cursor += endpointDescriptor.bLength;
diff --git a/services/native/src/usb_host_manager.cpp b/services/native/src/usb_host_manager.cpp
index f6d88f8..6548ce7 100644
--- a/services/native/src/usb_host_manager.cpp
+++ b/services/native/src/usb_host_manager.cpp
@@ -36,12 +36,12 @@ bool UsbHostManager::DelDevice(uint8_t busNum, uint8_t devNum)
     std::string name = std::to_string(busNum) + "-" + std::to_string(devNum);
     MAP_STR_DEVICE::iterator iter = devices_.find(name);
     if (iter == devices_.end()) {
-        USB_HILOGF(MODULE_SERVICE, "%{public}s:%{public}d name:%{public}s bus:%{public}hhu dev:%{public}hhu not exist",
-            __func__, __LINE__, name.c_str(), busNum, devNum);
+        USB_HILOGF(MODULE_SERVICE, "name:%{public}s bus:%{public}hhu dev:%{public}hhu not exist", name.c_str(),
+            busNum, devNum);
         return false;
     }
-    USB_HILOGF(MODULE_SERVICE, "%{public}s:%{public}d device:%{public}s bus:%{public}hhu dev:%{public}hhu erase ",
-        __func__, __LINE__, name.c_str(), busNum, devNum);
+    USB_HILOGI(MODULE_SERVICE, "device:%{public}s bus:%{public}hhu dev:%{public}hhu erase ", name.c_str(), busNum,
+        devNum);
     UsbDevice *devOld = iter->second;
     devices_.erase(iter);
     if (devOld)
@@ -52,7 +52,7 @@ bool UsbHostManager::DelDevice(uint8_t busNum, uint8_t devNum)
 bool UsbHostManager::AddDevice(UsbDevice *dev)
 {
     if (dev == nullptr) {
-        USB_HILOGF(MODULE_SERVICE, "%{public}s:%{public}d device is NULL", __func__, __LINE__);
+        USB_HILOGF(MODULE_SERVICE, "device is NULL");
         return false;
     }
     uint8_t busNum = dev->GetBusNum();
@@ -60,16 +60,15 @@ bool UsbHostManager::AddDevice(UsbDevice *dev)
     std::string name = std::to_string(busNum) + "-" + std::to_string(devNum);
     MAP_STR_DEVICE::iterator iter = devices_.find(name);
     if (iter != devices_.end()) {
-        USB_HILOGF(MODULE_SERVICE,
-                   "%{public}s:%{public}d device:%{public}s  bus:%{public}hhu dev:%{public}hhu already exist", __func__,
-                   __LINE__, name.c_str(), busNum, devNum);
+        USB_HILOGF(MODULE_SERVICE, "device:%{public}s bus:%{public}hhu dev:%{public}hhu already exist", name.c_str(),
+            busNum, devNum);
         UsbDevice *devOld = iter->second;
         devices_.erase(iter);
         if (devOld)
             delete devOld;
     }
-    USB_HILOGF(MODULE_SERVICE, "%{public}s:%{public}d device:%{public}s  bus:%{public}hhu dev:%{public}hhu insert",
-               __func__, __LINE__, name.c_str(), busNum, devNum);
+    USB_HILOGI(MODULE_SERVICE, "device:%{public}s bus:%{public}hhu dev:%{public}hhu insert", name.c_str(), busNum,
+        devNum);
     devices_.insert(std::pair<std::string, UsbDevice *>(name, dev));
     return true;
 }
diff --git a/services/native/src/usb_service.cpp b/services/native/src/usb_service.cpp
index e263b68..2cdb332 100644
--- a/services/native/src/usb_service.cpp
+++ b/services/native/src/usb_service.cpp
@@ -64,7 +64,7 @@ UsbService::~UsbService() {}
 
 void UsbService::OnStart()
 {
-    USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d usb_service OnStart enter", __func__, __LINE__);
+    USB_HILOGI(MODULE_USB_SERVICE, "usb_service OnStart enter");
     if (ready_) {
         USB_HILOGE(MODULE_USB_SERVICE, "OnStart is ready, nothing to do");
         return;
@@ -97,7 +97,7 @@ void UsbService::OnStart()
 
 bool UsbService::Init()
 {
-    USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d usb_service Init enter", __func__, __LINE__);
+    USB_HILOGI(MODULE_USB_SERVICE, "usb_service Init enter");
     if (!eventRunner_) {
         eventRunner_ = AppExecFwk::EventRunner::Create(USB_SERVICE_NAME);
         if (eventRunner_ == nullptr) {
@@ -130,18 +130,18 @@ bool UsbService::InitUsbd()
 {
     usbdSubscriber_ = new(std::nothrow) UsbServiceSubscriber();
     if (usbdSubscriber_ == nullptr) {
-        USB_HILOGE(MODULE_USB_SERVICE, " %{public}s:%{public}d Init failed\n", __func__, __LINE__);
+        USB_HILOGE(MODULE_USB_SERVICE, "Init failed\n");
         return false;
     }
 
     ErrCode ret = UsbdClient::GetInstance().BindUsbdSubscriber(usbdSubscriber_);
-    USB_HILOGE(MODULE_USB_SERVICE, " entry InitUsbd ret: %{public}d", ret);
+    USB_HILOGI(MODULE_USB_SERVICE, "entry InitUsbd ret: %{public}d", ret);
     return SUCCEEDED(ret);
 }
 
 void UsbService::OnStop()
 {
-    USB_HILOGE(MODULE_USB_SERVICE, " entry stop service %{public}d", ready_);
+    USB_HILOGI(MODULE_USB_SERVICE, "entry stop service %{public}d", ready_);
     if (!ready_) {
         return;
     }
@@ -172,15 +172,14 @@ int32_t UsbService::OpenDevice(uint8_t busNum, uint8_t devAddr)
 {
     std::string name = std::to_string(busNum) + "-" + std::to_string(devAddr);
     if (!UsbService::HasRight(name)) {
-        USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d No permission", __func__, __LINE__);
+        USB_HILOGE(MODULE_USB_SERVICE, "No permission");
         return UEC_SERVICE_PERMISSION_DENIED;
     }
 
     const UsbDev dev = {busNum, devAddr};
     int32_t ret = UsbdClient::GetInstance().OpenDevice(dev);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d OpenDevice failed ret:%{public}d", __func__, __LINE__,
-            ret);
+        USB_HILOGE(MODULE_USB_SERVICE, "OpenDevice failed ret:%{public}d", ret);
     }
 
     return ret;
@@ -222,7 +221,7 @@ int32_t UsbService::GetDevices(std::vector<UsbDevice> &deviceList)
 {
     std::map<std::string, UsbDevice *> devices;
     usbHostManger_->GetDevices(devices);
-    USB_HILOGI(MODULE_USB_SERVICE, "%{public}s list size %{public}zu", __func__, devices.size());
+    USB_HILOGI(MODULE_USB_SERVICE, "list size %{public}zu", devices.size());
     for (auto it = devices.begin(); it != devices.end(); ++it) {
         deviceList.push_back(*it->second);
     }
@@ -287,8 +286,7 @@ int32_t UsbService::BulkTransferRead(const UsbDev &devInfo, const UsbPipe &pipe,
 {
     int32_t ret = UsbdClient::GetInstance().BulkTransferRead(devInfo, pipe, timeOut, bufferData);
     if (UEC_OK != ret) {
-        USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d BulkTransferRead error ret:%{public}d", __func__,
-                   __LINE__, ret);
+        USB_HILOGE(MODULE_USB_SERVICE, "BulkTransferRead error ret:%{public}d", ret);
     }
     return ret;
 }
@@ -298,8 +296,7 @@ int32_t UsbService::BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, co
 {
     int32_t ret = UsbdClient::GetInstance().BulkTransferWrite(dev, pipe, timeOut, bufferData);
     if (UEC_OK != ret) {
-        USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d BulkTransferWrite error ret:%{public}d", __func__,
-                   __LINE__, ret);
+        USB_HILOGE(MODULE_USB_SERVICE, "BulkTransferWrite error ret:%{public}d", ret);
     }
     return ret;
 }
@@ -308,7 +305,7 @@ int32_t UsbService::ControlTransfer(const UsbDev &dev, const UsbCtrlTransfer &ct
 {
     int32_t ret = UsbdClient::GetInstance().ControlTransfer(dev, ctrl, bufferData);
     if (UEC_OK != ret) {
-        USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d error ret:%{public}d", __func__, __LINE__, ret);
+        USB_HILOGE(MODULE_USB_SERVICE, "error ret:%{public}d", ret);
     }
     return ret;
 }
@@ -336,7 +333,7 @@ int32_t UsbService::GetRawDescriptor(uint8_t busNum, uint8_t devAddr, std::vecto
     const UsbDev dev = {busNum, devAddr};
     int32_t ret = UsbdClient::GetInstance().GetRawDescriptor(dev, bufferData);
     if (UEC_OK != ret) {
-        USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d error ret:%{public}d", __func__, __LINE__, ret);
+        USB_HILOGE(MODULE_USB_SERVICE, "error ret:%{public}d", ret);
     }
     return ret;
 }
@@ -346,7 +343,7 @@ int32_t UsbService::GetFileDescriptor(uint8_t busNum, uint8_t devAddr, int32_t &
     const UsbDev dev = {busNum, devAddr};
     int32_t ret = UsbdClient::GetInstance().GetFileDescriptor(dev, fd);
     if (UEC_OK != ret) {
-        USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d error ret:%{public}d", __func__, __LINE__, ret);
+        USB_HILOGE(MODULE_USB_SERVICE, "error ret:%{public}d", ret);
     }
     return ret;
 }
@@ -356,7 +353,7 @@ int32_t UsbService::RequestQueue(const UsbDev &dev, const UsbPipe &pipe, const s
 {
     int32_t ret = UsbdClient::GetInstance().RequestQueue(dev, pipe, clientData, bufferData);
     if (UEC_OK != ret) {
-        USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d error ret:%{public}d", __func__, __LINE__, ret);
+        USB_HILOGE(MODULE_USB_SERVICE, "error ret:%{public}d", ret);
     }
     return ret;
 }
@@ -366,7 +363,7 @@ int32_t UsbService::RequestWait(const UsbDev &dev, int32_t timeOut, std::vector<
 {
     int32_t ret = UsbdClient::GetInstance().RequestWait(dev, clientData, bufferData, timeOut);
     if (UEC_OK != ret) {
-        USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d error ret:%{public}d", __func__, __LINE__, ret);
+        USB_HILOGE(MODULE_USB_SERVICE, "error ret:%{public}d", ret);
     }
     return ret;
 }
@@ -396,20 +393,18 @@ static std::string GetDevStringValFromIdx(uint8_t busNum, uint8_t devAddr, uint8
 
     int32_t ret = UsbdClient::GetInstance().GetStringDescriptor(dev, idx, strV);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d get string[%{public}hhu] failed ret:%{public}d", __func__,
-                   __LINE__, idx, ret);
+        USB_HILOGE(MODULE_USB_SERVICE, "get string[%{public}hhu] failed ret:%{public}d", idx, ret);
         return strDesc;
     }
     uint32_t length = strV.size();
     if ((length < DESCRIPTOR_VALUE_START_OFFSET) || (strV[1] != DESCRIPTOR_TYPE_STRING)) {
-        USB_HILOGI(MODULE_USB_SERVICE, "%{public}s:%{public}d type or length error, len:%{public}u", __func__, __LINE__,
-                   length);
+        USB_HILOGI(MODULE_USB_SERVICE, "type or length error, len:%{public}u", length);
         return strDesc;
     }
 
     uint16_t *tbuf = new(std::nothrow) uint16_t[length + 1]();
     if (tbuf == nullptr) {
-        USB_HILOGI(MODULE_USB_SERVICE, "%{public}s:%{public}d new failed\n", __func__, __LINE__);
+        USB_HILOGI(MODULE_USB_SERVICE, "new failed\n");
         return strDesc;
     }
 
@@ -418,8 +413,8 @@ static std::string GetDevStringValFromIdx(uint8_t busNum, uint8_t devAddr, uint8
     }
     std::wstring wstr((wchar_t *)(tbuf), (length - DESCRIPTOR_VALUE_START_OFFSET) / HALF);
     strDesc = std::string(wstr.begin(), wstr.end());
-    USB_HILOGI(MODULE_USB_SERVICE, "%{public}s:%{public}d getString idx:%{public}d String:%{public}s length:%{public}d",
-               __func__, __LINE__, idx, strDesc.c_str(), length);
+    USB_HILOGI(MODULE_USB_SERVICE, "getString idx:%{public}d String:%{public}s length:%{public}d", idx, strDesc.c_str(),
+        length);
     delete[] tbuf;
     return strDesc;
 }
@@ -448,23 +443,20 @@ static int32_t FillDevStrings(UsbDevice &dev)
     dev.SetManufacturerName(GetDevStringValFromIdx(busNum, devAddr, dev.GetiManufacturer()));
     dev.SetProductName(GetDevStringValFromIdx(busNum, devAddr, dev.GetiProduct()));
     dev.SetmSerial(GetDevStringValFromIdx(busNum, devAddr, dev.GetiSerialNumber()));
-    USB_HILOGI(MODULE_USB_SERVICE,
-               "%{public}s:%{public}d iSerial:%{public}d mSerial:%{public}s Manufactur:%{public}s product:%{public}s "
-               "version:%{public}s",
-               __func__, __LINE__, dev.GetiSerialNumber(), dev.GetmSerial().c_str(), dev.GetManufacturerName().c_str(),
-               dev.GetProductName().c_str(), dev.GetVersion().c_str());
+    USB_HILOGI(MODULE_USB_SERVICE, "iSerial:%{public}d mSerial:%{public}s Manufactur:%{public}s product:%{public}s "
+        "version:%{public}s", dev.GetiSerialNumber(), dev.GetmSerial().c_str(), dev.GetManufacturerName().c_str(),
+        dev.GetProductName().c_str(), dev.GetVersion().c_str());
 
     std::vector<USBConfig> configs;
     configs = dev.GetConfigs();
     for (auto it = configs.begin(); it != configs.end(); ++it) {
         it->SetName(GetDevStringValFromIdx(busNum, devAddr, it->GetiConfiguration()));
-        USB_HILOGI(MODULE_USB_SERVICE, "%{public}s:%{public}d Config:%{public}d %{public}s", __func__, __LINE__,
-                   it->GetiConfiguration(), it->GetName().c_str());
+        USB_HILOGI(MODULE_USB_SERVICE, "Config:%{public}d %{public}s", it->GetiConfiguration(), it->GetName().c_str());
         std::vector<UsbInterface> interfaces = it->GetInterfaces();
         for (auto itIF = interfaces.begin(); itIF != interfaces.end(); ++itIF) {
             itIF->SetName(GetDevStringValFromIdx(busNum, devAddr, itIF->GetiInterface()));
-            USB_HILOGI(MODULE_USB_SERVICE, "%{public}s:%{public}d interface:%{public}hhu %{public}s", __func__,
-                __LINE__, itIF->GetiInterface(), itIF->GetName().c_str());
+            USB_HILOGI(MODULE_USB_SERVICE, "interface:%{public}hhu %{public}s", itIF->GetiInterface(),
+                itIF->GetName().c_str());
         }
         it->SetInterfaces(interfaces);
     }
@@ -478,19 +470,15 @@ int32_t UsbService::GetDeviceInfoDescriptor(const UsbDev &uDev, std::vector<uint
     int32_t ret = UsbdClient::GetInstance().GetRawDescriptor(uDev, descriptor);
     if (ret != UEC_OK) {
         UsbdClient::GetInstance().CloseDevice(uDev);
-        USB_HILOGE(MODULE_USB_SERVICE,
-                   "%{public}s:%{public}d GetRawDescriptor failed ret=%{public}d busNum:%{public}d "
-                   "devAddr:%{public}d",
-                   __func__, __LINE__, ret, uDev.busNum, uDev.devAddr);
+        USB_HILOGE(MODULE_USB_SERVICE, "GetRawDescriptor failed ret=%{public}d busNum:%{public}d devAddr:%{public}d",
+            ret, uDev.busNum, uDev.devAddr);
         return ret;
     }
     uint8_t *buffer = descriptor.data();
     uint32_t length = descriptor.size();
     if ((!buffer) || (length == 0)) {
-        USB_HILOGE(MODULE_USB_SERVICE,
-                   "%{public}s:%{public}d GetRawDescriptor failed len=%{public}d busNum:%{public}d "
-                   "devAddr:%{public}d",
-                   __func__, __LINE__, length, uDev.busNum, uDev.devAddr);
+        USB_HILOGE(MODULE_USB_SERVICE, "GetRawDescriptor failed len=%{public}d busNum:%{public}d devAddr:%{public}d",
+            length, uDev.busNum, uDev.devAddr);
         return UEC_SERVICE_INVALID_VALUE;
     }
     dev.SetBusNum(uDev.busNum);
@@ -500,7 +488,7 @@ int32_t UsbService::GetDeviceInfoDescriptor(const UsbDev &uDev, std::vector<uint
     ret = UsbDescriptorParser::ParseDeviceDescriptor(buffer, length, dev);
     if (ret != UEC_OK) {
         UsbdClient::GetInstance().CloseDevice(uDev);
-        USB_HILOGE(MODULE_USB_SERVICE, "%{public}s ParseDeviceDescriptor failed ret=%{public}d", __func__, ret);
+        USB_HILOGE(MODULE_USB_SERVICE, "ParseDeviceDescriptor failed ret=%{public}d", ret);
         return ret;
     }
     return ret;
@@ -515,51 +503,50 @@ int32_t UsbService::GetConfigDescriptor(UsbDevice &dev, std::vector<uint8_t> &de
     int32_t ret = UEC_OK;
     for (uint8_t i = 0; i < dev.GetDescConfigCount(); ++i) {
         if (length <= cursor) {
-            USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d GetConfigDescriptor[%{public}d] length=%{public}d",
-                       __func__, __LINE__, i, length);
+            USB_HILOGE(MODULE_USB_SERVICE, "GetConfigDescriptor[%{public}d] length=%{public}d", i, length);
             break;
         }
-        USB_HILOGI(MODULE_USB_SERVICE, "%{public}s GetConfigDescriptor length=%{public}d", __func__, length);
+        USB_HILOGI(MODULE_USB_SERVICE, "GetConfigDescriptor length=%{public}d", length);
         uint32_t configCursor = 0;
         USBConfig config;
         ret = UsbDescriptorParser::ParseConfigDescriptor(buffer + cursor, length - cursor, configCursor, config);
+        if (ret != UEC_OK) {
+            USB_HILOGE(MODULE_USB_SERVICE, "ParseConfigDescriptor failed ret=%{public}d", ret);
+            return ret;
+        }
         cursor += configCursor;
         configs.push_back(config);
     }
     dev.SetConfigs(configs);
-    USB_HILOGI(MODULE_USB_SERVICE, "%{public}s:%{public}d SetConfigs ret=%{public}d", __func__, __LINE__, ret);
     ret = FillDevStrings(dev);
-    USB_HILOGI(MODULE_USB_SERVICE, "%{public}s:%{public}d FillDevStrings ret=%{public}d", __func__, __LINE__, ret);
+    USB_HILOGI(MODULE_USB_SERVICE, "FillDevStrings ret=%{public}d", ret);
     return ret;
 }
 
 int32_t UsbService::GetDeviceInfo(uint8_t busNum, uint8_t devAddr, UsbDevice &dev)
 {
-    USB_HILOGI(MODULE_USB_SERVICE, "%{public}s:%{public}d busNum:%{public}d devAddr:%{public}d", __func__, __LINE__,
-               busNum, devAddr);
+    USB_HILOGI(MODULE_USB_SERVICE, "busNum:%{public}d devAddr:%{public}d", busNum, devAddr);
     const UsbDev uDev = {busNum, devAddr};
     std::vector<uint8_t> descriptor;
 
     int32_t ret = UsbdClient::GetInstance().OpenDevice(uDev);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_SERVICE, "%{public}s OpenDevice failed ret=%{public}d", __func__, ret);
+        USB_HILOGE(MODULE_USB_SERVICE, "OpenDevice failed ret=%{public}d", ret);
         return ret;
     }
 
     ret = GetDeviceInfoDescriptor(uDev, descriptor, dev);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d GetDeviceInfoDescriptor ret=%{public}d", __func__,
-                   __LINE__, ret);
+        USB_HILOGE(MODULE_USB_SERVICE, "GetDeviceInfoDescriptor ret=%{public}d", ret);
     }
     ret = GetConfigDescriptor(dev, descriptor);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d GetConfigDescriptor ret=%{public}d", __func__, __LINE__,
-                   ret);
+        USB_HILOGE(MODULE_USB_SERVICE, "GetConfigDescriptor ret=%{public}d", ret);
         return ret;
     }
 
     UsbdClient::GetInstance().CloseDevice(uDev);
-    USB_HILOGI(MODULE_USB_SERVICE, "%{public}s CloseDevice=%{public}s", __func__, dev.ToString().c_str());
+    USB_HILOGI(MODULE_USB_SERVICE, "CloseDevice=%{public}s", dev.ToString().c_str());
 
     return UEC_OK;
 }
@@ -568,18 +555,18 @@ bool UsbService::AddDevice(uint8_t busNum, uint8_t devAddr)
 {
     UsbDevice *devInfo = new(std::nothrow) UsbDevice();
     if (devInfo == nullptr) {
-        USB_HILOGI(MODULE_USB_SERVICE, "%{public}s:%{public}d new failed", __func__, __LINE__);
+        USB_HILOGI(MODULE_USB_SERVICE, "new failed");
         return false;
     }
 
     errno_t retSafe = memset_s(devInfo, sizeof(UsbDevice), 0, sizeof(UsbDevice));
     if (retSafe != EOK) {
-        USB_HILOGI(MODULE_USB_SERVICE, "%{public}s:%{public}d memset_s failed", __func__, __LINE__);
+        USB_HILOGI(MODULE_USB_SERVICE, "memset_s failed");
         return false;
     }
 
     int32_t ret = GetDeviceInfo(busNum, devAddr, *devInfo);
-    USB_HILOGI(MODULE_USB_SERVICE, "%{public}s:%{public}d GetDeviceInfo ret=%{public}d", __func__, __LINE__, ret);
+    USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceInfo ret=%{public}d", ret);
     if (ret == UEC_OK) {
         usbHostManger_->AddDevice(devInfo);
         return true;
@@ -590,11 +577,10 @@ bool UsbService::AddDevice(uint8_t busNum, uint8_t devAddr)
 
 bool UsbService::DelDevice(uint8_t busNum, uint8_t devAddr)
 {
-    USB_HILOGI(MODULE_USBD, "%{public}s:%{public}d entry", __func__, __LINE__);
+    USB_HILOGI(MODULE_USBD, "entry");
     int32_t ret = Close(busNum, devAddr);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d Close device failed width ret = %{public}d", __func__, __LINE__,
-                   ret);
+        USB_HILOGE(MODULE_USBD, "Close device failed width ret = %{public}d", ret);
     }
     return usbHostManger_->DelDevice(busNum, devAddr);
 }
@@ -633,8 +619,7 @@ int32_t UsbService::RegBulkCallback(const UsbDev &devInfo, const UsbPipe &pipe,
 {
     int32_t ret = UsbdClient::GetInstance().RegBulkCallback(devInfo, pipe, cb);
     if (UEC_OK != ret) {
-        USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d RegBulkCallback error ret:%{public}d", __func__, __LINE__,
-                   ret);
+        USB_HILOGE(MODULE_USB_SERVICE, "RegBulkCallback error ret:%{public}d", ret);
     }
     return ret;
 }
@@ -643,8 +628,7 @@ int32_t UsbService::UnRegBulkCallback(const UsbDev &devInfo, const UsbPipe &pipe
 {
     int32_t ret = UsbdClient::GetInstance().UnRegBulkCallback(devInfo, pipe);
     if (UEC_OK != ret) {
-        USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d UnRegBulkCallback error ret:%{public}d", __func__,
-                   __LINE__, ret);
+        USB_HILOGE(MODULE_USB_SERVICE, "UnRegBulkCallback error ret:%{public}d", ret);
     }
     return ret;
 }
@@ -652,12 +636,12 @@ int32_t UsbService::UnRegBulkCallback(const UsbDev &devInfo, const UsbPipe &pipe
 int32_t UsbService::BulkRead(const UsbDev &devInfo, const UsbPipe &pipe, sptr<Ashmem> &ashmem)
 {
     if (ashmem == nullptr) {
-        USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d BulkRead error ashmem", __func__, __LINE__);
+        USB_HILOGE(MODULE_USB_SERVICE, "BulkRead error ashmem");
         return UEC_SERVICE_INVALID_VALUE;
     }
     int32_t ret = UsbdClient::GetInstance().BulkRead(devInfo, pipe, ashmem);
     if (UEC_OK != ret) {
-        USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d BulkRead error ret:%{public}d", __func__, __LINE__, ret);
+        USB_HILOGE(MODULE_USB_SERVICE, "BulkRead error ret:%{public}d", ret);
     }
     return ret;
 }
@@ -665,12 +649,12 @@ int32_t UsbService::BulkRead(const UsbDev &devInfo, const UsbPipe &pipe, sptr<As
 int32_t UsbService::BulkWrite(const UsbDev &devInfo, const UsbPipe &pipe, sptr<Ashmem> &ashmem)
 {
     if (ashmem == nullptr) {
-        USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d BulkWrite error ashmem", __func__, __LINE__);
+        USB_HILOGE(MODULE_USB_SERVICE, "BulkWrite error ashmem");
         return UEC_SERVICE_INVALID_VALUE;
     }
     int32_t ret = UsbdClient::GetInstance().BulkWrite(devInfo, pipe, ashmem);
     if (UEC_OK != ret) {
-        USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d BulkWrite error ret:%{public}d", __func__, __LINE__, ret);
+        USB_HILOGE(MODULE_USB_SERVICE, "BulkWrite error ret:%{public}d", ret);
     }
     return ret;
 }
@@ -679,8 +663,7 @@ int32_t UsbService::BulkCancel(const UsbDev &devInfo, const UsbPipe &pipe)
 {
     int32_t ret = UsbdClient::GetInstance().BulkCancel(devInfo, pipe);
     if (UEC_OK != ret) {
-        USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d BulkCancel error ret:%{public}d", __func__, __LINE__,
-                   ret);
+        USB_HILOGE(MODULE_USB_SERVICE, "BulkCancel error ret:%{public}d", ret);
     }
     return ret;
 }
diff --git a/services/native/src/usb_service_subscriber.cpp b/services/native/src/usb_service_subscriber.cpp
index 7d03c8b..a6ef657 100644
--- a/services/native/src/usb_service_subscriber.cpp
+++ b/services/native/src/usb_service_subscriber.cpp
@@ -87,8 +87,8 @@ int32_t UsbServiceSubscriber::DeviceEvent(const UsbInfo &info)
     int32_t status = info.getDevInfoStatus();
     int32_t ret = UEC_OK;
     Want want;
-    USB_HILOGW(MODULE_USBD, "%{public}s:%{public}d status:%{public}d bus:%{public}d dev:%{public}d", __func__, __LINE__,
-               status, info.getDevInfoBusNum(), info.getDevInfoDevNum());
+    USB_HILOGW(MODULE_USBD, "status:%{public}d bus:%{public}d dev:%{public}d", status, info.getDevInfoBusNum(),
+        info.getDevInfoDevNum());
 
     if (Invoking(info, want) == -1) {
         return ret;
@@ -114,8 +114,7 @@ int32_t UsbServiceSubscriber::DeviceEvent(const UsbInfo &info)
     }
     int32_t busNum = info.getDevInfoBusNum();
     int32_t devAddr = info.getDevInfoDevNum();
-    USB_HILOGW(MODULE_USBD, "%{public}s:%{public}d status:%{public}d bus:%{public}d dev:%{public}d", __func__, __LINE__,
-               status, busNum, devAddr);
+    USB_HILOGW(MODULE_USBD, "status:%{public}d bus:%{public}d dev:%{public}d", status, busNum, devAddr);
     auto pms = DelayedSpSingleton<UsbService>::GetInstance();
     if (pms == nullptr) {
         USB_HILOGE(MODULE_USB_SERVICE, "failed to GetInstance");
diff --git a/services/zidl/src/usb_srv_proxy.cpp b/services/zidl/src/usb_srv_proxy.cpp
index 9f7b032..b080a03 100644
--- a/services/zidl/src/usb_srv_proxy.cpp
+++ b/services/zidl/src/usb_srv_proxy.cpp
@@ -13,8 +13,6 @@
  * limitations under the License.
  */
 
-#include <map>
-#include <sstream>
 #include "ipc_types.h"
 #include "message_parcel.h"
 #include "securec.h"
@@ -41,14 +39,14 @@ int32_t UsbServerProxy::SetBufferMessage(MessageParcel &data, const std::vector<
     }
 
     if (!data.WriteUint32(length)) {
-        USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d failed length:%{public}u", __func__, __LINE__, length);
+        USB_HILOGE(MODULE_USBD, "write length failed:%{public}u", length);
         return UEC_SERVICE_WRITE_PARCEL_ERROR;
     }
     if ((ptr) && (length > 0) && !data.WriteBuffer((const void *)ptr, length)) {
-        USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d failed length:%{public}u", __func__, __LINE__, length);
+        USB_HILOGE(MODULE_USBD, "write buffer failed length:%{public}u", length);
         return UEC_SERVICE_WRITE_PARCEL_ERROR;
     } else {
-        USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d success length:%{public}u", __func__, __LINE__, length);
+        USB_HILOGE(MODULE_USBD, "success length:%{public}u", length);
     }
     return UEC_OK;
 }
@@ -58,17 +56,17 @@ int32_t UsbServerProxy::GetBufferMessage(MessageParcel &data, std::vector<uint8_
     uint32_t dataSize = 0;
     bufferData.clear();
     if (!data.ReadUint32(dataSize)) {
-        USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d failed", __func__, __LINE__);
+        USB_HILOGE(MODULE_USBD, "read dataSize failed");
         return UEC_SERVICE_READ_PARCEL_ERROR;
     }
     if (dataSize == 0) {
-        USB_HILOGI(MODULE_USBD, "%{public}s:%{public}d size:%{public}u", __func__, __LINE__, dataSize);
+        USB_HILOGI(MODULE_USBD, "invalid size:%{public}u", dataSize);
         return UEC_OK;
     }
 
     const uint8_t *readData = data.ReadUnpadBuffer(dataSize);
     if (readData == nullptr) {
-        USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d failed size:%{public}u", __func__, __LINE__, dataSize);
+        USB_HILOGE(MODULE_USBD, "failed size:%{public}u", dataSize);
         return UEC_SERVICE_READ_PARCEL_ERROR;
     }
     std::vector<uint8_t> tdata(readData, readData + dataSize);
@@ -81,7 +79,7 @@ int32_t UsbServerProxy::GetDevices(std::vector<UsbDevice> &deviceList)
     int32_t ret;
     sptr<IRemoteObject> remote = Remote();
     if (remote == nullptr) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "UsbServerProxy::%{public}s remote is failed", __func__);
+        USB_HILOGE(MODULE_USB_INNERKIT, "remote is failed");
         return ERR_INVALID_VALUE;
     }
     MessageParcel data;
@@ -89,13 +87,13 @@ int32_t UsbServerProxy::GetDevices(std::vector<UsbDevice> &deviceList)
     MessageOption option;
 
     if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
+        USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
         return ERR_INVALID_VALUE;
     }
 
     ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_GET_DEVICES), data, reply, option);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "UsbServerProxy::%{public}s failed code: %{public}d", __func__, ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "failed code: %{public}d", ret);
         return ret;
     }
     ret = GetDeviceListMessageParcel(reply, deviceList);
@@ -159,12 +157,12 @@ int32_t UsbServerProxy::GetDeviceMessageParcel(MessageParcel &data, UsbDevice &d
     data.ReadString(tstr);
     devInfo.SetmSerial(tstr);
 
-    USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s:%{public}d devName:%{public}s Bus:%{public}d dev:%{public}d ", __func__,
-               __LINE__, devInfo.GetName().c_str(), devInfo.GetBusNum(), devInfo.GetDevAddr());
+    USB_HILOGE(MODULE_USB_INNERKIT, "devName:%{public}s Bus:%{public}d dev:%{public}d ", devInfo.GetName().c_str(),
+        devInfo.GetBusNum(), devInfo.GetDevAddr());
     std::vector<USBConfig> configs;
     GetDeviceConfigsMessageParcel(data, configs);
     devInfo.SetConfigs(configs);
-    USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s ToString : %{public}s", __func__, devInfo.ToString().c_str());
+    USB_HILOGE(MODULE_USB_INNERKIT, "ToString : %{public}s", devInfo.ToString().c_str());
     return UEC_OK;
 }
 
@@ -194,7 +192,7 @@ int32_t UsbServerProxy::GetDeviceConfigsMessageParcel(MessageParcel &data, std::
         GetDeviceInterfacesMessageParcel(data, interfaces);
         config.SetInterfaces(interfaces);
         configs.push_back(config);
-        USB_HILOGI(MODULE_USB_SERVICE, "%{public}s devInfo=%{public}s", __func__, config.ToString().c_str());
+        USB_HILOGI(MODULE_USB_SERVICE, "devInfo=%{public}s", config.ToString().c_str());
     }
 
     return UEC_OK;
@@ -232,7 +230,7 @@ int32_t UsbServerProxy::GetDeviceInterfacesMessageParcel(MessageParcel &data, st
         }
         interface.SetEndpoints(eps);
         interfaces.push_back(interface);
-        USB_HILOGI(MODULE_USB_SERVICE, "%{public}s devInfo=%{public}s", __func__, interface.ToString().c_str());
+        USB_HILOGI(MODULE_USB_SERVICE, "devInfo=%{public}s", interface.ToString().c_str());
     }
     return UEC_OK;
 }
@@ -253,7 +251,7 @@ int32_t UsbServerProxy::GetDeviceEndpointsMessageParcel(MessageParcel &data, std
         data.ReadInt32(tmp);
         ep.SetMaxPacketSize(tmp);
         eps.push_back(ep);
-        USB_HILOGI(MODULE_USB_SERVICE, "%{public}s devInfo=%{public}s", __func__, ep.ToString().c_str());
+        USB_HILOGI(MODULE_USB_SERVICE, "devInfo=%{public}s", ep.ToString().c_str());
     }
     return UEC_OK;
 }
@@ -266,15 +264,14 @@ int32_t UsbServerProxy::OpenDevice(uint8_t busNum, uint8_t devAddr)
     sptr<IRemoteObject> remote = Remote();
     RETURN_IF_WITH_RET(remote == nullptr, UEC_SERVICE_INNER_ERR);
     if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
+        USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
         return UEC_INTERFACE_WRITE_PARCEL_ERROR;
     }
 
     SetDeviceMessage(data, busNum, devAddr);
     int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_OPEN_DEVICE), data, reply, option);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "UsbServerProxy::%{public}s SendRequest is failed, error code: %{public}d",
-                   __func__, ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "SendRequest is failed, error code: %{public}d", ret);
         return ret;
     }
     return ret;
@@ -288,15 +285,14 @@ bool UsbServerProxy::HasRight(std::string deviceName)
     sptr<IRemoteObject> remote = Remote();
     RETURN_IF_WITH_RET(remote == nullptr, false);
     if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
+        USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
         return false;
     }
 
     WRITE_PARCEL_WITH_RET(data, String, deviceName, false);
     int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_HAS_RIGHT), data, reply, option);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "UsbServerProxy::%{public}s SendRequest is failed, error code: %{public}d",
-                   __func__, ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "SendRequest is failed, error code: %{public}d", ret);
         return false;
     }
 
@@ -314,14 +310,13 @@ int32_t UsbServerProxy::RequestRight(std::string deviceName)
     sptr<IRemoteObject> remote = Remote();
     RETURN_IF_WITH_RET(remote == nullptr, UEC_INTERFACE_INVALID_VALUE);
     if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
+        USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
         return UEC_INTERFACE_WRITE_PARCEL_ERROR;
     }
     WRITE_PARCEL_WITH_RET(data, String, deviceName, UEC_INTERFACE_WRITE_PARCEL_ERROR);
     int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_REQUEST_RIGHT), data, reply, option);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "UsbServerProxy::%{public}s SendRequest is failed, error code: %{public}d",
-                   __func__, ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "SendRequest is failed, error code: %{public}d", ret);
     }
     return ret;
 }
@@ -334,14 +329,13 @@ int32_t UsbServerProxy::RemoveRight(std::string deviceName)
     sptr<IRemoteObject> remote = Remote();
     RETURN_IF_WITH_RET(remote == nullptr, UEC_INTERFACE_INVALID_VALUE);
     if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
+        USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
         return UEC_INTERFACE_WRITE_PARCEL_ERROR;
     }
     WRITE_PARCEL_WITH_RET(data, String, deviceName, UEC_INTERFACE_WRITE_PARCEL_ERROR);
     int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_REMOVE_RIGHT), data, reply, option);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "UsbServerProxy::%{public}s SendRequest is failed, error code: %d", __func__,
-                   ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "SendRequest is failed, error code: %{public}d", ret);
     }
     return ret;
 }
@@ -356,15 +350,14 @@ int32_t UsbServerProxy::GetCurrentFunctions(int32_t &funcs)
     MessageOption option;
 
     if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
-        USB_HILOGE(MODULE_USB_SERVICE, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
+        USB_HILOGE(MODULE_USB_SERVICE, "write descriptor failed!");
         return UEC_INTERFACE_WRITE_PARCEL_ERROR;
     }
 
     int32_t ret =
         remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_GET_CURRENT_FUNCTIONS), data, reply, option);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_SERVICE, "UsbServerProxy::%{public}s SendRequest is failed, error code: %d", __func__,
-                   ret);
+        USB_HILOGE(MODULE_USB_SERVICE, "SendRequest is failed, error code: %d", ret);
         return ret;
     }
     READ_PARCEL_WITH_RET(reply, Int32, funcs, UEC_INTERFACE_READ_PARCEL_ERROR);
@@ -381,15 +374,14 @@ int32_t UsbServerProxy::SetCurrentFunctions(int32_t funcs)
     MessageParcel reply;
 
     if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
-        USB_HILOGE(MODULE_USB_SERVICE, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
+        USB_HILOGE(MODULE_USB_SERVICE, "write descriptor failed!");
         return UEC_INTERFACE_WRITE_PARCEL_ERROR;
     }
     WRITE_PARCEL_WITH_RET(data, Int32, funcs, UEC_INTERFACE_WRITE_PARCEL_ERROR);
     int32_t ret =
         remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_SET_CURRENT_FUNCTIONS), data, reply, option);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_SERVICE, "UsbServerProxy::%{public}s SendRequest is failed, error code: %d", __func__,
-                   ret);
+        USB_HILOGE(MODULE_USB_SERVICE, "SendRequest is failed, error code: %d", ret);
     }
     return ret;
 }
@@ -403,15 +395,14 @@ int32_t UsbServerProxy::UsbFunctionsFromString(std::string_view funcs)
     MessageParcel reply;
 
     if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
-        USB_HILOGE(MODULE_USB_SERVICE, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
+        USB_HILOGE(MODULE_USB_SERVICE, "write descriptor failed!");
         return UEC_INTERFACE_WRITE_PARCEL_ERROR;
     }
     WRITE_PARCEL_WITH_RET(data, String, std::string { funcs }, UEC_INTERFACE_WRITE_PARCEL_ERROR);
     int32_t ret =
         remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_USB_FUNCTIONS_FROM_STRING), data, reply, option);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_SERVICE, "UsbServerProxy::%{public}s SendRequest is failed, error code: %d", __func__,
-                   ret);
+        USB_HILOGE(MODULE_USB_SERVICE, "SendRequest is failed, error code: %d", ret);
         return UEC_INTERFACE_INVALID_VALUE;
     }
     int32_t result = 0;
@@ -430,15 +421,14 @@ std::string UsbServerProxy::UsbFunctionsToString(int32_t funcs)
     RETURN_IF_WITH_RET(remote == nullptr, INVALID_STRING_VALUE);
 
     if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
-        USB_HILOGE(MODULE_USB_SERVICE, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
+        USB_HILOGE(MODULE_USB_SERVICE, "write descriptor failed!");
         return INVALID_STRING_VALUE;
     }
     WRITE_PARCEL_WITH_RET(data, Int32, funcs, INVALID_STRING_VALUE);
     int32_t ret =
         remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_USB_FUNCTIONS_TO_STRING), data, reply, option);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_SERVICE, "UsbServerProxy::%{public}s SendRequest is failed, error code: %d", __func__,
-                   ret);
+        USB_HILOGE(MODULE_USB_SERVICE, "SendRequest is failed, error code: %d", ret);
         return INVALID_STRING_VALUE;
     }
     std::string result;
@@ -455,13 +445,12 @@ int32_t UsbServerProxy::GetPorts(std::vector<UsbPort> &ports)
     MessageParcel reply;
     RETURN_IF_WITH_RET(remote == nullptr, UEC_INTERFACE_INVALID_VALUE);
     if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
+        USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
         return UEC_INTERFACE_WRITE_PARCEL_ERROR;
     }
     int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_GET_PORTS), data, reply, option);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "UsbServerProxy::%{public}s SendRequest is failed, error code: %d", __func__,
-                   ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "SendRequest is failed, error code: %d", ret);
         return ret;
     }
     int32_t size;
@@ -502,14 +491,13 @@ int32_t UsbServerProxy::GetSupportedModes(int32_t portId, int32_t &supportedMode
     sptr<IRemoteObject> remote = Remote();
     RETURN_IF_WITH_RET(remote == nullptr, UEC_INTERFACE_INVALID_VALUE);
     if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
+        USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
         return UEC_INTERFACE_WRITE_PARCEL_ERROR;
     }
     WRITE_PARCEL_WITH_RET(data, Int32, portId, UEC_INTERFACE_WRITE_PARCEL_ERROR);
     int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_GET_SUPPORTED_MODES), data, reply, option);
     if (ret) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "UsbServerProxy::%{public}s SendRequest is failed, error code: %d", __func__,
-                   ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "SendRequest is failed, error code: %d", ret);
         return ret;
     }
     READ_PARCEL_WITH_RET(reply, Int32, supportedModes, UEC_INTERFACE_READ_PARCEL_ERROR);
@@ -524,7 +512,7 @@ int32_t UsbServerProxy::SetPortRole(int32_t portId, int32_t powerRole, int32_t d
     sptr<IRemoteObject> remote = Remote();
     RETURN_IF_WITH_RET(remote == nullptr, UEC_INTERFACE_INVALID_VALUE);
     if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
+        USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
         return UEC_INTERFACE_WRITE_PARCEL_ERROR;
     }
     WRITE_PARCEL_WITH_RET(data, Int32, portId, UEC_INTERFACE_WRITE_PARCEL_ERROR);
@@ -532,8 +520,7 @@ int32_t UsbServerProxy::SetPortRole(int32_t portId, int32_t powerRole, int32_t d
     WRITE_PARCEL_WITH_RET(data, Int32, dataRole, UEC_INTERFACE_WRITE_PARCEL_ERROR);
     int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_SET_PORT_ROLE), data, reply, option);
     if (ret) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "UsbServerProxy::%{public}s SendRequest is failed, error code: %d", __func__,
-                   ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "SendRequest is failed, error code: %d", ret);
         return ret;
     }
     return ret;
@@ -547,7 +534,7 @@ int32_t UsbServerProxy::ClaimInterface(uint8_t busNum, uint8_t devAddr, uint8_t
     MessageParcel reply;
     MessageOption option;
     if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
+        USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
         return ERR_ENOUGH_DATA;
     }
     SetDeviceMessage(data, busNum, devAddr);
@@ -555,8 +542,7 @@ int32_t UsbServerProxy::ClaimInterface(uint8_t busNum, uint8_t devAddr, uint8_t
     WRITE_PARCEL_WITH_RET(data, Uint8, force, UEC_SERVICE_WRITE_PARCEL_ERROR);
     int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_CLAIM_INTERFACE), data, reply, option);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "UsbServerProxy::%{public}s SendRequest is failed, error code: %{public}d",
-                   __func__, ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "SendRequest is failed, error code: %{public}d", ret);
         return ret;
     }
     return ret;
@@ -570,15 +556,14 @@ int32_t UsbServerProxy::ReleaseInterface(uint8_t busNum, uint8_t devAddr, uint8_
     MessageParcel reply;
     MessageOption option;
     if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
+        USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
         return ERR_ENOUGH_DATA;
     }
     SetDeviceMessage(data, busNum, devAddr);
     WRITE_PARCEL_WITH_RET(data, Uint8, interface, UEC_SERVICE_WRITE_PARCEL_ERROR);
     int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_RELEASE_INTERFACE), data, reply, option);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "UsbServerProxy::%{public}s SendRequest is failed, error code: %d", __func__,
-                   ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "SendRequest is failed, error code: %d", ret);
     }
     return ret;
 }
@@ -591,7 +576,7 @@ int32_t UsbServerProxy::BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe,
     MessageParcel reply;
     MessageOption option;
     if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
+        USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
         return ERR_ENOUGH_DATA;
     }
     SetDeviceMessage(data, dev.busNum, dev.devAddr);
@@ -600,17 +585,15 @@ int32_t UsbServerProxy::BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe,
     WRITE_PARCEL_WITH_RET(data, Int32, timeOut, UEC_SERVICE_WRITE_PARCEL_ERROR);
     int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_BULK_TRANSFER_READ), data, reply, option);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "UsbServerProxy::%{public}s SendRequest is failed, error code: %d", __func__,
-                   ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "SendRequest is failed, error code: %d", ret);
         return ret;
     }
     ret = GetBufferMessage(reply, bufferData);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "UsbServerProxy::%{public}s get buffer is failed, error code: %d", __func__,
-                   ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "get buffer is failed, error code: %d", ret);
         return ret;
     }
-    USB_HILOGI(MODULE_USBD, "%{public}s Set buffer message. length = %{public}zu", __func__, bufferData.size());
+    USB_HILOGI(MODULE_USBD, "Set buffer message. length = %{public}zu", bufferData.size());
     return ret;
 }
 int32_t UsbServerProxy::BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe,
@@ -622,7 +605,7 @@ int32_t UsbServerProxy::BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe
     MessageParcel reply;
     MessageOption option;
     if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
+        USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
         return ERR_ENOUGH_DATA;
     }
     SetDeviceMessage(data, dev.busNum, dev.devAddr);
@@ -631,14 +614,12 @@ int32_t UsbServerProxy::BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe
     WRITE_PARCEL_WITH_RET(data, Int32, timeOut, UEC_SERVICE_WRITE_PARCEL_ERROR);
     int32_t ret = SetBufferMessage(data, bufferData);
     if (UEC_OK != ret) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s:%{public}d SetBufferMessage ret:%{public}d", __func__,
-                   __LINE__, ret);
+        USB_HILOGE(MODULE_INNERKIT, "SetBufferMessage ret:%{public}d", ret);
         return ret;
     }
     ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_BULK_TRANSFER_WRITE), data, reply, option);
     if (UEC_OK != ret) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s:%{public}d SendRequest ret:%{public}d", __func__,
-                   __LINE__, ret);
+        USB_HILOGE(MODULE_INNERKIT, "SendRequest ret:%{public}d", ret);
     }
     return ret;
 }
@@ -652,7 +633,7 @@ int32_t UsbServerProxy::ControlTransfer(const UsbDev &dev, const UsbCtrlTransfer
     MessageParcel reply;
     MessageOption option;
     if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
+        USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
         return UEC_SERVICE_INNER_ERR;
     }
     SetDeviceMessage(data, dev.busNum, dev.devAddr);
@@ -663,25 +644,22 @@ int32_t UsbServerProxy::ControlTransfer(const UsbDev &dev, const UsbCtrlTransfer
     WRITE_PARCEL_WITH_RET(data, Int32, ctrl.timeout, UEC_SERVICE_WRITE_PARCEL_ERROR);
     int32_t ret = SetBufferMessage(data, bufferData);
     if (UEC_OK != ret) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s:%{public}d write failed! len:%{public}d", __func__,
-                   __LINE__, ret);
+        USB_HILOGE(MODULE_INNERKIT, "write failed! len:%{public}d", ret);
         return ret;
     }
     bool isWrite = ((ctrl.requestType & USB_ENDPOINT_DIR_MASK) == USB_ENDPOINT_DIR_OUT);
     ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_CONTROL_TRANSFER), data, reply, option);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s:%{public}d USB_FUN_CONTROL_TRANSFER ret:%{public}d",
-                   __func__, __LINE__, ret);
+        USB_HILOGE(MODULE_INNERKIT, "USB_FUN_CONTROL_TRANSFER ret:%{public}d", ret);
         return ret;
     }
     if (!isWrite) {
         ret = GetBufferMessage(reply, bufferData);
         if (UEC_OK != ret) {
-            USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d Get buffer message error. ret = %{public}d", __func__,
-                       __LINE__, ret);
+            USB_HILOGE(MODULE_USBD, "Get buffer message error. ret = %{public}d", ret);
             return ret;
         }
-        USB_HILOGI(MODULE_USBD, "%{public}s Get buffer message. length = %{public}zu", __func__, bufferData.size());
+        USB_HILOGI(MODULE_USBD, "Get buffer message. length = %{public}zu", bufferData.size());
     }
     return UEC_OK;
 }
@@ -693,15 +671,14 @@ int32_t UsbServerProxy::SetActiveConfig(uint8_t busNum, uint8_t devAddr, uint8_t
     MessageParcel reply;
     MessageOption option;
     if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
+        USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
         return ERR_ENOUGH_DATA;
     }
     SetDeviceMessage(data, busNum, devAddr);
     WRITE_PARCEL_WITH_RET(data, Uint8, configIndex, UEC_SERVICE_WRITE_PARCEL_ERROR);
     int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_SET_ACTIVE_CONFIG), data, reply, option);
     if (UEC_OK != ret) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s:%{public}d USB_FUN_SET_ACTIVE_CONFIG ret:%{public}d",
-                   __func__, __LINE__, ret);
+        USB_HILOGE(MODULE_INNERKIT, "USB_FUN_SET_ACTIVE_CONFIG ret:%{public}d", ret);
     }
     return ret;
 }
@@ -713,14 +690,13 @@ int32_t UsbServerProxy::GetActiveConfig(uint8_t busNum, uint8_t devAddr, uint8_t
     MessageParcel reply;
     MessageOption option;
     if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
+        USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
         return ERR_ENOUGH_DATA;
     }
     SetDeviceMessage(data, busNum, devAddr);
     int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_GET_ACTIVE_CONFIG), data, reply, option);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s:%{public}d USB_FUN_GET_ACTIVE_CONFIG ret:%{public}d",
-                   __func__, __LINE__, ret);
+        USB_HILOGE(MODULE_INNERKIT, "USB_FUN_GET_ACTIVE_CONFIG ret:%{public}d", ret);
         return ret;
     }
     READ_PARCEL_WITH_RET(reply, Uint8, configIndex, UEC_SERVICE_WRITE_PARCEL_ERROR);
@@ -734,7 +710,7 @@ int32_t UsbServerProxy::SetInterface(uint8_t busNum, uint8_t devAddr, uint8_t in
     MessageParcel reply;
     MessageOption option;
     if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
+        USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
         return ERR_ENOUGH_DATA;
     }
     SetDeviceMessage(data, busNum, devAddr);
@@ -742,8 +718,7 @@ int32_t UsbServerProxy::SetInterface(uint8_t busNum, uint8_t devAddr, uint8_t in
     WRITE_PARCEL_WITH_RET(data, Uint8, altIndex, UEC_SERVICE_WRITE_PARCEL_ERROR);
     int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_SET_INTERFACE), data, reply, option);
     if (UEC_OK != ret) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s:%{public}d USB_FUN_SET_INTERFACE ret:%{public}d",
-                   __func__, __LINE__, ret);
+        USB_HILOGE(MODULE_INNERKIT, "USB_FUN_SET_INTERFACE ret:%{public}d", ret);
     }
     return ret;
 }
@@ -755,7 +730,7 @@ int32_t UsbServerProxy::GetRawDescriptor(uint8_t busNum, uint8_t devAddr, std::v
     MessageParcel reply;
     MessageOption option;
     if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
+        USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
         return ERR_ENOUGH_DATA;
     }
     SetDeviceMessage(data, busNum, devAddr);
@@ -763,8 +738,7 @@ int32_t UsbServerProxy::GetRawDescriptor(uint8_t busNum, uint8_t devAddr, std::v
     if (ret == UEC_OK) {
         ret = GetBufferMessage(reply, bufferData);
         if (UEC_OK != ret) {
-            USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s:%{public}d get failed ret:%{public}d", __func__,
-                       __LINE__, ret);
+            USB_HILOGE(MODULE_INNERKIT, "get failed ret:%{public}d", ret);
         }
     }
     return ret;
@@ -778,7 +752,7 @@ int32_t UsbServerProxy::GetFileDescriptor(uint8_t busNum, uint8_t devAddr, int32
     MessageParcel reply;
     MessageOption option;
     if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
+        USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
         return ERR_ENOUGH_DATA;
     }
     SetDeviceMessage(data, busNum, devAddr);
@@ -798,7 +772,7 @@ int32_t UsbServerProxy::RequestQueue(const UsbDev &dev, const UsbPipe &pipe, con
     MessageParcel reply;
     MessageOption option;
     if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s get descriptor failed!", __func__);
+        USB_HILOGE(MODULE_INNERKIT, "get descriptor failed!");
         return ERR_ENOUGH_DATA;
     }
     SetDeviceMessage(data, dev.busNum, dev.devAddr);
@@ -807,21 +781,19 @@ int32_t UsbServerProxy::RequestQueue(const UsbDev &dev, const UsbPipe &pipe, con
 
     int32_t ret = UsbServerProxy::SetBufferMessage(data, clientData);
     if (UEC_OK != ret) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s:%{public}d setBuffer failed ret:%{public}d", __func__,
-                   __LINE__, ret);
+        USB_HILOGE(MODULE_INNERKIT, "set clientData failed ret:%{public}d", ret);
         return ERR_INVALID_VALUE;
     }
 
     ret = UsbServerProxy::SetBufferMessage(data, bufferData);
     if (UEC_OK != ret) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s:%{public}d setBuffer failed ret:%{public}d", __func__,
-                   __LINE__, ret);
+        USB_HILOGE(MODULE_INNERKIT, "setBuffer failed ret:%{public}d", ret);
         return ERR_INVALID_VALUE;
     }
 
     ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_REQUEST_QUEUE), data, reply, option);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s:%{public}d queue failed!", __func__, __LINE__);
+        USB_HILOGE(MODULE_INNERKIT, "SendRequest failed!");
         return ret;
     }
     return ret;
@@ -837,7 +809,7 @@ int32_t UsbServerProxy::RequestWait(const UsbDev &dev, int32_t timeOut, std::vec
     MessageOption option;
 
     if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s get descriptor failed!", __func__);
+        USB_HILOGE(MODULE_INNERKIT, "get descriptor failed!");
         return ERR_ENOUGH_DATA;
     }
 
@@ -845,22 +817,19 @@ int32_t UsbServerProxy::RequestWait(const UsbDev &dev, int32_t timeOut, std::vec
     WRITE_PARCEL_WITH_RET(data, Int32, timeOut, UEC_SERVICE_WRITE_PARCEL_ERROR);
     int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_REQUEST_WAIT), data, reply, option);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s:%{public}d queue failed! ret:%{public}d", __func__,
-                   __LINE__, ret);
+        USB_HILOGE(MODULE_INNERKIT, "queue failed! ret:%{public}d", ret);
         return ret;
     }
 
     ret = UsbServerProxy::GetBufferMessage(reply, clientData);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s:%{public}d get clientData failed! ret:%{public}d",
-                   __func__, __LINE__, ret);
+        USB_HILOGE(MODULE_INNERKIT, "get clientData failed! ret:%{public}d", ret);
         return ret;
     }
 
     ret = UsbServerProxy::GetBufferMessage(reply, bufferData);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s:%{public}d get buffer failed! ret:%{public}d", __func__,
-                   __LINE__, ret);
+        USB_HILOGE(MODULE_INNERKIT, "get buffer failed! ret:%{public}d", ret);
         return ret;
     }
 
@@ -876,7 +845,7 @@ int32_t UsbServerProxy::RequestCancel(uint8_t busNum, uint8_t devAddr, uint8_t i
     MessageParcel reply;
     MessageOption option;
     if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s get descriptor failed!", __func__);
+        USB_HILOGE(MODULE_INNERKIT, "get descriptor failed!");
         return ERR_ENOUGH_DATA;
     }
 
@@ -885,7 +854,7 @@ int32_t UsbServerProxy::RequestCancel(uint8_t busNum, uint8_t devAddr, uint8_t i
     WRITE_PARCEL_WITH_RET(data, Uint8, endpointId, UEC_SERVICE_WRITE_PARCEL_ERROR);
     ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_REQUEST_CANCEL), data, reply, option);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s request cancel failed!", __func__);
+        USB_HILOGE(MODULE_INNERKIT, "request cancel failed!");
     }
 
     return ret;
@@ -899,14 +868,14 @@ int32_t UsbServerProxy::Close(uint8_t busNum, uint8_t devAddr)
     MessageParcel data;
     MessageParcel reply;
     if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s get descriptor failed!", __func__);
+        USB_HILOGE(MODULE_INNERKIT, "get descriptor failed!");
         return ERR_ENOUGH_DATA;
     }
 
     SetDeviceMessage(data, busNum, devAddr);
     int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_CLOSE_DEVICE), data, reply, option);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s queue failed!", __func__);
+        USB_HILOGE(MODULE_INNERKIT, "queue failed!");
         return ret;
     }
 
@@ -919,7 +888,7 @@ int32_t UsbServerProxy::RegBulkCallback(const UsbDev &dev, const UsbPipe &pipe,
     RETURN_IF_WITH_RET(remote == nullptr, UEC_SERVICE_INNER_ERR);
     MessageParcel data;
     if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
+        USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
         return ERR_ENOUGH_DATA;
     }
     SetDeviceMessage(data, dev.busNum, dev.devAddr);
@@ -930,7 +899,7 @@ int32_t UsbServerProxy::RegBulkCallback(const UsbDev &dev, const UsbPipe &pipe,
     MessageParcel reply;
     int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_REG_BULK_CALLBACK), data, reply, option);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s SendRequest failed!", __func__);
+        USB_HILOGE(MODULE_INNERKIT, "SendRequest failed!");
         return ret;
     }
     return ret;
@@ -942,7 +911,7 @@ int32_t UsbServerProxy::UnRegBulkCallback(const UsbDev &dev, const UsbPipe &pipe
     RETURN_IF_WITH_RET(remote == nullptr, UEC_SERVICE_INNER_ERR);
     MessageParcel data;
     if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
+        USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
         return ERR_ENOUGH_DATA;
     }
     SetDeviceMessage(data, dev.busNum, dev.devAddr);
@@ -952,7 +921,7 @@ int32_t UsbServerProxy::UnRegBulkCallback(const UsbDev &dev, const UsbPipe &pipe
     MessageParcel reply;
     int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_UNREG_BULK_CALLBACK), data, reply, option);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s SendRequest failed!", __func__);
+        USB_HILOGE(MODULE_INNERKIT, "SendRequest failed!");
         return ret;
     }
     return ret;
@@ -964,7 +933,7 @@ int32_t UsbServerProxy::BulkRead(const UsbDev &dev, const UsbPipe &pipe, sptr<As
     RETURN_IF_WITH_RET(remote == nullptr, UEC_SERVICE_INNER_ERR);
     MessageParcel data;
     if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
+        USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
         return ERR_ENOUGH_DATA;
     }
     SetDeviceMessage(data, dev.busNum, dev.devAddr);
@@ -975,7 +944,7 @@ int32_t UsbServerProxy::BulkRead(const UsbDev &dev, const UsbPipe &pipe, sptr<As
     MessageParcel reply;
     int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_BULK_AYSNC_READ), data, reply, option);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s SendRequest failed!", __func__);
+        USB_HILOGE(MODULE_INNERKIT, "SendRequest failed!");
         return ret;
     }
     return ret;
@@ -987,7 +956,7 @@ int32_t UsbServerProxy::BulkWrite(const UsbDev &dev, const UsbPipe &pipe, sptr<A
     RETURN_IF_WITH_RET(remote == nullptr, UEC_SERVICE_INNER_ERR);
     MessageParcel data;
     if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
+        USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
         return ERR_ENOUGH_DATA;
     }
     SetDeviceMessage(data, dev.busNum, dev.devAddr);
@@ -998,7 +967,7 @@ int32_t UsbServerProxy::BulkWrite(const UsbDev &dev, const UsbPipe &pipe, sptr<A
     MessageParcel reply;
     int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_BULK_AYSNC_WRITE), data, reply, option);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s SendRequest failed!", __func__);
+        USB_HILOGE(MODULE_INNERKIT, "SendRequest failed!");
         return ret;
     }
     return ret;
@@ -1010,7 +979,7 @@ int32_t UsbServerProxy::BulkCancel(const UsbDev &dev, const UsbPipe &pipe)
     RETURN_IF_WITH_RET(remote == nullptr, UEC_SERVICE_INNER_ERR);
     MessageParcel data;
     if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
+        USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
         return ERR_ENOUGH_DATA;
     }
     SetDeviceMessage(data, dev.busNum, dev.devAddr);
@@ -1020,7 +989,7 @@ int32_t UsbServerProxy::BulkCancel(const UsbDev &dev, const UsbPipe &pipe)
     MessageParcel reply;
     int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_BULK_AYSNC_CANCEL), data, reply, option);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s SendRequest failed!", __func__);
+        USB_HILOGE(MODULE_INNERKIT, "SendRequest failed!");
         return ret;
     }
     return ret;
diff --git a/services/zidl/src/usb_srv_stub.cpp b/services/zidl/src/usb_srv_stub.cpp
index 01fcd1e..ec5aa1a 100644
--- a/services/zidl/src/usb_srv_stub.cpp
+++ b/services/zidl/src/usb_srv_stub.cpp
@@ -13,9 +13,6 @@
  * limitations under the License.
  */
 
-#include <map>
-#include <sstream>
-#include <vector>
 #include "message_parcel.h"
 #include "securec.h"
 #include "usb_common.h"
@@ -45,11 +42,11 @@ int32_t UsbServerStub::SetBufferMessage(MessageParcel &data, const std::vector<u
     }
 
     if (!data.WriteUint32(length)) {
-        USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d failed length:%{public}u", __func__, __LINE__, length);
+        USB_HILOGE(MODULE_USBD, "write length failed length:%{public}u", length);
         return UEC_SERVICE_WRITE_PARCEL_ERROR;
     }
     if ((ptr) && (length > 0) && !data.WriteBuffer((const void *)ptr, length)) {
-        USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d failed length:%{public}u", __func__, __LINE__, length);
+        USB_HILOGE(MODULE_USBD, "writer buffer failed length:%{public}u", length);
         return UEC_SERVICE_WRITE_PARCEL_ERROR;
     }
     return UEC_OK;
@@ -60,17 +57,17 @@ int32_t UsbServerStub::GetBufferMessage(MessageParcel &data, std::vector<uint8_t
     uint32_t dataSize = 0;
     bufferData.clear();
     if (!data.ReadUint32(dataSize)) {
-        USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d failed", __func__, __LINE__);
+        USB_HILOGE(MODULE_USBD, "read dataSize failed");
         return UEC_SERVICE_READ_PARCEL_ERROR;
     }
     if (dataSize == 0) {
-        USB_HILOGW(MODULE_USBD, "%{public}s:%{public}d size:%{public}u", __func__, __LINE__, dataSize);
+        USB_HILOGW(MODULE_USBD, "size:%{public}u", dataSize);
         return UEC_OK;
     }
 
     const uint8_t *readData = data.ReadUnpadBuffer(dataSize);
     if (readData == nullptr) {
-        USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d failed size:%{public}u", __func__, __LINE__, dataSize);
+        USB_HILOGE(MODULE_USBD, "failed size:%{public}u", dataSize);
         return UEC_SERVICE_READ_PARCEL_ERROR;
     }
     std::vector<uint8_t> tdata(readData, readData + dataSize);
@@ -378,12 +375,12 @@ int32_t UsbServerStub::DoBulkTransferRead(MessageParcel &data, MessageParcel &re
     const UsbPipe tmpPipe = {interface, endpoint};
     int32_t ret = BulkTransferRead(tmpDev, tmpPipe, bufferData, timeOut);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d ret:%{public}d", __func__, __LINE__, ret);
+        USB_HILOGE(MODULE_USBD, "read failed ret:%{public}d", ret);
         return ret;
     }
     ret = SetBufferMessage(reply, bufferData);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d ret:%{public}d", __func__, __LINE__, ret);
+        USB_HILOGE(MODULE_USBD, "set buffer failed ret:%{public}d", ret);
     }
     return ret;
 }
@@ -405,13 +402,12 @@ int32_t UsbServerStub::DoBulkTransferWrite(MessageParcel &data, MessageParcel &r
     const UsbPipe tmpPipe = {interface, endpoint};
     int32_t ret = GetBufferMessage(data, bufferData);
     if (UEC_OK != ret) {
-        USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d ret:%{public}d", __func__, __LINE__, ret);
+        USB_HILOGE(MODULE_USBD, "GetBufferMessage failedret:%{public}d", ret);
         return ret;
     }
     ret = BulkTransferWrite(tmpDev, tmpPipe, bufferData, timeOut);
     if (UEC_OK != ret) {
-        USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d BulkTransferWrite error ret:%{public}d", __func__, __LINE__,
-                   ret);
+        USB_HILOGE(MODULE_USBD, "BulkTransferWrite error ret:%{public}d", ret);
     }
     return ret;
 }
@@ -436,7 +432,7 @@ int32_t UsbServerStub::DoControlTransfer(MessageParcel &data, MessageParcel &rep
     std::vector<uint8_t> bufferData;
     int32_t ret = GetBufferMessage(data, bufferData);
     if (UEC_OK != ret) {
-        USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d get error ret:%{public}d", __func__, __LINE__, ret);
+        USB_HILOGE(MODULE_USBD, "get error ret:%{public}d", ret);
         return ret;
     }
 
@@ -445,15 +441,14 @@ int32_t UsbServerStub::DoControlTransfer(MessageParcel &data, MessageParcel &rep
     const UsbCtrlTransfer tctrl = {requestType, request, value, index, timeOut};
     ret = ControlTransfer(tmpDev, tctrl, bufferData);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d ControlTransfer error ret:%{public}d", __func__, __LINE__, ret);
+        USB_HILOGE(MODULE_USBD, "ControlTransfer error ret:%{public}d", ret);
         return ret;
     }
 
     if (!bWrite) {
         ret = SetBufferMessage(reply, bufferData);
         if (UEC_OK != ret) {
-            USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d Set buffer message error length = %{public}d", __func__,
-                       __LINE__, ret);
+            USB_HILOGE(MODULE_USBD, "Set buffer message error length = %{public}d", ret);
         }
     }
 
@@ -509,10 +504,10 @@ int32_t UsbServerStub::DoGetRawDescriptor(MessageParcel &data, MessageParcel &re
     if (UEC_OK == ret) {
         ret = SetBufferMessage(reply, bufferData);
         if (UEC_OK != ret) {
-            USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d ret:%{public}d", __func__, __LINE__, ret);
+            USB_HILOGE(MODULE_USBD, "SetBufferMessage failed ret:%{public}d", ret);
         }
     } else {
-        USB_HILOGW(MODULE_USBD, "%{public}s:%{public}d ret:%{public}d", __func__, __LINE__, ret);
+        USB_HILOGW(MODULE_USBD, "GetRawDescriptor failed ret:%{public}d", ret);
     }
     return ret;
 }
@@ -528,7 +523,7 @@ int32_t UsbServerStub::DoGetFileDescriptor(MessageParcel &data, MessageParcel &r
     if (UEC_OK == ret) {
         WRITE_PARCEL_WITH_RET(reply, Int32, fd, UEC_SERVICE_WRITE_PARCEL_ERROR);
     } else {
-        USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d ret:%{public}d", __func__, __LINE__, ret);
+        USB_HILOGE(MODULE_USBD, "ret:%{public}d", ret);
     }
     return ret;
 }
@@ -548,19 +543,19 @@ int32_t UsbServerStub::DoRequestQueue(MessageParcel &data, MessageParcel &reply,
 
     int32_t ret = UsbServerStub::GetBufferMessage(data, clientData);
     if (UEC_OK != ret) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s:%{public}d failed  ret:%{public}d", __func__, __LINE__, ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "GetBufferMessage failed  ret:%{public}d", ret);
         return ret;
     }
     ret = UsbServerStub::GetBufferMessage(data, bufferData);
     if (UEC_OK != ret) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s:%{public}d failed  ret:%{public}d", __func__, __LINE__, ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "GetBufferMessage failed  ret:%{public}d", ret);
         return ret;
     }
     const UsbDev tmpDev = {busNum, devAddr};
     const UsbPipe tmpPipe = {ifId, endpoint};
     ret = RequestQueue(tmpDev, tmpPipe, clientData, bufferData);
     if (UEC_OK != ret) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s:%{public}d failed  ret:%{public}d", __func__, __LINE__, ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "GetBufferMessage failed ret:%{public}d", ret);
     }
     return ret;
 }
@@ -579,19 +574,19 @@ int32_t UsbServerStub::DoRequestWait(MessageParcel &data, MessageParcel &reply,
     const UsbDev tmpDev = {busNum, devAddr};
     int32_t ret = RequestWait(tmpDev, timeOut, clientData, bufferData);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s:%{public}d failed ret:%{public}d", __func__, __LINE__, ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "RequestWait failed ret:%{public}d", ret);
         return ret;
     }
 
     ret = SetBufferMessage(reply, clientData);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s:%{public}d failed ret:%{public}d", __func__, __LINE__, ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "Set clientData failed ret:%{public}d", ret);
         return ret;
     }
 
     ret = SetBufferMessage(reply, bufferData);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s:%{public}d failed ret:%{public}d", __func__, __LINE__, ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "Set bufferData failed ret:%{public}d", ret);
         return ret;
     }
     return ret;
@@ -609,7 +604,7 @@ int32_t UsbServerStub::DoRequestCancel(MessageParcel &data, MessageParcel &reply
     READ_PARCEL_WITH_RET(data, Uint8, endpointId, UEC_SERVICE_WRITE_PARCEL_ERROR);
     int32_t ret = RequestCancel(busNum, devAddr, interfaceId, endpointId);
     if (UEC_OK != ret) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s:%{public}d failed ret:%{public}d", __func__, __LINE__, ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "failed ret:%{public}d", ret);
     }
     return ret;
 }
@@ -622,7 +617,7 @@ int32_t UsbServerStub::DoClose(MessageParcel &data, MessageParcel &reply, Messag
     READ_PARCEL_WITH_RET(data, Uint8, devAddr, UEC_SERVICE_WRITE_PARCEL_ERROR);
     int32_t ret = Close(busNum, devAddr);
     if (UEC_OK != ret) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s:%{public}d failed ret:%{public}d", __func__, __LINE__, ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "failed ret:%{public}d", ret);
     }
     return ret;
 }
@@ -632,13 +627,13 @@ int32_t UsbServerStub::DoGetDevices(MessageParcel &data, MessageParcel &reply, M
     std::vector<UsbDevice> deviceList;
     int32_t ret = GetDevices(deviceList);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_SERVICE, "%{public}s: failed ret = %{public}d", __func__, ret);
+        USB_HILOGE(MODULE_SERVICE, "GetDevices failed ret = %{public}d", ret);
         return ret;
     }
-    USB_HILOGE(MODULE_SERVICE, "%{public}s: list size = %{public}zu", __func__, deviceList.size());
+    USB_HILOGI(MODULE_SERVICE, "list size = %{public}zu", deviceList.size());
     ret = SetDeviceListMessageParcel(deviceList, reply);
     if (UEC_OK != ret) {
-        USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s:%{public}d failed ret:%{public}d", __func__, __LINE__, ret);
+        USB_HILOGE(MODULE_USB_INNERKIT, "SetDeviceListMessageParcel failed ret:%{public}d", ret);
     }
     return ret;
 }
@@ -678,10 +673,8 @@ int32_t UsbServerStub::SetDeviceMessageParcel(UsbDevice &devInfo, MessageParcel
     WRITE_PARCEL_WITH_RET(data, String, devInfo.GetProductName(), UEC_SERVICE_WRITE_PARCEL_ERROR);
     WRITE_PARCEL_WITH_RET(data, String, devInfo.GetVersion(), UEC_SERVICE_WRITE_PARCEL_ERROR);
     WRITE_PARCEL_WITH_RET(data, String, devInfo.GetmSerial(), UEC_SERVICE_WRITE_PARCEL_ERROR);
-    USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s:%{public}d devName:%{public}s Bus:%{public}d dev:%{public}d ", __func__,
-               __LINE__, devInfo.GetName().c_str(), devInfo.GetBusNum(), devInfo.GetDevAddr());
-    USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s:%{public}d devInfo:%{public}s", __func__, __LINE__,
-               devInfo.ToString().c_str());
+
+    USB_HILOGE(MODULE_USB_INNERKIT, "devInfo:%{public}s", devInfo.ToString().c_str());
     WRITE_PARCEL_WITH_RET(data, Int32, devInfo.GetConfigCount(), UEC_SERVICE_WRITE_PARCEL_ERROR);
     return SetDeviceConfigsMessageParcel(devInfo.GetConfigs(), data);
 }
@@ -698,7 +691,7 @@ int32_t UsbServerStub::SetDeviceConfigsMessageParcel(std::vector<USBConfig> &con
         WRITE_PARCEL_WITH_RET(data, String, config.GetName(), UEC_SERVICE_WRITE_PARCEL_ERROR);
 
         WRITE_PARCEL_WITH_RET(data, Uint32, config.GetInterfaceCount(), UEC_SERVICE_WRITE_PARCEL_ERROR);
-        USB_HILOGI(MODULE_USB_SERVICE, "%{public}s devInfo=%{public}s", __func__, config.ToString().c_str());
+        USB_HILOGI(MODULE_USB_SERVICE, "devInfo=%{public}s", config.ToString().c_str());
         int32_t ret = SetDeviceInterfacesMessageParcel(config.GetInterfaces(), data);
         if (ret) {
             return ret;
@@ -721,7 +714,7 @@ int32_t UsbServerStub::SetDeviceInterfacesMessageParcel(std::vector<UsbInterface
         WRITE_PARCEL_WITH_RET(data, String, interface.GetName(), UEC_SERVICE_WRITE_PARCEL_ERROR);
 
         WRITE_PARCEL_WITH_RET(data, Int32, interface.GetEndpointCount(), UEC_SERVICE_WRITE_PARCEL_ERROR);
-        USB_HILOGI(MODULE_USB_SERVICE, "%{public}s devInfo=%{public}s", __func__, interface.ToString().c_str());
+        USB_HILOGI(MODULE_USB_SERVICE, "interface=%{public}s", interface.ToString().c_str());
         int32_t ret = SetDeviceEndpointsMessageParcel(interface.GetEndpoints(), data);
         if (ret) {
             return ret;
@@ -738,7 +731,7 @@ int32_t UsbServerStub::SetDeviceEndpointsMessageParcel(std::vector<USBEndpoint>
         WRITE_PARCEL_WITH_RET(data, Int32, ep.GetAttributes(), UEC_SERVICE_WRITE_PARCEL_ERROR);
         WRITE_PARCEL_WITH_RET(data, Int32, ep.GetInterval(), UEC_SERVICE_WRITE_PARCEL_ERROR);
         WRITE_PARCEL_WITH_RET(data, Int32, ep.GetMaxPacketSize(), UEC_SERVICE_WRITE_PARCEL_ERROR);
-        USB_HILOGI(MODULE_USB_SERVICE, "%{public}s devInfo=%{public}s", __func__, ep.ToString().c_str());
+        USB_HILOGI(MODULE_USB_SERVICE, "ep=%{public}s", ep.ToString().c_str());
     }
     return UEC_OK;
 }
@@ -758,7 +751,7 @@ int32_t UsbServerStub::DoRegBulkCallback(MessageParcel &data, MessageParcel &rep
     const UsbPipe tmpPipe = {interface, endpoint};
     int32_t ret = RegBulkCallback(tmpDev, tmpPipe, cb);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d ret:%{public}d", __func__, __LINE__, ret);
+        USB_HILOGE(MODULE_USBD, "ret:%{public}d", ret);
         return ret;
     }
     return ret;
@@ -778,7 +771,7 @@ int32_t UsbServerStub::DoUnRegBulkCallback(MessageParcel &data, MessageParcel &r
     const UsbPipe tmpPipe = {interface, endpoint};
     int32_t ret = UnRegBulkCallback(tmpDev, tmpPipe);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d ret:%{public}d", __func__, __LINE__, ret);
+        USB_HILOGE(MODULE_USBD, "ret:%{public}d", ret);
         return ret;
     }
     return ret;
@@ -799,7 +792,7 @@ int32_t UsbServerStub::DoBulkRead(MessageParcel &data, MessageParcel &reply, Mes
     const UsbPipe tmpPipe = {interface, endpoint};
     int32_t ret = BulkRead(tmpDev, tmpPipe, ashmem);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d ret:%{public}d", __func__, __LINE__, ret);
+        USB_HILOGE(MODULE_USBD, "BulkRead failed ret:%{public}d", ret);
         return ret;
     }
     return ret;
@@ -820,7 +813,7 @@ int32_t UsbServerStub::DoBulkWrite(MessageParcel &data, MessageParcel &reply, Me
     const UsbPipe tmpPipe = {interface, endpoint};
     int32_t ret = BulkWrite(tmpDev, tmpPipe, ashmem);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d ret:%{public}d", __func__, __LINE__, ret);
+        USB_HILOGE(MODULE_USBD, "ret:%{public}d", ret);
         return ret;
     }
     return ret;
@@ -840,7 +833,7 @@ int32_t UsbServerStub::DoBulkCancel(MessageParcel &data, MessageParcel &reply, M
     const UsbPipe tmpPipe = {interface, endpoint};
     int32_t ret = BulkCancel(tmpDev, tmpPipe);
     if (ret != UEC_OK) {
-        USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d ret:%{public}d", __func__, __LINE__, ret);
+        USB_HILOGE(MODULE_USBD, "ret:%{public}d", ret);
         return ret;
     }
     return ret;
diff --git a/utils/native/include/delayed_sp_singleton.h b/utils/native/include/delayed_sp_singleton.h
index a533aef..f368d5c 100644
--- a/utils/native/include/delayed_sp_singleton.h
+++ b/utils/native/include/delayed_sp_singleton.h
@@ -56,7 +56,7 @@ template <typename T> sptr<T> DelayedSpSingleton<T>::GetInstance()
     if (instance_ == nullptr) {
         instance_ = new(std::nothrow) T();
         if (instance_ == nullptr) {
-            USB_HILOGI(MODULE_USB_SERVICE, " %{public}s:%{public}d get instance failed\n", __func__, __LINE__);
+            USB_HILOGI(MODULE_USB_SERVICE, "get instance failed\n");
         }
     }