void CServerCrashDataSource::GetExecutableListL( RExecutablePointerList & aExecutableList,
TUint & aTotalExecutableListDescSize )
{
LOG_MSG( "CServerCrashDataSource::GetExecutableListL()\n" );
// Delete any objects in the array, since we will replace them.
aExecutableList.ResetAndDestroy();
aTotalExecutableListDescSize = 0;
if( iExecutableListBuffer.Size() != iLastExecutableListSize )
{
LOG_MSG2( " iExecutableListBuffer.ReAlloc( %d)\n", iLastExecutableListSize );
iExecutableListBuffer.ReAllocL( iLastExecutableListSize );
}
DoGetListL( EExecutables, (TUint)(-1), (TUint)(-1), iExecutableListBuffer, iLastExecutableListSize );
iLastExecutableListSize = iExecutableListBuffer.Size();
TUint8* ptr = (TUint8*)( iExecutableListBuffer.Ptr() );
const TUint8* ptrEnd = ptr + iLastExecutableListSize;
//LOG_MSG3( " Data start,end=(0x%x, 0x%x)\n", ptr, ptrEnd );
while( ptr < ptrEnd )
{
TExecutablesListEntry *entry = (TExecutablesListEntry*)ptr;
if( !entry )
{
LOG_MSG( " ERROR !* : TExecutablesListEntry is NULL\n" );
User::Leave(KErrBadHandle);
}
if( entry->iNameLength == 0 )
{
LOG_MSG( " Skipping executable : entry->iNameLength=0" );
ptr += Align4( entry->GetSize() );
continue;
}
TPtrC entryName(&(entry->iName[0]), entry->iNameLength);
CExecutableInfo *executableInfoPtr =
CExecutableInfo::NewL(entryName, entry->iIsActivelyDebugged, entry->iIsPassivelyDebugged );
TInt err = aExecutableList.Append( executableInfoPtr );
if(err != KErrNone)
{
delete executableInfoPtr;
User::Leave(err);
}
aTotalExecutableListDescSize += executableInfoPtr->Size();
ptr += Align4( entry->GetSize() );
}
}
/*
* The order of the data in the buffer is:
* Word1 : NotificationSize (2 bytes) , PathSize (2 bytes)
* Word2 : NewNameSize (2 bytes) , NotificationType (2 bytes)
* Word3 : UID - NOT YET SUPPORTED
* Word(s) : Path (TText8) , [Any sub-class members]
*
* The size should be located at: *this + KNotificationHeaderSize + Align4(PathSize)
*/
EXPORT_C TInt TFsNotification::FileSize(TInt64& aSize) const
{
if(NotificationType() != EFileChange)
return KErrNotSupported;
aSize = *PtrAdd((TInt64*)this, KNotificationHeaderSize + Align4(PathSize()));
return KErrNone;
}
TInt CMemEntry::EntrySize()
//
// Calculate the entries size.
//
{
return(Align4(KRomEntrySize+iEntry.iNameLength));
}
static void LoadDebug(LoadState* S, Proto* f)
{
int i,n;
n=LoadInt(S);
Align4(S);
if (!luaZ_direct_mode(S->Z)) {
f->lineinfo=luaM_newvector(S->L,n,int);
LoadVector(S,f->lineinfo,n,sizeof(int));
} else {
// -----------------------------------------------------------------------------
// CDirectoryDesc::Read : Reading from a Directory
// -----------------------------------------------------------------------------
void CDirectoryDesc::Read(TDes8& aDesc, TRequestStatus& aStatus)
{
TInt errorNum = KErrNone;
const TInt16 KDirentSize = 8;
TInt readLen = aDesc.MaxLength();
TUint8* bufPtr = const_cast<TUint8*>(aDesc.Ptr());
TInt copiedInfo = 0;
TEntryArray entries;
errorNum = iDir.Read( entries );
TDirent direntEntry;
if (errorNum == KErrNone || errorNum == KErrEof)
{
errorNum = KErrNone;
TEntry entry;
TInt len = 0;
TInt count = entries.Count();
TBuf8<KMaxFileName> fileName;
TInt index = 0;
TInt copyLen = 0;
//Loop through each entry and get all the informations
for (; index<count && copiedInfo<readLen; index++, copiedInfo += copyLen)
{
entry = entries[index];
//Copy File's UID
TUid fileUID = entry.iType.MostDerived();
direntEntry.iEntryNum = fileUID.iUid;
HBufC8 *name;
if(ConvertUnicodeToUtf8(entry.iName,name,errorNum) == -1)
{
break;
}
//Copy entry type and record Length
fileName.Copy( name->Des() );
delete name;
len = fileName.Length();
direntEntry.iRecLen = KDirentSize + len + 1;
//Maintaing a four byte boundary.
direntEntry.iRecLen = Align4(direntEntry.iRecLen);
direntEntry.iEntryType = 0;
direntEntry.iNameLen = len;
//Copy entry name
Mem::Copy( direntEntry.iEntryName, fileName.PtrZ(), len+1);
//Copy structure on to the buffer
copyLen = Min(direntEntry.iRecLen, (readLen - copiedInfo));
Mem::Copy( bufPtr, &direntEntry, copyLen );
bufPtr += copyLen;
}
}
//Set the Length
aDesc.SetLength( copiedInfo );
TRequestStatus* status = &aStatus;
User::RequestComplete(status, errorNum);
}
/*
* The order of the data in the buffer is:
* Word1 : NotificationSize (2 bytes) , PathSize (2 bytes)
* Word2 : NewNameSize (2 bytes) , NotificationType (2 bytes)
* Word3 : UID - NOT YET SUPPORTED
* Word(s) : Path (TText8) , [Any sub-class members]
*
* The attribute should be located at: *this + KNotificationHeaderSize + Align4(PathSize)
*/
EXPORT_C TInt TFsNotification::Attributes(TUint& aSetAtt, TUint& aClearAtt) const
{
if(NotificationType() != EAttribute)
return KErrNotSupported;
TUint* clearAttptr = PtrAdd((TUint*)this, KNotificationHeaderSize + Align4(PathSize()));
aClearAtt = *clearAttptr;
aSetAtt = *PtrAdd((TUint*)clearAttptr, sizeof(TUint));
return KErrNone;
}
static void LoadDebug(LoadState* S, Proto* f)
{
int i,n;
n=LoadInt(S);
Align4(S);
#ifdef LUA_OPTIMIZE_DEBUG
if(n) {
if (!luaZ_direct_mode(S->Z)) {
f->packedlineinfo=luaM_newvector(S->L,n,unsigned char);
LoadBlock(S,f->packedlineinfo,n);
} else {
int CField::QuerySaveLength()
{
if (GetFieldType() == fString)
{
return Align4(m_nWidth);
}
else
{
return sizeof(FieldNUM);
}
}
CMemEntry::CMemEntry(const TEntry& anEntry)
//
// Constructor.
//
{
iEntry.iAtt=(TUint8)(anEntry.iAtt|KEntryAttReadOnly); // All rom files are read only
iEntry.iSize=anEntry.iSize;
iEntry.iNameLength=(TUint8)anEntry.iName.Size();
iSize=Align4(anEntry.iSize);
__DECLARE_NAME(_S("CMemEntry"));
}
/************************************************************************************
函数名称：
bool CField::LoadDataFromBuffer(LPBYTE& lpIndicate, LPBYTE& lpData)
功能说明：虚函數,读取一条记录某一字段的数据,可以用来读取值标签.
详细解释：1.子类实现.
出入参数：
[in]: 1.lpIndicate:指示字节地址.
2.lpData :数据地址.
[out]:1.lpIndicate:下一数据块的指示字节地址.
2.lpData :下一数据块的数据地址.
返回类型：bool
制作：YTLI 2002/07/12
修改:
************************************************************************************/
void CField::LoadDataFromBuffer( LPBYTE& lpData)
{
if(m_pValue==NULL)
{//旧版本
if(m_nNextModifyField == -1)
{
NewData();
LoadDataFromBuffer(lpData);
DeleteData();
}
else
{
if(m_pFields->IsConvertToLastVersion(this))
{
NewData();
LoadDataFromBuffer(lpData);
CField* pNewField = m_pFields->m_FieldVersion.GetFieldByAbsolutePos(m_nNextModifyField);
pNewField->ConvertToCurField(this);
DeleteData();
}
}
}
else
{//当前最新
if (GetFieldType() == fString)
{
FieldString* pStr = (FieldString*)m_pValue;
char *pBuf = new char[m_nWidth+2];
memset(pBuf,0,m_nWidth+2);
memcpy(pBuf,lpData,m_nWidth);
*pStr= pBuf;
/*
char* lpstr = pStr->GetBuffer(m_nWidth+2);
memcpy(lpstr,lpData,m_nWidth);
*(lpstr+m_nWidth)= 0;
*(lpstr+m_nWidth+1)= 0;
pStr->ReleaseBuffer();
*/
//pStr->TrimLeft();//,左边空格保留
pStr->TrimRight();
lpData = lpData + Align4(m_nWidth);
}
else
{
memcpy( &*((FieldNUM *)m_pValue), lpData, sizeof(FieldNUM) ); //ytli Modify 2002/09/04
lpData = lpData + sizeof(FieldNUM);
}
}
}
static void LoadCode(LoadState* S, Proto* f)
{
int n=LoadInt(S);
Align4(S);
if (!luaZ_direct_mode(S->Z)) {
f->code=luaM_newvector(S->L,n,Instruction);
LoadVector(S,f->code,n,sizeof(Instruction));
} else {
f->code=(Instruction*)luaZ_get_crt_address(S->Z);
LoadVector(S,NULL,n,sizeof(Instruction));
}
f->sizecode=n;
}
static void DumpCode(const Proto *f, DumpState* D)
{
DumpInt(f->sizecode,D);
char buf[10];
int i;
Align4(D);
for (i=0; i<f->sizecode; i++)
{
memcpy(buf,&f->code[i],sizeof(Instruction));
MaybeByteSwap(buf,sizeof(Instruction),D);
DumpBlock(buf,sizeof(Instruction),D);
}
}
/*
* The order of the data in the buffer is:
* Word1 : NotificationSize (2 bytes) , PathSize (2 bytes)
* Word2 : NewNameSize (2 bytes) , NotificationType (2 bytes)
* Word3 : UID - NOT YET SUPPORTED
* Word(s) : Path (TText8) , [Any sub-class members]
*
* The new name should be located at: *this + KNotificationHeaderSize + Align4(PathSize)
*/
EXPORT_C TInt TFsNotification::NewName(TPtrC& aNewName) const
{
//Only ERename, EVolumeName and EDriveName have second paths
//Notification of type EOverflow does not have a path associated with it
TFsNotificationType notificationType = NotificationType();
if((notificationType != ERename &&
notificationType != EVolumeName &&
notificationType != EDriveName) ||
notificationType == EOverflow)
{
return KErrNotSupported;
}
TUint16* pathPtr = PtrAdd((TUint16*)this, KNotificationHeaderSize + Align4(PathSize()));
aNewName.Set(pathPtr,NewNameSize()/2);
return KErrNone;
}
EXPORT_C CFsNotify* CFsNotify::NewL(RFs& aFs, TInt aBufferSize)
{
CFsNotify* self=new(ELeave) CFsNotify;
CleanupStack::PushL(self);
//Making sure buffer size is at least minimally large and not too big
if(aBufferSize > (KMaxTInt/2))
{
User::Leave(KErrArgument);
}
else if(aBufferSize < KMinNotificationBufferSize)
{
aBufferSize = KMinNotificationBufferSize;
}
self->ConstructL(aFs, Align4(aBufferSize));
CleanupStack::Pop(self);
return self;
}
// class Entry
TRomEntry* Entry::CreateRomEntry(char*& anAddr) const
{
TRomEntry *pE=(TRomEntry*)anAddr;
pE->iAtt=iRomNode->iAtt;
pE->iSize=iRomNode->iRomFile->iAddresses.iSize;
pE->iAddressLin=iRomNode->iRomFile->iAddresses.iRunAddr;
if (IsFile())
iRomNode->iRomFile->SetRomEntry(pE);
pE->iName[0]=0;
pE->iName[1]=0;
TInt nl=iRomNode->NameCpy((char*)pE->iName);
pE->iNameLength=(TUint8)nl;
if (Unicode)
nl<<=1;
anAddr+=Align4(KRomEntrySize+nl);
TRACE(TDIR,DumpRomEntry(*pE));
return pE;
}
/************************************************************************************
函数名称：
功能说明：将m_pValue指向的值按文件格式存入Buffer中.
详细解释：1.
2.返回数据长度.
3.如果传入指针无效,则返回-1.
出入参数：
[in]: 1.lpData:指向的数据为数据指示+数据内容.
[out]:无.
返回类型：long
制作：YTLI 2002/07/15
修改:
************************************************************************************/
void CField::SaveDataToBuffer(LPBYTE& lpData)
{
if (GetFieldType() == fString)
{
FieldString* pStr = (FieldString*)m_pValue;
char* lpstr = pStr->GetData();
memcpy(lpData,lpstr,pStr->GetLength()+1);
/*char* lpstr = pStr->GetBuffer(m_nWidth+2);
memcpy(lpData,lpstr,m_nWidth);
pStr->ReleaseBuffer(); */
lpData +=Align4(m_nWidth);
}
else
{
memcpy( lpData,m_pValue, sizeof(FieldNUM) ); //ytli Modify 2002/09/04
lpData +=sizeof(FieldNUM);
}
}
static void DumpDebug(const Proto* f, DumpState* D)
{
int i,n;
n= (D->strip) ? 0 : f->sizelineinfo;
DumpInt(n,D);
Align4(D);
for (i=0; i<n; i++)
{
DumpInt(f->lineinfo[i],D);
}
n= (D->strip) ? 0 : f->sizelocvars;
DumpInt(n,D);
for (i=0; i<n; i++)
{
DumpString(f->locvars[i].varname,D);
DumpInt(f->locvars[i].startpc,D);
DumpInt(f->locvars[i].endpc,D);
}
n= (D->strip) ? 0 : f->sizeupvalues;
DumpInt(n,D);
for (i=0; i<n; i++) DumpString(f->upvalues[i],D);
}
// -----------------------------------------------------------------------------
// TSockAddr::GetUserLen
// -----------------------------------------------------------------------------
//
TInt TSockAddr::GetUserLen()
{
return Length()-Align4(sizeof(SSockAddr));
}
EXPORT_C void TBtreeInlineLeafOrg::SetEntrySize(TInt aSize)
{
__ASSERT_DEBUG(aSize<=KMaxBtreeKeyLength,Panic(EBadEntrySize));
iEntrySize=Align4(aSize);
iMaxEntries=(KPoolPageSize-sizeof(SHeader))/iEntrySize;
}
EXPORT_C TInt TRawEntryArray::EntrySize(TInt aIdx)
{ return Align4(::EntrySize((*this)[aIdx])); }
// -----------------------------------------------------------------------------
// TSockAddr::SetUserLen
// -----------------------------------------------------------------------------
//
void TSockAddr::SetUserLen(TInt aLen)
{
SetLength(aLen+Align4(sizeof(SSockAddr)));
}
void CServerCrashDataSource::GetCodeSegmentsL( const TUint64 aTid, RCodeSegPointerList &aCodeSegList, TUint & aTotalCodeSegListDescSize )
{
LOG_MSG2("->CServerCrashDataSource::GetCodeSegmentsL(aTid=%Lu)\n", aTid );
aCodeSegList.ResetAndDestroy();
aTotalCodeSegListDescSize = 0;
TUint32 size = KMaxFileName;
RBuf8 buffer;
buffer.CreateL(KMaxFileName);
CleanupClosePushL(buffer);
DoGetListL( ECodeSegs, aTid, (TUint)-1, buffer, size );
LOG_MSG2( " DoGetListL( ECodeSegs ) returned buffer.Size()=0x%X\n", buffer.Size() );
TUint8* ptr = (TUint8*)buffer.Ptr();
const TUint8* ptrEnd = ptr + size;
while(ptr < ptrEnd)
{
TCodeSegListEntry* entry = (TCodeSegListEntry*)ptr;
LOG_MSG4( " entry->CodeBase=0x%X, CodeSize=0x%X, ConstDataSize=0x%X\n",
entry->iCodeBase, entry->iCodeSize, entry->iConstDataSize );
LOG_MSG4( " InitDataBase=0x%X, InitDataSize=0x%X, UnintDataSize=0x%X\n",
entry->iInitialisedDataBase, entry->iInitialisedDataSize, entry->iUninitialisedDataSize );
LOG_MSG3( " IsXip=0x%X, CodeSegType=0x%X\n", entry->iIsXip, entry->iCodeSegType );
TCodeSegInfo *codeSeg = new(ELeave) TCodeSegInfo;
TPtr name(&(entry->iName[0]), entry->iNameLength, entry->iNameLength);
codeSeg->iName = name;
codeSeg->iType = entry->iCodeSegType;
codeSeg->iXIP = entry->iIsXip;
codeSeg->iCodeSize = entry->iCodeSize;
codeSeg->iCodeRunAddr = entry->iCodeBase;
if( codeSeg->iXIP )
{
codeSeg->iCodeLoadAddr = codeSeg->iCodeRunAddr;
}
else
{
codeSeg->iCodeLoadAddr = 0; //TODO
}
codeSeg->iRoDataSize = entry->iConstDataSize;
codeSeg->iRoDataRunAddr = entry->iCodeBase + entry->iCodeSize;
if( codeSeg->iXIP )
{
codeSeg->iRoDataLoadAddr = codeSeg->iRoDataRunAddr;
}
else
{
codeSeg->iRoDataLoadAddr = 0; //TODO
}
codeSeg->iDataSize = entry->iInitialisedDataSize + entry->iUninitialisedDataSize;
codeSeg->iDataRunAddr = entry->iInitialisedDataBase;
if( codeSeg->iXIP )
{
codeSeg->iDataLoadAddr = codeSeg->iDataRunAddr;
}
else
{
codeSeg->iDataLoadAddr = 0; //TODO
}
TInt err = aCodeSegList.Append(codeSeg);
if(err != KErrNone)
{
delete codeSeg;
User::Leave(err);
}
aTotalCodeSegListDescSize += sizeof(TCodeSegInfo);
ptr += Align4(entry->GetSize());
}
CleanupStack::PopAndDestroy(&buffer);
}
/** Obtain the thread list. If aProcessId is negative, we obtain the entire system
thread list. If aProcessId is positive we get the thread list for that process */
void CServerCrashDataSource::GetThreadListL( const TUint64 aProcessId,
RThreadPointerList & aThreadList,
TUint & aTotalThreadListDescSize )
{
LOG_MSG2( "->CServerCrashDataSource::GetThreadListL(aProcessId=%Lu)\n", aProcessId);
// Delete any objects in the array, since we will replace them.
aThreadList.ResetAndDestroy();
aTotalThreadListDescSize = 0;
if( iThreadListBuffer.Size() != iLastThreadListSize )
{
LOG_MSG2("CServerCrashDataSource::GetThreadListL -> iThreadListBuffer.ReAlloc(%d)\n", iLastThreadListSize );
iThreadListBuffer.ReAllocL( iLastThreadListSize );
}
LOG_MSG( "CServerCrashDataSource::GetThreadListL -> DoGetListL()\n" );
DoGetListL( EThreads, (TUint)-1, aProcessId, iThreadListBuffer, iLastThreadListSize );
iLastThreadListSize = iThreadListBuffer.Size();
CThreadInfo * threadInfoPtr;
RThread thread;
TThreadStackInfo stackInfo;
TThreadListEntry * entry;
TUint usrStackSize;
TLinAddr usrStackAddr;
TLinAddr svcStackPtr;
TLinAddr svcStackBase;
TUint svcStackSize;
TUint priority;
TUint8* ptr = (TUint8*)( iThreadListBuffer.Ptr() );
const TUint8* ptrEnd = ptr + iLastThreadListSize;
//LOG_MSG3( " Data start,end=(0x%x, 0x%x)\n", ptr, ptrEnd );
while( ptr < ptrEnd )
{
entry = (TThreadListEntry*)ptr;
if( !entry )
{
LOG_MSG( " ERROR !* : TThreadListEntry is NULL\n" );
User::Leave(KErrBadHandle);
}
if( entry->iNameLength == 0 )
{
LOG_MSG4( " Skipping Thread 0x%X%X : entry->iNameLength=%d",
I64HIGH(entry->iThreadId), I64LOW(entry->iThreadId), entry->iNameLength );
ptr += Align4( entry->GetSize() );
continue;
}
//LOG_MSG3( " entry &=0x%X, size=%d\n", &(entry->iThreadId), entry->GetSize() );
//LOG_MSG3( " entry->iThreadId= 0x%X%X\n", I64HIGH(entry->iThreadId), I64LOW(entry->iThreadId) );
//LOG_MSG3( " found tid=%d, pid=%d\n", I64LOW(entry->iThreadId), I64LOW(entry->iProcessId) );
if( entry->iSupervisorStackPtrValid )
{
svcStackPtr = entry->iSupervisorStackPtr;
}
else
{
svcStackPtr = 0;
}
if( entry->iSupervisorStackBaseValid )
{
svcStackBase = entry->iSupervisorStackBase;
}
else
{
svcStackBase = 0;
}
if( entry->iSupervisorStackSizeValid )
{
svcStackSize = entry->iSupervisorStackSize;
}
else
{
svcStackSize = 0;
}
if( KErrNone == thread.Open( entry->iThreadId ) )
{
priority = (TUint)(thread.Priority());
if( KErrNone == thread.StackInfo( stackInfo ) )
{
usrStackAddr = stackInfo.iLimit;
usrStackSize = stackInfo.iBase - stackInfo.iLimit;
}
else
{
usrStackSize = 0;
usrStackAddr = 0;
}
thread.Close();
}
else
{
usrStackSize = 0;
usrStackAddr = 0;
priority = 0;
}
/*
LOG_MSG3( " entry->iNameLength=%d, &(entry->iName[0])=0x%X\n",
entry->iNameLength, &(entry->iName[0]) );
*/
TPtrC entryName( &(entry->iName[0]), entry->iNameLength );
//LOG_MSG2( " -> threadInfoPtr = CThreadInfo::NewL( name.Size()=%d)\n", entryName.Size() );
threadInfoPtr = CThreadInfo::NewL(
entry->iThreadId,
entryName,
entry->iProcessId,
(TUint)priority,
svcStackPtr,
svcStackBase,
svcStackSize,
usrStackAddr,
usrStackSize );
/*
LOG_MSG3( " threadInfoPtr->iSvcStackAddr=0x%X, threadInfoPtr->iSvcStackSize=0x%X\n",
threadInfoPtr->SvcStackAddr(), threadInfoPtr->SvcStackSize() );
*/
TInt err = aThreadList.Append( threadInfoPtr );
if( err != KErrNone )
{
// We use this id so as not to use Push(), AppendL(), Pop()
delete threadInfoPtr;
User::Leave( err );
}
aTotalThreadListDescSize += threadInfoPtr->Size();
/*
LOG_MSG3( " aTotalThreadListDescSize = %d after adding %d\n",
aTotalThreadListDescSize, threadInfoPtr->Size() );
RBuf rPrintBuf;
rPrintBuf.Create( threadInfoPtr->Name());
RDebug::Printf( " <- rPrintBuf.Create(), rPrintBuf.Length()=%d\n", rPrintBuf.Length() );
char* cl = (char*) rPrintBuf.Collapse().PtrZ();
RDebug::Printf(" name=%s\n", cl );
rPrintBuf.Close();
*/
ptr += Align4( entry->GetSize() );
//LOG_MSG2( " ptr += Align4(entry->GetSize()) = 0x%X\n", ptr );
} // while
}
void CServerCrashDataSource::GetProcessListL( RProcessPointerList & aProcessList,
TUint & aTotalProcessListDescSize )
{
//LOG_MSG( "CServerCrashDataSource::GetProcessListL()\n" );
// Delete any objects in the array, since we will replace them.
aProcessList.ResetAndDestroy();
aTotalProcessListDescSize = 0;
if( iProcListBuffer.Size() != iLastProcListSize )
{
LOG_MSG2( " iProcListBuffer.ReAlloc( %d)\n", iLastProcListSize );
iProcListBuffer.ReAllocL( iLastProcListSize );
}
DoGetListL( EProcesses, (TUint)(-1), (TUint)(-1), iProcListBuffer, iLastProcListSize );
iLastProcListSize = iProcListBuffer.Size();
TUint8* ptr = (TUint8*)( iProcListBuffer.Ptr() );
const TUint8* ptrEnd = ptr + iLastProcListSize;
//LOG_MSG3( " Data start,end=(0x%x, 0x%x)\n", ptr, ptrEnd );
while( ptr < ptrEnd )
{
TProcessListEntry *entry = (TProcessListEntry*)ptr;
if( !entry )
{
LOG_MSG( " ERROR !* : TProcessListEntry is NULL\n" );
User::Leave(KErrBadHandle);
}
TUint64 id = entry->iProcessId;
if( entry->iFileNameLength == 0 )
{
LOG_MSG4( " Skipping process 0x%X%X : entry->iFileNameLength=%d",
I64HIGH(entry->iProcessId), I64LOW(entry->iProcessId), entry->iFileNameLength );
ptr += Align4( entry->GetSize() );
continue;
}
/*
LOG_MSG4( " process 0x%X%X has iFileNameLength=%d",
I64HIGH(entry->iProcessId), I64LOW(entry->iProcessId), entry->iFileNameLength );
*/
TPtrC entryName(&(entry->iNames[0]), entry->iFileNameLength);
CProcessInfo *procInfoPtr = CProcessInfo::NewL(id, entryName );
TInt err = aProcessList.Append( procInfoPtr );
if(err != KErrNone)
{
delete procInfoPtr;
User::Leave(err);
}
aTotalProcessListDescSize += procInfoPtr->Size();
ptr += Align4( entry->GetSize() );
}
}
EXPORT_C void TBtreeInlineIndexOrg::SetEntrySize(TInt aSize)
{
__ASSERT_DEBUG(aSize<=KMaxBtreeKeyLength,Panic(EBadEntrySize));
iEntrySize=_FOFF(SEntry,iKey[Align4(aSize)]);
iMaxEntries=(KPoolPageSize-sizeof(SHeader)-sizeof(TPageRef))/iEntrySize;
}
