コード例 #1
0
/**
Constructs DCommsbuf based upon underlying shared buffer.
Should be constructed in kernel private memory not in place in the buffer.
Offset defaults to zero and length to the maximum length
@param aShBuf Underlying shared buffer
@param aCommsPoolHandle Opaque user side handle (as discovered through driver interface)
*/
DCommsBuf::DCommsBuf(TShBuf* aShBuf, TInt aCommsPoolHandle, TInt aBufSize)
	{
	__ASSERT_COMPILE(sizeof(TCommsBuf) == TCommsBuf::KCommsBufMetadataSize);
	__ASSERT_COMPILE(sizeof(DCommsBuf) == sizeof(TCommsBuf));

	__ASSERT_DEBUG(aCommsPoolHandle, KernCommsBuf::Fault(ECommsBufMetadataCorrupt));

	iFrontCanary = KCanaryDefault;
	TUint8* shBufPtr = Kern::ShBufPtr(aShBuf);
	iShBuf = aShBuf;
	iCommsBufPtr = shBufPtr + aBufSize;
	
	iRawDataOffset = -aBufSize;
	iOffset = iRawDataOffset;
	iRawSize = aBufSize;
	iLength = aBufSize;
	iNext = NULL;
	iPool = aCommsPoolHandle;
	iHandle = 0;
	
	iReservedWords[0] = 0;
	iReservedWords[1] = 0;
	iReservedWords[2] = 0;
	iReservedWords[3] = 0;
	iReservedWords[4] = 0;
	iBackCanary = KCanaryDefault;
	}
コード例 #2
0
ファイル: ub_svr.cpp プロジェクト: kuailexs/symbiandump-os1
/**
Constructs the server object, specifying the server type and the active
object priority.

Derived classes must define and implement a constructor through which
the priority can be specified. A typical implementation calls this server
base class constructor through a constructor initialization list.

@param aPriority The priority of this active object.
@param aType     Indicates the type of session that the server creates.
                 If not explicitly stated, then the server creates
                 a session that is not sharable with other threads.
*/
EXPORT_C CServer2::CServer2(TInt aPriority, TServerType aType)
	:	CActive(aPriority),
		iSessionType((TUint8)aType),
		iSessionQ(_FOFF(CSession2,iLink)),
		iSessionIter(iSessionQ)
	{
	ASSERT(iSessionType == aType);
	__ASSERT_COMPILE(EServerRole_Default == 0);
	__ASSERT_COMPILE(EServerOpt_PinClientDescriptorsDefault == 0);
	}
コード例 #3
0
/** Initialise this interface.

This must be called before any call to OpenL(), to ensure that the 
RProperties it uses are correctly initialised.
*/
EXPORT_C void RLbsNetworkPositionUpdates::InitializeL()
	{
	// There is an assumption that TPositionSatelliteInfo is the biggest
	// class to be sent over this interface, so double-check
	__ASSERT_COMPILE(sizeof(TPositionSatelliteInfo) >= sizeof(TPositionInfo));
	__ASSERT_COMPILE(sizeof(TPositionSatelliteInfo) >= sizeof(TPositionCourseInfo));
	
	TSecurityPolicy readPolicy(ECapabilityLocation);
	TSecurityPolicy writePolicy(ECapabilityWriteDeviceData);
	
	// Network reference position property
	TInt err = RProperty::Define(KNetworkReferencePositionUpdateKey, 
								 RProperty::ELargeByteArray, 
								 readPolicy, 
								 writePolicy, 
								 sizeof(TLbsPositionUpdateData));
	if (err != KErrNone && err != KErrAlreadyExists)
		{
		User::Leave(err);
		}

	// Network final position property
	err = RProperty::Define(KNetworkFinalPositionUpdateKey, 
							 RProperty::ELargeByteArray, 
							 readPolicy, 
							 writePolicy, 
							 sizeof(TLbsPositionUpdateData));
	if (err != KErrNone && err != KErrAlreadyExists)
		{
		User::Leave(err);
		}

	// Set default values for the properties										 
	TLbsPositionUpdateData defaultData;
	defaultData.iError = KErrNotFound;
	defaultData.iTargetTime = 0;
	defaultData.iActualTime = 0;
	// indicate that the property is ok, but contains no data.
	defaultData.iValidData = EFalse;
	TLbsPositionUpdateDataPckgC pckg(defaultData);
	
	User::LeaveIfError(RProperty::Set(RProcess().SecureId(), 
									  KNetworkReferencePositionUpdateKey, 
									  pckg));
	
	User::LeaveIfError(RProperty::Set(RProcess().SecureId(), 
									  KNetworkFinalPositionUpdateKey, 
									  pckg));
	
	// Save the Uid of the process which called InitializeL()
	// in the cenrep file owned by LbsRoot.
	SetCategoryUidL(KNetworkPositionUpdateCategoryKey, 
				    RProcess().SecureId());
	}
コード例 #4
0
ファイル: mprocess.cpp プロジェクト: kuailexs/symbiandump-os1
TInt DMemModelProcess::DoCreate(TBool aKernelProcess, TProcessCreateInfo& aInfo)
	{
	// Required so we can detect whether a process has been created and added 
	// to its object container by checking for iContainerID!=EProcess.
	__ASSERT_COMPILE(EProcess != 0);
	__KTRACE_OPT(KPROC,Kern::Printf(">DMemModelProcess::DoCreate %O",this));
	TInt r=KErrNone;

	if (aKernelProcess)
		{
		iAttributes |= ESupervisor;
		iOsAsid = KKernelOsAsid;
		}
	else
		{
		r = MM::AddressSpaceAlloc(iPageDir);
		if (r>=0)
			{
			iOsAsid = r;
			r = KErrNone;
			}
		}
	if (r == KErrNone)
		{// Add this process's own reference to its os asid.
		__e32_atomic_store_ord32(&iOsAsidRefCount, 1);
		}

#ifdef BTRACE_FLEXIBLE_MEM_MODEL
	BTrace8(BTrace::EFlexibleMemModel,BTrace::EAddressSpaceId,this,iOsAsid);
#endif

	__KTRACE_OPT(KPROC,Kern::Printf("OS ASID=%d, PD=%08x",iOsAsid,iPageDir));
	__KTRACE_OPT(KPROC,Kern::Printf("<DMemModelProcess::DoCreate %d",r));
	return r;
	}
コード例 #5
0
//
// Location Response Message to PSY
//
EXPORT_C TLbsCellLocationResponseMsg::TLbsCellLocationResponseMsg(const TLbsNetSessionIdInt& aSessionId,
                                                                TInt aReason,
                                                                const TPositionInfoBase& aPosInfo): 
         TLbsNetInternalMsgBase(ECellLocationResponse, 
                           sizeof(TLbsCellLocationResponseMsg), 
                           aSessionId)
    {
    // Must make sure that the data to be stored is not bigger than the buffer.
    __ASSERT_COMPILE(sizeof(TLbsCellLocationResponseMsg) <= KMaximumMessageSizeBytes);

    iReason = aReason;
    // Check that the type of aPosInfo is valid
    TUint32 type = aPosInfo.PositionClassType();
    if (((type & EPositionInfoUnknownClass) != EPositionInfoUnknownClass)
        && ((type & EPositionInfoClass) != EPositionInfoClass)
        && ((type & EPositionCourseInfoClass) != EPositionCourseInfoClass)
        && ((type & EPositionSatelliteInfoClass) != EPositionSatelliteInfoClass)
        && ((type & EPositionExtendedSatelliteInfoClass) != EPositionExtendedSatelliteInfoClass))
        {
        User::Panic(_L("LbsNetInternal"), 1);
        }
    
    // The TPositionInfoBase is just the base class, so we need to copy over 
    // the data from the actual concrete class type.
    __ASSERT_DEBUG(aPosInfo.PositionClassSize() <= sizeof(TPositionExtendedSatelliteInfo), User::Invariant());
    Mem::Copy(&iPosInfo, &aPosInfo, aPosInfo.PositionClassSize());
    }
コード例 #6
0
CTRenderOrientation::CTRenderOrientation()
    {
    // check that these two enums are aligned
    __ASSERT_COMPILE(EDisplayOrientationAuto == ENumWindowSets);
    
    SetTestStepName(KTRenderOrientation);
    }
コード例 #7
0
/**
Verifies that the buffer contains a structurally correct command. 
This does not ensure that the content of the command is semantically valid.

@param aCommmand A new HL2CapCommand if the buffer contains a structurally valid command.
@param aBuffer The buffer containing the command
@return KErrNone if the command if created.
		KErrNoMemory if the command structure is valid but cannot be created.
		KErrCorrupt if the command structure is invalid.
*/
TInt HDisconnectRequest::NewCommandIfValid(RMBufChain& aBuffer, HL2CapCommand*& aCommand)
	{
	LOG_STATIC_FUNC
	// Firstly align the MBufChain.  The maximum size we can align the 
	// MBufChain to is the maximum MBuf size
	__ASSERT_COMPILE(KDisconnectRequestLength <= KMBufSmallSize);
	
	TInt length = aBuffer.Length();
	if(length == KDisconnectRequestLength)
		{
		// Don't need to check result as we know that the MBufChain contains
		// at least length bytes as we asked first.
		(void)aBuffer.Align(length);
		aCommand = new HDisconnectRequest(aBuffer);
		if(aCommand)
			{
			return KErrNone;
			}
		else
			{
			return KErrNoMemory;
			}
		}
	else
		{
		// Dodge length!
		return KErrCorrupt;
		}
	}
コード例 #8
0
ファイル: CS_SES.CPP プロジェクト: cdaffara/symbiandump-os1
void CCommSession::AddPlayerToDisconnectList(TWorkerId aPlayerId)
	{
	__ASSERT_COMPILE(TC32WorkerThreadPublicInfo::EMaxWorkerThreadId < 32);	// Using a TUint32 as a flag container
	ASSERT(aPlayerId <= TC32WorkerThreadPublicInfo::EMaxWorkerThreadId);
	__FLOG_STMT(
		if(!IsPlayerInDisconnectList(aPlayerId))
			{
			C32LOG3(KC32Detail, _L8("CCommSession(%08x):\tAddPlayerToDisconnectList(%d)"), this, aPlayerId );
			}
		)
コード例 #9
0
EXPORT_C TT_LbsAGpsRequestForcedUpdate::TT_LbsAGpsRequestForcedUpdate()
														: TT_LbsMsgBase(EModuleRequestForcedUpdate)
	{
	// Must make sure that the data to be stored is not bigger than the buffer.
	__ASSERT_COMPILE(sizeof(ST_LbsAGpsRequestForcedUpdate) <= sizeof(iBuffer));

	// In-place construction of the data member
	new(&Data()) ST_LbsAGpsRequestForcedUpdate;
		
	ST_LbsAGpsRequestForcedUpdate& data = Data();
	}
コード例 #10
0
//
// Location Cancel Message from PSY
//
EXPORT_C TLbsCellLocationCancelMsg::TLbsCellLocationCancelMsg(const TLbsNetSessionIdInt& aSessionId,
                                                                    TInt aReason):
    TLbsNetInternalMsgBase(ECellLocationCancel, 
                           sizeof(TLbsCellLocationCancelMsg),
                           aSessionId)
    {
    // Must make sure that the data to be stored is not bigger than the buffer.
    __ASSERT_COMPILE(sizeof(TLbsCellLocationCancelMsg) <= KMaximumMessageSizeBytes);
    
    iReason = aReason;
    }
コード例 #11
0
EXPORT_C TLbsNetLocNetworkLocationCompleteMsg::TLbsNetLocNetworkLocationCompleteMsg(
    const TLbsNetSessionIdInt& aSessionId,
    TInt aReason) :
    TLbsNetLocMsgBase(ENetLocMsgNetworkLocationComplete,
                      sizeof(TLbsNetLocNetworkLocationCompleteMsg),
                      aSessionId)
{
    // Must make sure that the data to be stored is not bigger than the buffer.
    __ASSERT_COMPILE(sizeof(TLbsNetLocNetworkLocationCompleteMsg) <= KMaximumMessageSizeBytes);

    iReason = aReason;
}
コード例 #12
0
///////////////////////////////////////////////////////////////////////////////
// Test A-Gps Module Request Options
///////////////////////////////////////////////////////////////////////////////
EXPORT_C TT_LbsAGpsRequestOptions::TT_LbsAGpsRequestOptions(TLbsHybridModuleOptions aModuleOption) 
															: TT_LbsMsgBase(EModuleRequestOptions)
	{
	// Must make sure that the data to be stored is not bigger than the buffer.
	__ASSERT_COMPILE(sizeof(ST_LbsAGpsRequestOptions) <= sizeof(iBuffer));

	// In-place construction of the data member
	new(&Data()) ST_LbsAGpsRequestOptions;
		
	ST_LbsAGpsRequestOptions& data = Data();

	data.iModuleOption = aModuleOption;
	}
コード例 #13
0
//
// Location Request Message from PSY
//
EXPORT_C TLbsCellLocationRequestMsg::TLbsCellLocationRequestMsg(const TLbsNetSessionIdInt& aSessionId,
                                                                TUid aProtocolModule,
                                                                const TLbsNetPosRequestOptionsInt& aOptions) :
        TLbsNetInternalMsgBase(ECellLocationRequest, 
                      sizeof(TLbsCellLocationRequestMsg),
                      aSessionId)
    {
    // Must make sure that the data to be stored is not bigger than the buffer.
    __ASSERT_COMPILE(sizeof(TLbsCellLocationRequestMsg) <= KMaximumMessageSizeBytes);

    iProtocolModule = aProtocolModule;
    iOptions = aOptions;
    }
コード例 #14
0
EXPORT_C TT_LbsAGpsResponseMsg::TT_LbsAGpsResponseMsg(const TModuleResponseType& 	aResponse)
							  						: TT_LbsMsgBase(EModuleResponse)
	{
	// Must make sure that the data to be stored is not bigger than the buffer.
	__ASSERT_COMPILE(sizeof(ST_LbsAGpsResponse) <= sizeof(iBuffer));

	// In-place construction of the data member
	new(&Data()) ST_LbsAGpsResponse;
		
	ST_LbsAGpsResponse& data = Data();

	data.iResponseType = aResponse;
	}
コード例 #15
0
///////////////////////////////////////////////////////////////////////////////
// Test A-Gps Module Request Error
///////////////////////////////////////////////////////////////////////////////
EXPORT_C TT_LbsAGpsRequestError::TT_LbsAGpsRequestError(TInt aError)
														: TT_LbsMsgBase(EModuleRequestError)
	{
	// Must make sure that the data to be stored is not bigger than the buffer.
	__ASSERT_COMPILE(sizeof(ST_LbsAGpsRequestError) <= sizeof(iBuffer));

	// In-place construction of the data member
	new(&Data()) ST_LbsAGpsRequestError;
		
	ST_LbsAGpsRequestError& data = Data();

	data.iError = aError;
	}
コード例 #16
0
EXPORT_C TT_LbsAGpsRequestTimeOut::TT_LbsAGpsRequestTimeOut(const TTimeIntervalMicroSeconds& aTimeOut)
															: TT_LbsMsgBase(EModuleRequestTimeOut)
	{
	// Must make sure that the data to be stored is not bigger than the buffer.
	__ASSERT_COMPILE(sizeof(ST_LbsAGpsRequestTimeOut) <= sizeof(iBuffer));

	// In-place construction of the data member
	new(&Data()) ST_LbsAGpsRequestTimeOut;
		
	ST_LbsAGpsRequestTimeOut& data = Data();

	data.iTimeOut = aTimeOut;
	}
コード例 #17
0
EXPORT_C void CPolicyServer::ProcessError(const RMessage2& aMsg, TInt aError)
	{
	__ASSERT_COMPILE(-1 == RMessage2::EConnect);
	__ASSERT_ALWAYS(aMsg.Function() >= RMessage2::EConnect, User::Panic(KPolicyServer, 2));
	if(aMsg.Authorised() && aMsg.Function() >= 0)
		{
		aMsg.Session()->ServiceError(aMsg, aError);
		}
	else //Either ServiceL hadn't been called yet (not (yet) authorised) or
		//it's a Connect message
		{
		aMsg.Complete(aError);
		}
	}
コード例 #18
0
EXPORT_C TLbsNetLocNetworkLocationRequestMsg::TLbsNetLocNetworkLocationRequestMsg(
    const TLbsNetSessionIdInt& aSessionId,
    TBool aNewClient,
    TLbsNetPosRequestQualityInt aQuality) :
    TLbsNetLocMsgBase(ENetLocMsgNetworkLocationRequest,
                      sizeof(TLbsNetLocNetworkLocationRequestMsg),
                      aSessionId)
{
    // Must make sure that the data to be stored is not bigger than the buffer.
    __ASSERT_COMPILE(sizeof(TLbsNetLocNetworkLocationRequestMsg) <= KMaximumMessageSizeBytes);

    iNewClient = aNewClient;
    iQuality = aQuality;
}
コード例 #19
0
///////////////////////////////////////////////////////////////////////////////
// Test A-Gps Module Request Update Initialization Message
///////////////////////////////////////////////////////////////////////////////
EXPORT_C TT_LbsAGpsRequestUpdateInitMsg::TT_LbsAGpsRequestUpdateInitMsg(const TDesC& aConfigFileName, const TDesC& aConfigSection)
																		: TT_LbsMsgBase(EModuleRequestUpdateInit)
	{
	// Must make sure that the data to be stored is not bigger than the buffer.
	__ASSERT_COMPILE(sizeof(ST_LbsAGpsRequestUpdateInit) <= sizeof(iBuffer));

	// In-place construction of the data member
	new(&Data()) ST_LbsAGpsRequestUpdateInit;
		
	ST_LbsAGpsRequestUpdateInit& data = Data();

	data.iConfigFileName = aConfigFileName;	
	data.iConfigSection = aConfigSection;	
	}
コード例 #20
0
//static
bool QFileSystemEngine::setCurrentPath(const QFileSystemEntry &entry)
{
    QFileSystemMetaData meta;
    QFileSystemEntry absname = absoluteName(entry);
    fillMetaData(absname, meta, QFileSystemMetaData::ExistsAttribute | QFileSystemMetaData::DirectoryType);
    if(!(meta.exists() && meta.isDirectory()))
        return false;

    RFs& fs = qt_s60GetRFs();
    QString abspath = absname.nativeFilePath();
    if(!abspath.endsWith(QLatin1Char('\\')))
        abspath.append(QLatin1Char('\\'));
    TInt r = fs.SetSessionPath(qt_QString2TPtrC(abspath));
    //SetSessionPath succeeds for non existent directory, which is why it's checked above
    if (r == KErrNone) {
        __ASSERT_COMPILE(sizeof(wchar_t) == sizeof(unsigned short));
        //attempt to set open C to the same path
        r = ::wchdir(reinterpret_cast<const wchar_t *>(absname.filePath().utf16()));
        if (r < 0)
            qWarning("failed to sync path to open C");
        return true;
    }
    return false;
}
コード例 #21
0
EXPORT_C void CPolicyServer::RunL()
	{
	const RMessage2& msg = Message();
	msg.ClearAuthorised();
	TInt fn = msg.Function();

	__ASSERT_COMPILE(-1 == RMessage2::EConnect);
	if(fn >= RMessage2::EConnect) 
		//So this implies any "normal" message or Connect
		//Now we have two steps to follow each having two mutually exculsive
		//parts.
		//Step 1: Find policy.
		//Step 2: Apply policy.
		{
		const TPolicyElement* element = 0;
		TUint specialCase = 0;
		//1a: If its a normal message.  Find the associate policy or special
		//case action.
		if(fn >= 0)
			{
			element = FindPolicyElement(fn, specialCase);
			}
		//1b: If its a connect message, there's a shortcut to the policy.
		else 
			{
			TUint8 i = iPolicy.iOnConnect;
			if(i >= ESpecialCaseHardLimit)
				specialCase = i;
			else
				element = &(iPolicy.iElements[i]);
			}
		//2a: We found a policy that we can automatically apply... Apply it!
		if(element)
			{
			TSecurityInfo missing;
			//If policy check succeeds, allow it through
			if(element->iPolicy.CheckPolicy(msg, missing, __PSD("Checked by CPolicyServer::RunL")))
				{
				ProcessL(msg);
				}
			//Else see what failure action is required (return error code,
			//panic client, ask user, etc...)
			else
				{
				CheckFailedL(msg, element->iAction, missing);
				}
			}
		//2b: The policy is a special case
		else 
			{
			switch(specialCase)
				{
				//If you change this you'll have to add to the switch statement
				__ASSERT_COMPILE(ESpecialCaseLimit == 252u);
				case ECustomCheck:
					{
					TInt action = EFailClient; 
					//The default action after failing a CustomSecurityCheck is
					//to complete the message with KErrPermissionDenied.  If
					//you want a different action, then change the action
					//parameter prior to returning from your derived
					//implementation of CustomSecurityCheckL
					TSecurityInfo missing;
					__ASSERT_COMPILE(SCapabilitySet::ENCapW == 2);
					memset(&missing, 0, sizeof(SSecurityInfo));
					TCustomResult result = CustomSecurityCheckL(msg, action, missing);
					if(result == EPass)
						{
						ProcessL(msg);
						}
					else if(result == EFail)
						{
						CheckFailedL(msg, action, missing); 
						}
					else if(result == EAsync)
						{
						//Do Nothing.  Derived CustomSecurityCheck is
						//responsible for calling ProcessL/CheckFailedL
						}
					else
						Panic(EPolSvrInvalidCustomResult);
					}
					break;	
				case ENotSupported:
					msg.Complete(KErrNotSupported);	
					break;
				case EAlwaysPass:
					ProcessL(msg);
					break;
				default:
					Panic(EPolSvrPolicyInvalid);
					break;
				}
			}
		}
	//else it must be either Disconnect or bad message.  Both are handled by
	//ProcessL
	else 
		{
		ProcessL(msg);
		}

	// Queue reception of next message if it hasn't already been done
	if(!IsActive())
		ReStart();
	}
コード例 #22
0
ファイル: sf_fmt.cpp プロジェクト: kuailexs/symbiandump-os1
/**
    Open a drive for formatting.
*/
TInt FsFormatOpen(CFsRequest* aRequest)
	{
    TDrive& drive = *aRequest->Drive();

	__PRINT1(_L("FsFormatOpen() drv:%d"), drive.DriveNumber());
    
    TInt nMountRes = drive.CheckMount();
    //-- KErrNotReady means that there is no file system mounted on this drive
    //-- KErrInUse means that there are some "disk access" objects, like RFormat or RRawDisk opened on the mount.
    if(nMountRes == KErrNotReady || nMountRes == KErrInUse) 
        {
        __PRINT1(_L("FsFormatOpen() ChkMount:%d"), nMountRes);
        return nMountRes;
        }
    
    const TFormatMode fmtMode = (TFormatMode)aRequest->Message().Int1();
    TName buf;
    TUint32 currFsNameHash = 0; //-- current file system name hash, 0 means "not set"; used during forced FS dismounting

    if((nMountRes == KErrNone) && drive.CurrentMount().LockStatus() < 0)
        {//-- the mount is locked, it has normal objects (files, directories) opened on it. 
        
        //-- if someone is interested in the list of opened files and number of opened directories, compile this code in.
        #ifdef DUMP_OPENED_OBJECTS
            DumpOpenedObjects(drive);
        #endif //DUMP_OPENED_OBJECTS


        if(!(fmtMode & EForceFormat))
            {
            __PRINT(_L("FsFormatOpen() The mount is in use"));
            return KErrInUse;
            }    

        //-- there is a special flag that tells to force media dismounting even if it has files or dirs opened.
        __PRINT(_L("FsFormatOpen() The mount is in use, forcing dismounting!"));

        //-- record currently mounted FS name hash, it may be used after forced dismounting
        drive.CurrentMount().FileSystemName(buf); //-- the iCurrentMount is alive
        currFsNameHash = TVolFormatParam::CalcFSNameHash(buf);

        //-- kill the current mount
        FsThreadManager::LockDrive(drive.DriveNumber());
        TInt nRes = drive.ForceUnmountFileSystemForFormatting();
        FsThreadManager::UnlockDrive(drive.DriveNumber());

        
        switch(nRes)
            {
            case KErrInUse: 
            __PRINT(_L("FsFormatOpen() The mount has clamps! Can't force dismount"));    
            return KErrInUse; //-- there are clamps on this drive - can't dismount

            case KErrNone:
            break;

            default:
            ASSERT(0); //-- unexpected error code
            return nRes;

            };

        if(fmtMode & EQuickFormat)
            {//-- quick format may require the normally mounted FS, make the best effrot to mount it
            nMountRes = drive.CheckMount();
            }
        else
            {//-- this will make the FS mounted by force; for full format it will be quicker
            nMountRes = KErrCorrupt;
            }

        }

	//-- if True, we will need mount (probably specific) file system by force because normal mounting has failed
    TBool bNeedForceMount = (nMountRes != KErrNone); 

    //-- find out if we have optional data structure that describes format parameter
    TUint32 newFsNameHash = 0; //-- file system name hash, may be used for selecting which file system to put onto the volume. 0 means "not specified"

    const TLDFormatInfo*    pLDFormatInfo   = NULL;
    const TVolFormatParam*  pVolFormatParam = NULL;

    __ASSERT_COMPILE(sizeof(TVolFormatParam) >= sizeof(TLDFormatInfo));
    TBuf8<sizeof(TVolFormatParam)> paramBuf;
   
    
    if(fmtMode & ESpecialFormat)  
        {   
        //-- the user has provided format parameters structure.
        //-- IPC argument #2 contains a structure: <TUint32>[optional package descriptor]
        //-- where 1st mandatory TUint32 is a pointer to format counter and the optional additional package is a data structure passed to the filesystem by the client of RFormat
        const TInt desLen = aRequest->GetDesLength(KMsgPtr2);
        ASSERT((TUint32)desLen >= sizeof(TUint32));
    
        const TInt dataPckgLen = desLen - sizeof(TUint32);

        if((TUint32)dataPckgLen > sizeof(TUint32))
            {
            aRequest->ReadL(KMsgPtr2, paramBuf); 
            }
        
        if(dataPckgLen == sizeof(TLDFormatInfo))
            {//-- the user has provided formatting parameters via TLDFormatInfo structure.
            pLDFormatInfo = (const TLDFormatInfo*)(paramBuf.Ptr() + sizeof(TUint32));
            }
        else if(dataPckgLen == sizeof(TVolFormatParam))
            {//-- it's likely to be TVolFormatParam, need to check UId to be sure.
            pVolFormatParam = (const TVolFormatParam*)(const TVolFormatParam*)(paramBuf.Ptr() + sizeof(TUint32));

            if(pVolFormatParam->iUId == TVolFormatParam::KUId)  //-- check the class UID
                {//-- this is the real TVolFormatParam object passed
                newFsNameHash = pVolFormatParam->FSNameHash();
                }
            }
        else if(dataPckgLen >0)
            {//-- parameters data structure has strange length
            return KErrArgument;
            }
    
        }

    //-------------------
    if(!newFsNameHash && currFsNameHash)
        {//-- new file system name isn't specified (default formatting), but the volume had been forcedly dismounted.
         //-- restore the original file system   
        newFsNameHash = currFsNameHash;
        }
    
    if(newFsNameHash)
        {//-- check if the specified FS is already mounted on the volume
        if(!bNeedForceMount)
            {
            drive.CurrentMount().FileSystemName(buf); //-- the iCurrentMount is alive
            }
        else
            { //-- the iCurrentMount can be NULL, use the iFsys - the real file system associated with this drive
            buf = drive.GetFSys()->Name();
            }

        const TUint32 currFSNameHash = TVolFormatParam::CalcFSNameHash(buf);
        if(currFSNameHash == newFsNameHash)
            {//-- no need to do anything, the required FS is already mounted
            newFsNameHash = 0; 
            } 
        }

    if(newFsNameHash) 
        {
        //-- the user has specified some filesystem to be mounted on the volume. Check if this FS is supported at all.
        //-- if it is supported, but some other FS is currently mounted, it will be dismounted and the new one will be forced.
        TInt nRes;
            
        for(TInt cntFS=0; ;++cntFS)
            {
            nRes = drive.FSys().GetSupportedFileSystemName(cntFS, buf); //-- enumerate possible child file systems
            
            if(nRes != KErrNone)
                return KErrNotSupported; //-- the filesystem with the given name (fsNameHash) is not supported.

            if(newFsNameHash == TVolFormatParam::CalcFSNameHash(buf))
                {//-- the filesystem with the given name (fsNameHash) is supported, but some other filesystem can be already mounted
                drive.Dismount();
                bNeedForceMount = ETrue; //-- this will force the desired FS to be mounted
                break;
                }
            }
    
        }//if(fsNameHash) 


    //-- try force mounting the desired file system if it is required
    if(bNeedForceMount)
        {
        const TInt KMaxRetries = 3;
        for(TInt cnt=0; ; ++cnt)
            {
            drive.MountFileSystem(ETrue, newFsNameHash);

            nMountRes = drive.GetReason();
            if(nMountRes == KErrNone || nMountRes == KErrLocked)
                break;
            
            drive.Dismount(); //-- will reset mount retries counter
            
            if(cnt >= KMaxRetries)
                {
                __PRINT1(_L("FsFormatOpen() can't mount FS! res:%d"), nMountRes);    
                return nMountRes;
                }
            }
        }

    ASSERT(nMountRes == KErrNone || nMountRes == KErrLocked);
    
    __ASSERT_DEBUG(drive.CurrentMount().LockStatus()==0, Fault(ESvrFormatOpenFailed));


	TDriveInfo dInfo;
	drive.DriveInfo(dInfo);
	const TInt mediaAtt = dInfo.iMediaAtt;

#if defined(_LOCKABLE_MEDIA)
	if (!(fmtMode & EForceErase) && (mediaAtt & KMediaAttLocked))
		{
		// if attempting to format a locked drive, dismount otherwise subsequent 
		// requests will operate on a mount that has been forcibly mounted (a few lines above)
		CMountCB* pM = &drive.CurrentMount();
		
        if(pM)
			pM->Close();

		drive.MountFileSystem(EFalse);	// clear iCurrentMount
		return KErrLocked;
		}
#endif

	if (!(mediaAtt & KMediaAttFormattable) || (mediaAtt & KMediaAttWriteProtected))
		{
		CMountCB* pM = &drive.CurrentMount();
		
        if(pM)
			pM->Close();

		drive.MountFileSystem(EFalse);
        return KErrAccessDenied;
		}

	//-- instantinate and open CFormatCB object for this drive
    CFormatCB* formatCB=NULL;
	TInt fmtHandle;
    
    TRAPD(ret, formatCB = drive.FormatOpenL(aRequest, fmtHandle, fmtMode, pLDFormatInfo, pVolFormatParam ));

	if (ret!=KErrNone)
		{
		if(formatCB)
			formatCB->Close();

		return ret;
		}

	TPtrC8 pH((TUint8*)&fmtHandle,sizeof(TInt));
	aRequest->WriteL(KMsgPtr3,pH);
	TInt count=100;

	TPtrC8 pCount((TUint8*)&count,sizeof(TInt));
	aRequest->WriteL(KMsgPtr2,pCount);
	aRequest->Session()->IncResourceCount();
	
    return KErrNone;
	}
コード例 #23
0
void CMemSpyEngineHelperActiveObject::ExtractActiveObjectAddressesL( TAny* aSchedulerCellAddress, const TDesC8& aSchedulerCellData, CMemSpyEngineActiveObjectArray& aArray )
    {
    // Create read stream
    RDesReadStream stream( aSchedulerCellData );
    CleanupClosePushL( stream );

    // First item is vtable
    TUint address = stream.ReadUint32L();
    //RDebug::Printf("CMemSpyEngineHelperActiveObject::ExtractActiveObjectAddressesL() - vtable: 0x%08x", address );
    (void) address;

    // Next item is CActiveScheduler::iStack - which we'll skip, because it might be a stack address
    // I suppose we could validate this against the thread's stack address range, but can't be bothered
    // at the moment.
    address = stream.ReadUint32L();
    //RDebug::Printf("CMemSpyEngineHelperActiveObject::ExtractActiveObjectAddressesL() - got CActiveScheduler::iStack as: 0x%08x", address);
    (void) address;

    // Then comes CActiveScheduler::iActiveQ - this is what we are interested in.... 
    //
    //  class TPriQue : public TDblQueBase
    //        [TDblQueBase::iHead] - this just derives from TDblQueLinkBase and doesn't have any direct data members
    //            class TDblQueLink : public TDblQueLinkBase
    //                [ptr]  TDblQueLinkBase::iNext*
    //                [ptr]  TDblQueLinkBase::iPrev*
    // [TInt] TDblQueBase::iOffset
    __ASSERT_COMPILE( sizeof( TDblQueLinkBase* ) == sizeof(TUint) );
    __ASSERT_COMPILE( sizeof( TInt ) == 4 );

    // Get read offset so that we know the starting address of the queue
    const TStreamPos pos = stream.Source()->TellL(MStreamBuf::ERead);
#ifdef __WINS__
    const TAny* terminatingQueueAddress = (TAny*) (TUint(aSchedulerCellAddress) + pos.Offset());
#else
    const TAny* terminatingQueueAddress = (TAny*) aSchedulerCellAddress;
#endif

    const TAny* queueNext = (TAny*) stream.ReadUint32L();
    const TAny* queuePrev = (TAny*) stream.ReadUint32L();
    const TUint queueItemOffset = stream.ReadUint32L();
    //RDebug::Printf("CMemSpyEngineHelperActiveObject::ExtractActiveObjectAddressesL() - queueNext: 0x%08x, queuePrev: 0x%08x, queueItemOffset: %d, pos: %d, terminatingQueueAddress: 0x%08x", queueNext, queuePrev, queueItemOffset, pos.Offset(), terminatingQueueAddress);
    (void) queuePrev;
    CleanupStack::PopAndDestroy( &stream );
        
    // Iterate through the active objects
    if  ( queueNext != NULL )
        {
        TAny* realNextCellHeapCell = NULL;
        TAny* calculatedCellAddress = ((TAny*) (TUint(queueNext) - queueItemOffset));

        while( !( calculatedCellAddress == NULL || calculatedCellAddress == terminatingQueueAddress || realNextCellHeapCell == terminatingQueueAddress ) )
            {
            // Create an active object for this cell
            TAny* nextCell = ReadActiveObjectDataL( calculatedCellAddress, aArray );
            
            // Work out next cell address
            calculatedCellAddress = ((TAny*) ( TUint( nextCell ) - queueItemOffset ) );
            //RDebug::Printf("CMemSpyEngineHelperActiveObject::ExtractActiveObjectAddressesL() - calculatedCellAddress: 0x%08x, terminatingQueueAddress: 0x%08x", calculatedCellAddress, terminatingQueueAddress);

            // Identify the next cell address
            realNextCellHeapCell = ConvertAddressToRealHeapCellAddressL( nextCell );
            }
        }
    }
コード例 #24
0
EXPORT_C TT_LbsMsgBase::TT_LbsMsgBase() :
	iType(EUnknown)
	{
	// Check that the internal buffer is 8-byte aligned.
	__ASSERT_COMPILE((_FOFF(TT_LbsMsgBase, iBuffer) & 0x40) == 0x0);
	}