FCL/sf/os/usb: comparison usbmgmt/usbmgr/usbman/client/SRC/RUsb.cpp

equal deleted inserted replaced

-:4bea936937d0
+:1a2a19ee918d
 #include <e32uid.h>
 #include <usbman.h>
 #include <usb.h>
 #include <e32base.h>
-#include "rusb.h"
-#include <usb/usblogger.h>
-#ifdef __FLOG_ACTIVE
-_LIT8(KLogComponent, "USBMAN");
-#endif
 #ifdef __USBMAN_NO_PROCESSES__
 #include <e32math.h>
+#endif
+#include <usb/usblogger.h>
+#include "rusb.h"
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "RUsbTraces.h"
 #endif
 static TInt StartServer()
 //
 	// from KErrNone
 	err = (server.ExitType() == EExitPanic) ? KErrServerTerminated : stat.Int();
 	server.Close();
-	LOGTEXT2(_L8("USB server started successfully: err = %d\n"),err);
+	OstTrace1( TRACE_NORMAL, RUSB_STARTSERVER, "::StartServer;USB server started successfully: err=%d", err );
 	return err;
 	}
 EXPORT_C RUsb::RUsb()
 	: iDeviceStatePkg(0), iServiceStatePkg(0), iMessagePkg(0),
 	  iHostPkg(TDeviceEventInformation())
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_RUSB_CONS_ENTRY );
-	LOG_FUNC
+	OstTraceFunctionExit0( RUSB_RUSB_CONS_EXIT );
 	}
 EXPORT_C RUsb::~RUsb()
 	{
-	LOG_LINE
+OstTraceFunctionEntry0( RUSB_RUSB_DES_ENTRY );
-	LOG_FUNC
+	OstTraceFunctionExit0( RUSB_RUSB_DES_EXIT );
 	}
 EXPORT_C TVersion RUsb::Version() const
 	{
 	return(TVersion(KUsbSrvMajorVersionNumber,KUsbSrvMinorVersionNumber,KUsbSrvBuildVersionNumber));
 	}
 EXPORT_C TInt RUsb::Connect()
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_CONNECT_ENTRY );
-	LOG_FUNC
 	TInt retry = 2;
 	FOREVER
 		{
 		// Create the session to UsbSrv with 10 asynchronous message slots
 		TInt err = CreateSession(KUsbServerName, Version(), 10);
 		if ((err != KErrNotFound) && (err != KErrServerTerminated))
 			{
+			OstTraceFunctionExit0( RUSB_CONNECT_EXIT );
 			return err;
 			}
 		if (--retry == 0)
 			{
+			OstTraceFunctionExit0( RUSB_CONNECT_EXIT_DUP1 );
 			return err;
 			}
 		err = StartServer();
 		if ((err != KErrNone) && (err != KErrAlreadyExists))
 			{
+			OstTraceFunctionExit0( RUSB_CONNECT_EXIT_DUP2 );
 			return err;
 			}
 		}
 	}
 EXPORT_C void RUsb::Start(TRequestStatus& aStatus)
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_START_ENTRY );
-	LOG_FUNC
 	SendReceive(EUsbStart, aStatus);
+	OstTraceFunctionExit0( RUSB_START_EXIT );
 	}
 EXPORT_C void RUsb::StartCancel()
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_STARTCANCEL_ENTRY );
-	LOG_FUNC
 	SendReceive(EUsbStartCancel);
+	OstTraceFunctionExit0( RUSB_STARTCANCEL_EXIT );
 	}
 EXPORT_C void RUsb::Stop()
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_STOP_ENTRY );
-	LOG_FUNC
 	SendReceive(EUsbStop);
+	OstTraceFunctionExit0( RUSB_STOP_EXIT );
 	}
 EXPORT_C void RUsb::Stop(TRequestStatus& aStatus)
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_STOP_TREQUESTSTATUS_ENTRY );
-	LOG_FUNC
 	SendReceive(EUsbStop, aStatus);
+	OstTraceFunctionExit0( RUSB_STOP_TREQUESTSTATUS_EXIT );
 	}
 EXPORT_C void RUsb::StopCancel()
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_STOPCANCEL_ENTRY );
-	LOG_FUNC
 	SendReceive(EUsbStopCancel);
+	OstTraceFunctionExit0( RUSB_STOPCANCEL_EXIT );
 	}
 EXPORT_C TInt RUsb::GetServiceState(TUsbServiceState& aState)
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_GETSERVICESTATE_ENTRY );
-	LOG_FUNC
 	TPckg<TUint32> pkg(aState);
 	TInt ret=SendReceive(EUsbGetCurrentState, TIpcArgs(&pkg));
 	aState=(TUsbServiceState)pkg();
+	OstTraceFunctionExit0( RUSB_GETSERVICESTATE_EXIT );
 	return ret;
 	}
 EXPORT_C TInt RUsb::GetCurrentState(TUsbServiceState& aState)
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_GETCURRENTSTATE_ENTRY );
-	LOG_FUNC
 	return GetServiceState(aState);
 	}
 EXPORT_C void RUsb::ServiceStateNotification(TUsbServiceState& aState,
 	TRequestStatus& aStatus)
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_SERVICESTATENOTIFICATION_ENTRY );
-	LOG_FUNC
 	iServiceStatePkg.Set((TUint8*)&aState, sizeof(TUint32), sizeof(TUint32));
 	SendReceive(EUsbRegisterServiceObserver, TIpcArgs(&iServiceStatePkg), aStatus);
+	OstTraceFunctionExit0( RUSB_SERVICESTATENOTIFICATION_EXIT );
 	}
 EXPORT_C void RUsb::ServiceStateNotificationCancel()
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_SERVICESTATENOTIFICATIONCANCEL_ENTRY );
-	LOG_FUNC
 	SendReceive(EUsbCancelServiceObserver);
+	OstTraceFunctionExit0( RUSB_SERVICESTATENOTIFICATIONCANCEL_EXIT );
 	}
 EXPORT_C TInt RUsb::GetDeviceState(TUsbDeviceState& aState)
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_GETDEVICESTATE_ENTRY );
-	LOG_FUNC
 	TPckg<TUint32> pkg(aState);
 	TInt ret=SendReceive(EUsbGetCurrentDeviceState, TIpcArgs(&pkg));
 	aState=(TUsbDeviceState)pkg();
+	OstTraceFunctionExit0( RUSB_GETDEVICESTATE_EXIT );
 	return ret;
 	}
 EXPORT_C void RUsb::DeviceStateNotification(TUint aEventMask, TUsbDeviceState& aState,
 											TRequestStatus& aStatus)
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_DEVICESTATENOTIFICATION_ENTRY );
-	LOG_FUNC
 	iDeviceStatePkg.Set((TUint8*)&aState, sizeof(TUint32), sizeof(TUint32));
 	SendReceive(EUsbRegisterObserver, TIpcArgs(aEventMask, &iDeviceStatePkg), aStatus);
+	OstTraceFunctionExit0( RUSB_DEVICESTATENOTIFICATION_EXIT );
 	}
 EXPORT_C void RUsb::DeviceStateNotificationCancel()
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_DEVICESTATENOTIFICATIONCANCEL_ENTRY );
-	LOG_FUNC
 	SendReceive(EUsbCancelObserver);
+	OstTraceFunctionExit0( RUSB_DEVICESTATENOTIFICATIONCANCEL_EXIT );
 	}
 EXPORT_C void RUsb::StateNotification(TUint aEventMask, TUsbDeviceState& aState, TRequestStatus& aStatus)
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_STATENOTIFICATION_ENTRY );
-	LOG_FUNC
 	DeviceStateNotification(aEventMask, aState, aStatus);
+	OstTraceFunctionExit0( RUSB_STATENOTIFICATION_EXIT );
 	}
 EXPORT_C void RUsb::StateNotificationCancel()
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_STATENOTIFICATIONCANCEL_ENTRY );
-	LOG_FUNC
 	DeviceStateNotificationCancel();
+	OstTraceFunctionExit0( RUSB_STATENOTIFICATIONCANCEL_EXIT );
 	}
 EXPORT_C void RUsb::TryStart(TInt aPersonalityId, TRequestStatus& aStatus)
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_TRYSTART_ENTRY );
-	LOG_FUNC
 	TIpcArgs ipcArgs(aPersonalityId);
 	SendReceive(EUsbTryStart, ipcArgs, aStatus);
+	OstTraceFunctionExit0( RUSB_TRYSTART_EXIT );
 	}
 EXPORT_C void RUsb::TryStop(TRequestStatus& aStatus)
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_TRYSTOP_ENTRY );
-	LOG_FUNC
 	SendReceive(EUsbTryStop, aStatus);
+	OstTraceFunctionExit0( RUSB_TRYSTOP_EXIT );
 	}
 EXPORT_C TInt RUsb::CancelInterest(TUsbReqType aMessageId)
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_CANCELINTEREST_ENTRY );
-	LOG_FUNC
 	TInt messageId;
 	switch (aMessageId)
 		{
 	case EStart:
 	return SendReceive(EUsbCancelInterest, ipcArgs);
 	}
 EXPORT_C TInt RUsb::GetDescription(TInt aPersonalityId, HBufC*& aLocalizedPersonalityDescriptor)
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_GETDESCRIPTION_ENTRY );
-	LOG_FUNC
 	TInt ret = KErrNone;
 	// caller is responsible for freeing up memory allocatd for aLocalizedPersonalityDescriptor
 	TRAP(ret, aLocalizedPersonalityDescriptor = HBufC::NewL(KUsbStringDescStringMaxSize));
 	if (ret == KErrNone)
 		{
 		{
 		// just in case caller tries to free the memory before checking the return code
 		aLocalizedPersonalityDescriptor = NULL;
 		}
+	OstTraceFunctionExit0( RUSB_GETDESCRIPTION_EXIT );
 	return ret;
 	}
 EXPORT_C TInt RUsb::GetCurrentPersonalityId(TInt& aPersonalityId)
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_GETCURRENTPERSONALITYID_ENTRY );
-	LOG_FUNC
 	TPckg<TInt> pkg0(aPersonalityId);
 	TInt ret = SendReceive(EUsbGetCurrentPersonalityId, TIpcArgs(&pkg0));
 	aPersonalityId = static_cast<TInt>(pkg0());
+	OstTraceFunctionExit0( RUSB_GETCURRENTPERSONALITYID_EXIT );
 	return ret;
 	}
 EXPORT_C TInt RUsb::GetSupportedClasses(TInt aPersonalityId, RArray<TUid>& aClassUids)
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_GETSUPPORTEDCLASSES_ENTRY );
-	LOG_FUNC
 	TInt ret = KErrNone;
 	HBufC8* buf = NULL;
 	// +1 for the actual count of personality ids
 	TRAP(ret, buf = HBufC8::NewL((KUsbMaxSupportedClasses + 1)*sizeof (TInt32)));
 	if (ret != KErrNone)
 		{
+		OstTraceFunctionExit0( RUSB_GETSUPPORTEDCLASSES_EXIT );
 		return ret;
 		}
 	TPtr8 ptr8 = buf->Des();
 	ret = SendReceive(EUsbGetSupportedClasses, TIpcArgs(aPersonalityId, &ptr8));
 		{
 		const TInt32* recvedIds = reinterpret_cast<const TInt32*>(buf->Ptr());
 		if (!recvedIds)
 			{
 			delete buf;
+			OstTraceFunctionExit0( RUSB_GETSUPPORTEDCLASSES_EXIT_DUP1 );
 			return KErrCorrupt;
 			}
 		TInt arraySize = *recvedIds++;
 		// Copy received supported class ids to aClassUids
 				}
 			}
 		}
 	delete buf;
+	OstTraceFunctionExit0( RUSB_GETSUPPORTEDCLASSES_EXIT_DUP2 );
 	return ret;
 	}
 EXPORT_C TInt RUsb::ClassSupported(TInt aPersonalityId, TUid aClassUid, TBool& aSupported)
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_CLASSSUPPORTED_ENTRY );
-	LOG_FUNC
 	TPckg<TInt32>  	pkg2(aSupported);
 	TIpcArgs ipcArgs(aPersonalityId, aClassUid.iUid, &pkg2);
 	TInt ret = SendReceive(EUsbClassSupported, ipcArgs);
 	if (ret == KErrNone)
 		{
 		aSupported = static_cast<TBool>(pkg2());
 		}
+	OstTraceFunctionExit0( RUSB_CLASSSUPPORTED_EXIT );
 	return ret;
 	}
 EXPORT_C TInt RUsb::GetPersonalityIds(RArray<TInt>& aPersonalityIds)
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_GETPERSONALITYIDS_ENTRY );
-	LOG_FUNC
 	TInt ret = KErrNone;
 	HBufC8* buf = NULL;
 	// +1 for the actual count of personality ids
 	TRAP(ret, buf = HBufC8::NewL((KUsbMaxSupportedPersonalities + 1)*sizeof (TInt)));
 	if (ret != KErrNone)
 		{
+		OstTraceFunctionExit0( RUSB_GETPERSONALITYIDS_EXIT );
 		return ret;
 		}
 	TPtr8 ptr8 = buf->Des();
 	ret = SendReceive(EUsbGetPersonalityIds, TIpcArgs(&ptr8));
 		{
 		const TInt* recvedIds = reinterpret_cast<const TInt*>(buf->Ptr());
 		if (!recvedIds)
 			{
 			delete buf;
+			OstTraceFunctionExit0( RUSB_GETPERSONALITYIDS_EXIT_DUP1 );
 			return KErrCorrupt;
 			}
 		TInt arraySize = *recvedIds++;
 		// Copy received personality ids to aPersonalityIds
 				}
 			}
 		}
 	delete buf;
+	OstTraceFunctionExit0( RUSB_GETPERSONALITYIDS_EXIT_DUP2 );
 	return ret;
 	}
 EXPORT_C TInt RUsb::__DbgMarkHeap()
 	{
 return KErrNone;
 #endif
 	}
 EXPORT_C void panic()
-	{
+{
-	_USB_PANIC(KUsbCliPncCat, EUsbPanicRemovedExport);
+OstTrace1( TRACE_FATAL, RUSB_PANIC, "::panic;Panic reason=%d", EUsbPanicRemovedExport );
+User::Panic(KUsbCliPncCat, EUsbPanicRemovedExport);
 	}
 EXPORT_C TInt RUsb::SetCtlSessionMode(TBool aValue)
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_SETCTLSESSIONMODE_ENTRY );
-	LOG_FUNC
 	TPckg<TBool> pkg(aValue);
 	return SendReceive(EUsbSetCtlSessionMode, TIpcArgs(&pkg));
 	}
 EXPORT_C TInt RUsb::BusRequest()
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_BUSREQUEST_ENTRY );
-	LOG_FUNC
 	return SendReceive(EUsbBusRequest);
 	}
 EXPORT_C TInt RUsb::BusRespondSrp()
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_BUSRESPONDSRP_ENTRY );
-	LOG_FUNC
 	return SendReceive(EUsbBusRespondSrp);
 	}
 EXPORT_C TInt RUsb::BusClearError()
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_BUSCLEARERROR_ENTRY );
-	LOG_FUNC
 	return SendReceive(EUsbBusClearError);
 	}
 EXPORT_C TInt RUsb::BusDrop()
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_BUSDROP_ENTRY );
-	LOG_FUNC
 	return SendReceive(EUsbBusDrop);
 	}
 EXPORT_C void RUsb::MessageNotification(TRequestStatus& aStatus, TInt& aMessage)
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_MESSAGENOTIFICATION_ENTRY );
-	LOG_FUNC
 	iMessagePkg.Set((TUint8*)&aMessage, sizeof(TInt), sizeof(TInt));
 	SendReceive(EUsbRegisterMessageObserver, TIpcArgs(&iMessagePkg), aStatus);
+	OstTraceFunctionExit0( RUSB_MESSAGENOTIFICATION_EXIT );
 	}
 EXPORT_C void RUsb::MessageNotificationCancel()
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_MESSAGENOTIFICATIONCANCEL_ENTRY );
-	LOG_FUNC
 	SendReceive(EUsbCancelMessageObserver);
+	OstTraceFunctionExit0( RUSB_MESSAGENOTIFICATIONCANCEL_EXIT );
 	}
 EXPORT_C void RUsb::HostEventNotification(TRequestStatus& aStatus,
 										  TDeviceEventInformation& aDeviceInformation)
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_HOSTEVENTNOTIFICATION_ENTRY );
-	LOG_FUNC
 	iHostPkg.Set((TUint8*)&aDeviceInformation, sizeof(TDeviceEventInformation), sizeof(TDeviceEventInformation));
 	SendReceive(EUsbRegisterHostObserver, TIpcArgs(&iHostPkg), aStatus);
+	OstTraceFunctionExit0( RUSB_HOSTEVENTNOTIFICATION_EXIT );
 	}
 EXPORT_C void RUsb::HostEventNotificationCancel()
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_HOSTEVENTNOTIFICATIONCANCEL_ENTRY );
-	LOG_FUNC
 	SendReceive(EUsbCancelHostObserver);
+	OstTraceFunctionExit0( RUSB_HOSTEVENTNOTIFICATIONCANCEL_EXIT );
 	}
 EXPORT_C TInt RUsb::EnableFunctionDriverLoading()
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_ENABLEFUNCTIONDRIVERLOADING_ENTRY );
-	LOG_FUNC
 	return SendReceive(EUsbEnableFunctionDriverLoading);
 	}
 EXPORT_C void RUsb::DisableFunctionDriverLoading()
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_DISABLEFUNCTIONDRIVERLOADING_ENTRY );
-	LOG_FUNC
 	SendReceive(EUsbDisableFunctionDriverLoading);
+	OstTraceFunctionExit0( RUSB_DISABLEFUNCTIONDRIVERLOADING_EXIT );
 	}
 EXPORT_C TInt RUsb::GetSupportedLanguages(TUint aDeviceId, RArray<TUint>& aLangIds)
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_GETSUPPORTEDLANGUAGES_ENTRY );
-	LOG_FUNC
 	aLangIds.Reset();
 	TInt ret = KErrNone;
 	HBufC8* buf = NULL;
 	// +1 for the actual count of language ids
 	TRAP(ret, buf = HBufC8::NewL((KUsbMaxSupportedLanguageIds + 1)*sizeof (TUint)));
 	if (ret != KErrNone)
 		{
+		OstTraceFunctionExit0( RUSB_GETSUPPORTEDLANGUAGES_EXIT );
 		return ret;
 		}
 	TPtr8 ptr8 = buf->Des();
 	ret = SendReceive(EUsbGetSupportedLanguages, TIpcArgs(aDeviceId, &ptr8));
 		{
 		const TUint* recvedIds = reinterpret_cast<const TUint*>(buf->Ptr());
 		if (!recvedIds)
 			{
 			delete buf;
+			OstTraceFunctionExit0( RUSB_GETSUPPORTEDLANGUAGES_EXIT_DUP1 );
 			return KErrCorrupt;
 			}
 		TInt arraySize = *recvedIds++;
 		// Copy received language ids to aLangIds
 				}
 			}
 		}
 	delete buf;
+	OstTraceFunctionExit0( RUSB_GETSUPPORTEDLANGUAGES_EXIT_DUP2 );
 	return ret;
 	}
 EXPORT_C TInt RUsb::GetManufacturerStringDescriptor(TUint aDeviceId, TUint aLangId, TName& aString)
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_GETMANUFACTURERSTRINGDESCRIPTOR_ENTRY );
-	LOG_FUNC
 	return SendReceive(EUsbGetManufacturerStringDescriptor, TIpcArgs(aDeviceId, aLangId, &aString));
 	}
 EXPORT_C TInt RUsb::GetProductStringDescriptor(TUint aDeviceId, TUint aLangId, TName& aString)
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_GETPRODUCTSTRINGDESCRIPTOR_ENTRY );
-	LOG_FUNC
 	return SendReceive(EUsbGetProductStringDescriptor, TIpcArgs(aDeviceId, aLangId, &aString));
 	}
 EXPORT_C TInt RUsb::GetOtgDescriptor(TUint aDeviceId, TOtgDescriptor& aDescriptor)
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_GETOTGDESCRIPTOR_ENTRY );
-	LOG_FUNC
 	TPckg<TOtgDescriptor> otgDescPkg(aDescriptor);
 	TIpcArgs args;
 	args.Set(0, aDeviceId);
 	args.Set(1, &otgDescPkg);
 	}
 EXPORT_C TInt RUsb::RequestSession()
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_REQUESTSESSION_ENTRY );
-	LOG_FUNC
 	return SendReceive(EUsbRequestSession);
 	}
 EXPORT_C TInt RUsb::GetDetailedDescription(TInt /*aPersonalityId*/, HBufC*& /*aLocalizedPersonalityDescriptor*/)
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_GETDETAILEDDESCRIPTION_ENTRY );
-	LOG_FUNC
 	//This API has been deprecated
+	OstTraceFunctionExit0( RUSB_GETDETAILEDDESCRIPTION_EXIT );
 	return KErrNotSupported;
 	}
 EXPORT_C TInt RUsb::GetPersonalityProperty(TInt aPersonalityId, TUint32& aProperty)
 	{
-	LOG_LINE
+	OstTraceFunctionEntry0( RUSB_GETPERSONALITYPROPERTY_ENTRY );
-	LOG_FUNC
 	TPckg<TUint32> pkg(aProperty);
 	TInt ret = SendReceive(EUsbGetPersonalityProperty, TIpcArgs(aPersonalityId, &pkg));
 	if (ret == KErrNone)
 		{
 		aProperty = static_cast<TUint32>(pkg());
 		}
+	OstTraceFunctionExit0( RUSB_GETPERSONALITYPROPERTY_EXIT );
 	return ret;
 	}

changeset 36	1a2a19ee918d
parent 31	4bea936937d0