author | Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com> |
Fri, 11 Jun 2010 15:02:23 +0300 | |
changeset 152 | 657f875b013e |
parent 109 | b3a1d9898418 |
child 201 | 43365a9b78a3 |
permissions | -rw-r--r-- |
0 | 1 |
// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies). |
2 |
// All rights reserved. |
|
3 |
// This component and the accompanying materials are made available |
|
4 |
// under the terms of the License "Eclipse Public License v1.0" |
|
5 |
// which accompanies this distribution, and is available |
|
6 |
// at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 |
// |
|
8 |
// Initial Contributors: |
|
9 |
// Nokia Corporation - initial contribution. |
|
10 |
// |
|
11 |
// Contributors: |
|
12 |
// |
|
13 |
// Description: |
|
14 |
// |
|
15 |
||
16 |
#include <plat_priv.h> |
|
17 |
#include "cache_maintenance.h" |
|
18 |
#include "mm.h" |
|
19 |
#include "mmu.h" |
|
20 |
#include "mmanager.h" |
|
21 |
#include "mobject.h" |
|
22 |
#include "mpager.h" |
|
23 |
#include "mcodepaging.h" |
|
24 |
||
25 |
/** |
|
26 |
Manager for memory objects containing demand paged executable code. |
|
27 |
This is the memory used by DCodeSegMemory object to store the contents of RAM loaded |
|
28 |
EXEs and DLLs which are to be demand paged. |
|
29 |
||
30 |
This memory has associated information, supplied by the Loader, which enables |
|
31 |
the executable's code to be located in the file system and its contents |
|
32 |
relocated and fixed-up when demand loaded. |
|
33 |
||
34 |
@see DPagedCodeInfo |
|
35 |
@see MM::PagedCodeNew |
|
36 |
*/ |
|
37 |
class DCodePagedMemoryManager : public DPagedMemoryManager |
|
38 |
{ |
|
39 |
private: |
|
40 |
// from DMemoryManager... |
|
41 |
virtual TInt New(DMemoryObject*& aMemory, TUint aSizeInPages, TMemoryAttributes aAttributes, TMemoryCreateFlags aCreateFlags); |
|
42 |
virtual void Destruct(DMemoryObject* aMemory); |
|
43 |
virtual void Free(DMemoryObject* aMemory, TUint aIndex, TUint aCount); |
|
44 |
virtual TInt CleanPage(DMemoryObject* aMemory, SPageInfo* aPageInfo, TPhysAddr*& aPageArrayEntry); |
|
45 |
||
46 |
// from DPagedMemoryManager... |
|
47 |
virtual void Init3(); |
|
48 |
virtual TInt InstallPagingDevice(DPagingDevice* aDevice); |
|
49 |
virtual TInt AcquirePageReadRequest(DPageReadRequest*& aRequest, DMemoryObject* aMemory, TUint aIndex, TUint aCount); |
|
50 |
virtual TInt ReadPages(DMemoryObject* aMemory, TUint aIndex, TUint aCount, TPhysAddr* aPages, DPageReadRequest* aRequest); |
|
51 |
virtual TBool IsAllocated(DMemoryObject* aMemory, TUint aIndex, TUint aCount); |
|
52 |
||
53 |
private: |
|
54 |
/** |
|
55 |
Array of paging devices used for each media drive. |
|
56 |
This is a initialised by #InstallPagingDevice. |
|
57 |
Drives without paging devices have the null pointer in their entry. |
|
58 |
*/ |
|
59 |
DPagingDevice* iDevice[KMaxLocalDrives]; |
|
60 |
||
61 |
public: |
|
62 |
/** |
|
63 |
The single instance of this manager class. |
|
64 |
*/ |
|
65 |
static DCodePagedMemoryManager TheManager; |
|
66 |
||
102
ef2a444a7410
Revision: 201018
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
90
diff
changeset
|
67 |
friend DPagingDevice* CodePagingDevice(TInt aDriveNum); |
0 | 68 |
}; |
69 |
||
70 |
||
71 |
/** |
|
72 |
Reference counted object containing a #TPagedCodeInfo. |
|
73 |
This is a structure containing the information about a demand paged code segment |
|
74 |
which is required to load and fixup its code section. |
|
75 |
||
76 |
An instance of this object is created for each memory object being managed by |
|
77 |
#DCodePagedMemoryManager, and a pointer to it is stored in the memory object's |
|
78 |
DMemoryObject::iManagerData member. |
|
79 |
||
80 |
@see TPagedCodeInfo |
|
81 |
@see MM::PagedCodeLoaded |
|
82 |
*/ |
|
83 |
class DPagedCodeInfo : public DReferenceCountedObject |
|
84 |
{ |
|
85 |
public: |
|
86 |
/** |
|
87 |
Return a reference to the embedded #TPagedCodeInfo. |
|
88 |
*/ |
|
89 |
inline TPagedCodeInfo& Info() |
|
90 |
{ return iInfo; } |
|
91 |
private: |
|
92 |
/** |
|
93 |
@copybrief TPagedCodeInfo |
|
94 |
*/ |
|
95 |
TPagedCodeInfo iInfo; |
|
96 |
}; |
|
97 |
||
98 |
||
99 |
DCodePagedMemoryManager DCodePagedMemoryManager::TheManager; |
|
100 |
DPagedMemoryManager* TheCodePagedMemoryManager = &DCodePagedMemoryManager::TheManager; |
|
101 |
||
102 |
||
103 |
DPagingDevice* CodePagingDevice(TInt aDriveNum) |
|
104 |
{ |
|
105 |
__NK_ASSERT_DEBUG(aDriveNum<KMaxLocalDrives); |
|
106 |
return DCodePagedMemoryManager::TheManager.iDevice[aDriveNum]; |
|
107 |
} |
|
108 |
||
109 |
||
110 |
void DCodePagedMemoryManager::Init3() |
|
111 |
{ |
|
112 |
TRACEB(("DCodePagedMemoryManager::Init3()")); |
|
113 |
} |
|
114 |
||
115 |
||
116 |
TInt DCodePagedMemoryManager::InstallPagingDevice(DPagingDevice* aDevice) |
|
117 |
{ |
|
118 |
TRACEB(("DCodePagedMemoryManager::InstallPagingDevice(0x%08x)",aDevice)); |
|
119 |
||
120 |
TUint codePolicy = TheSuperPage().KernelConfigFlags() & EKernelConfigCodePagingPolicyMask; |
|
121 |
TRACEB(("Code Paging Policy = %d", codePolicy >> EKernelConfigCodePagingPolicyShift)); |
|
122 |
if(codePolicy == EKernelConfigCodePagingPolicyNoPaging) |
|
123 |
{ |
|
124 |
// no paging allowed so end now... |
|
125 |
return KErrNone; |
|
126 |
} |
|
127 |
||
128 |
TInt i; |
|
129 |
for(i=0; i<KMaxLocalDrives; ++i) |
|
130 |
if(aDevice->iDrivesSupported&(1<<i)) |
|
131 |
{ |
|
132 |
TRACEB(("DCodePagedMemoryManager::InstallPagingDevice drive=%d",i)); |
|
133 |
TAny* null = 0; |
|
109
b3a1d9898418
Revision: 201019
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
102
diff
changeset
|
134 |
if(aDevice->iType & DPagingDevice::EMediaExtension) |
b3a1d9898418
Revision: 201019
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
102
diff
changeset
|
135 |
__e32_atomic_store_ord_ptr(&iDevice[i], null); |
0 | 136 |
if(!__e32_atomic_cas_ord_ptr(&iDevice[i], &null, aDevice)) // set iDevice[i]=aDevice if it was originally 0 |
137 |
{ |
|
138 |
// paging device already registered... |
|
139 |
TRACEB(("DCodePagedMemoryManager::InstallPagingDevice returns ALREADY EXISTS!")); |
|
140 |
return KErrAlreadyExists; |
|
141 |
} |
|
142 |
// flag code paging is supported... |
|
143 |
__e32_atomic_ior_ord32(&K::MemModelAttributes, (TUint32)EMemModelAttrCodePaging); |
|
144 |
} |
|
145 |
||
146 |
return KErrNone; |
|
147 |
} |
|
148 |
||
149 |
||
150 |
TInt DCodePagedMemoryManager::AcquirePageReadRequest(DPageReadRequest*& aRequest, DMemoryObject* aMemory, TUint aIndex, TUint aCount) |
|
151 |
{ |
|
152 |
DPagingDevice* device = 0; |
|
153 |
MmuLock::Lock(); |
|
154 |
DPagedCodeInfo* pagedCodeInfo = (DPagedCodeInfo*)aMemory->iManagerData; |
|
155 |
if(pagedCodeInfo) |
|
156 |
{ |
|
157 |
TPagedCodeInfo& info = pagedCodeInfo->Info(); |
|
158 |
device = iDevice[info.iCodeLocalDrive]; |
|
159 |
} |
|
160 |
MmuLock::Unlock(); |
|
161 |
||
162 |
if(!device) |
|
163 |
{ |
|
164 |
aRequest = 0; |
|
165 |
return KErrNotFound; |
|
166 |
} |
|
167 |
||
168 |
aRequest = device->iRequestPool->AcquirePageReadRequest(aMemory,aIndex,aCount); |
|
169 |
return KErrNone; |
|
170 |
} |
|
171 |
||
172 |
||
173 |
TInt DCodePagedMemoryManager::New(DMemoryObject*& aMemory, TUint aSizeInPages, TMemoryAttributes aAttributes, TMemoryCreateFlags aCreateFlags) |
|
174 |
{ |
|
175 |
DPagedCodeInfo* pagedCodeInfo = new DPagedCodeInfo; |
|
176 |
if(!pagedCodeInfo) |
|
177 |
return KErrNoMemory; |
|
178 |
||
179 |
TInt r = DPagedMemoryManager::New(aMemory, aSizeInPages, aAttributes, aCreateFlags); |
|
180 |
if(r!=KErrNone) |
|
181 |
pagedCodeInfo->Close(); |
|
182 |
else |
|
183 |
aMemory->iManagerData = pagedCodeInfo; |
|
184 |
||
185 |
return r; |
|
186 |
} |
|
187 |
||
188 |
||
189 |
void DCodePagedMemoryManager::Destruct(DMemoryObject* aMemory) |
|
190 |
{ |
|
191 |
MmuLock::Lock(); |
|
192 |
DPagedCodeInfo* pagedCodeInfo = (DPagedCodeInfo*)aMemory->iManagerData; |
|
193 |
aMemory->iManagerData = 0; |
|
194 |
MmuLock::Unlock(); |
|
195 |
||
196 |
if(pagedCodeInfo) |
|
197 |
pagedCodeInfo->Close(); |
|
198 |
||
199 |
// base call to free memory and close object... |
|
200 |
DPagedMemoryManager::Destruct(aMemory); |
|
201 |
} |
|
202 |
||
203 |
||
204 |
void DCodePagedMemoryManager::Free(DMemoryObject* aMemory, TUint aIndex, TUint aCount) |
|
205 |
{ |
|
206 |
DoFree(aMemory,aIndex,aCount); |
|
207 |
} |
|
208 |
||
209 |
||
210 |
TInt DCodePagedMemoryManager::CleanPage(DMemoryObject* aMemory, SPageInfo* aPageInfo, TPhysAddr*& aPageArrayEntry) |
|
211 |
{ |
|
102
ef2a444a7410
Revision: 201018
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
90
diff
changeset
|
212 |
if(!aPageInfo->IsDirty()) |
0 | 213 |
return KErrNone; |
214 |
||
215 |
// shouldn't be asked to clean a page which is writable... |
|
102
ef2a444a7410
Revision: 201018
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
90
diff
changeset
|
216 |
__NK_ASSERT_DEBUG(!aPageInfo->IsWritable()); |
0 | 217 |
|
218 |
// Note, memory may have been modified by the CodeModifier class. |
|
219 |
||
220 |
// just mark page as clean as we don't try and preserve code modifications... |
|
221 |
ThePager.SetClean(*aPageInfo); |
|
222 |
||
223 |
return KErrNone; |
|
224 |
} |
|
225 |
||
226 |
||
227 |
TInt ReadFunc(TAny* aArg1, TAny* aArg2, TLinAddr aBuffer, TInt aBlockNumber, TInt aBlockCount) |
|
228 |
{ |
|
229 |
START_PAGING_BENCHMARK; |
|
230 |
TInt drive = (TInt)aArg1; |
|
231 |
TThreadMessage* msg = (TThreadMessage*)aArg2; |
|
232 |
DPagingDevice* device = CodePagingDevice(drive); |
|
233 |
TInt r = device->Read(msg, aBuffer, aBlockNumber, aBlockCount, drive); |
|
234 |
__NK_ASSERT_DEBUG(r!=KErrNoMemory); // not allowed to allocated memory, therefore can't fail with KErrNoMemory |
|
235 |
END_PAGING_BENCHMARK(EPagingBmReadMedia); |
|
236 |
return r; |
|
237 |
} |
|
238 |
||
239 |
||
240 |
TInt DCodePagedMemoryManager::ReadPages(DMemoryObject* aMemory, TUint aIndex, TUint aCount, TPhysAddr* aPages, DPageReadRequest* aRequest) |
|
241 |
{ |
|
242 |
TRACE2(("DCodePagedMemoryManager::ReadPage(0x%08x,0x%08x,0x%08x,?,?)",aMemory,aIndex,aCount)); |
|
243 |
||
90
947f0dc9f7a8
Revision: 201015
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
244 |
__NK_ASSERT_DEBUG(aRequest->CheckUseContiguous(aMemory,aIndex,aCount)); |
947f0dc9f7a8
Revision: 201015
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
245 |
__ASSERT_CRITICAL; |
0 | 246 |
|
247 |
START_PAGING_BENCHMARK; |
|
248 |
||
249 |
MmuLock::Lock(); |
|
250 |
DPagedCodeInfo* pagedCodeInfo = (DPagedCodeInfo*)aMemory->iManagerData; |
|
251 |
if(pagedCodeInfo) |
|
252 |
pagedCodeInfo->Open(); |
|
253 |
MmuLock::Unlock(); |
|
254 |
if(!pagedCodeInfo) |
|
255 |
return KErrNotFound; |
|
256 |
||
257 |
TPagedCodeInfo& info = pagedCodeInfo->Info(); |
|
258 |
DPagingDevice& device = *iDevice[info.iCodeLocalDrive]; |
|
259 |
||
260 |
TLinAddr linAddr = aRequest->MapPages(aIndex,aCount,aPages); |
|
261 |
TInt r = KErrNone; |
|
90
947f0dc9f7a8
Revision: 201015
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
262 |
TThreadMessage message; |
0 | 263 |
|
264 |
if(!info.iCodeSize) |
|
265 |
{ |
|
266 |
// no blockmap yet, use blank pages... |
|
267 |
memset((TAny*)linAddr, aCount*KPageSize, 0x03); |
|
268 |
CacheMaintenance::CodeChanged(linAddr, aCount*KPageSize); |
|
269 |
goto done; |
|
270 |
} |
|
271 |
||
272 |
for(; aCount; ++aIndex, --aCount, linAddr+=KPageSize) |
|
273 |
{ |
|
274 |
// work out which bit of the file to read |
|
275 |
TInt codeOffset = aIndex<<KPageShift; |
|
276 |
TInt dataOffset; |
|
277 |
TInt dataSize; |
|
278 |
TInt decompressedSize = Min(KPageSize, info.iCodeSize-codeOffset); |
|
279 |
if(info.iCompressionType) |
|
280 |
{ |
|
281 |
dataOffset = info.iCodePageOffsets[aIndex]; |
|
282 |
dataSize = info.iCodePageOffsets[aIndex+1] - dataOffset; |
|
283 |
__KTRACE_OPT(KPAGING,Kern::Printf(" compressed, file offset == %x, size == %d", dataOffset, dataSize)); |
|
284 |
} |
|
285 |
else |
|
286 |
{ |
|
287 |
dataOffset = codeOffset + info.iCodeStartInFile; |
|
288 |
dataSize = Min(KPageSize, info.iBlockMap.DataLength()-dataOffset); |
|
289 |
__NK_ASSERT_DEBUG(dataSize==decompressedSize); |
|
290 |
__KTRACE_OPT(KPAGING,Kern::Printf(" uncompressed, file offset == %x, size == %d", dataOffset, dataSize)); |
|
291 |
} |
|
292 |
||
293 |
TInt bufferStart = info.iBlockMap.Read(aRequest->iBuffer, |
|
294 |
dataOffset, |
|
295 |
dataSize, |
|
296 |
device.iReadUnitShift, |
|
297 |
ReadFunc, |
|
298 |
(TAny*)info.iCodeLocalDrive, |
|
90
947f0dc9f7a8
Revision: 201015
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
299 |
(TAny*)&message); |
0 | 300 |
|
301 |
if(bufferStart<0) |
|
302 |
{ |
|
303 |
r = bufferStart; // return error |
|
304 |
__NK_ASSERT_DEBUG(0); |
|
305 |
break; |
|
306 |
} |
|
307 |
||
308 |
TLinAddr data = aRequest->iBuffer + bufferStart; |
|
309 |
r = Decompress(info.iCompressionType, linAddr, decompressedSize, data, dataSize); |
|
310 |
if(r>=0) |
|
311 |
{ |
|
312 |
if(r!=decompressedSize) |
|
313 |
{ |
|
314 |
__KTRACE_OPT(KPANIC, Kern::Printf("DCodePagedMemoryManager::ReadPage: error decompressing page at %08x + %x: %d", dataOffset, dataSize, r)); |
|
315 |
__NK_ASSERT_DEBUG(0); |
|
316 |
r = KErrCorrupt; |
|
317 |
} |
|
318 |
else |
|
319 |
r = KErrNone; |
|
320 |
} |
|
321 |
else |
|
322 |
{ |
|
323 |
__NK_ASSERT_DEBUG(0); |
|
324 |
} |
|
325 |
||
326 |
if(r!=KErrNone) |
|
327 |
break; |
|
328 |
||
329 |
if(decompressedSize<KPageSize) |
|
330 |
memset((TAny*)(linAddr+decompressedSize), KPageSize-decompressedSize, 0x03); |
|
331 |
if(info.iLoaded) |
|
332 |
info.ApplyFixups(linAddr, aIndex); |
|
333 |
} |
|
334 |
done: |
|
335 |
aRequest->UnmapPages(true); |
|
336 |
||
337 |
pagedCodeInfo->AsyncClose(); |
|
338 |
||
90
947f0dc9f7a8
Revision: 201015
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
339 |
END_PAGING_BENCHMARK_N(EPagingBmReadCodePage, aCount); |
0 | 340 |
return r; |
341 |
} |
|
342 |
||
343 |
||
344 |
TBool DCodePagedMemoryManager::IsAllocated(DMemoryObject* aMemory, TUint aIndex, TUint aCount) |
|
345 |
{ |
|
346 |
// all pages allocated if memory not destroyed (iManagerData!=0)... |
|
347 |
return aMemory->iManagerData!=0; |
|
348 |
} |
|
349 |
||
350 |
||
351 |
TInt MM::PagedCodeNew(DMemoryObject*& aMemory, TUint aPageCount, TPagedCodeInfo*& aInfo) |
|
352 |
{ |
|
353 |
TRACE(("MM::PagedCodeNew(?,0x%08x,0x%08x)",aPageCount,aInfo)); |
|
354 |
TMemoryCreateFlags createFlags = (TMemoryCreateFlags)(EMemoryCreateNoWipe | EMemoryCreateAllowExecution); |
|
355 |
TInt r = TheCodePagedMemoryManager->New(aMemory,aPageCount,EMemoryAttributeStandard,createFlags); |
|
356 |
if(r==KErrNone) |
|
357 |
aInfo = &((DPagedCodeInfo*)aMemory->iManagerData)->Info(); |
|
358 |
TRACE(("MM::PagedCodeNew returns %d, aMemory=0x%08x",r,aMemory)); |
|
359 |
return r; |
|
360 |
} |
|
361 |
||
362 |
||
363 |
void MM::PagedCodeLoaded(DMemoryObject* aMemory, TLinAddr aLoadAddress) |
|
364 |
{ |
|
365 |
TRACE(("MM::PagedCodeLoaded(0x%08x,0x%08x)",aMemory,aLoadAddress)); |
|
366 |
||
367 |
TPagedCodeInfo& info = ((DPagedCodeInfo*)aMemory->iManagerData)->Info(); |
|
368 |
||
369 |
// we need to apply fixups for all memory already paged in. |
|
370 |
// Note, if this memory is subsequently discarded it should not be paged-in again |
|
371 |
// until after this function has completed, because the Loader won't touch the memory |
|
372 |
// and it has not yet been mapped into any other process. |
|
373 |
||
374 |
// make iterator for memory... |
|
375 |
RPageArray::TIter pageIter; |
|
376 |
aMemory->iPages.FindStart(0,aMemory->iSizeInPages,pageIter); |
|
377 |
||
378 |
for(;;) |
|
379 |
{ |
|
380 |
// find some pages... |
|
381 |
RPageArray::TIter pageList; |
|
382 |
TUint n = pageIter.Find(pageList); |
|
383 |
if(!n) |
|
384 |
break; |
|
385 |
||
386 |
// fix up each page found... |
|
387 |
UNLOCK_USER_MEMORY(); |
|
388 |
do |
|
389 |
{ |
|
390 |
TUint i = pageList.Index(); |
|
391 |
TLinAddr a = aLoadAddress+i*KPageSize; |
|
392 |
info.ApplyFixups(a,i); |
|
393 |
CacheMaintenance::CodeChanged(a, KPageSize); |
|
394 |
// now we've finished updating the page, mark it as read only and |
|
395 |
// clean as we don't need to save changes if it is stolen. |
|
396 |
MmuLock::Lock(); |
|
397 |
TPhysAddr* pages; |
|
398 |
if(pageList.Pages(pages,1)==1) |
|
399 |
if(RPageArray::IsPresent(*pages)) |
|
400 |
{// The loader page still has a writable mapping but it won't |
|
401 |
// touch the page again so this is safe. No use restricting the |
|
402 |
// page to be read only as if the loader did write to it again |
|
403 |
// it would just be rejuvenated as writeable and made dirty. |
|
404 |
SPageInfo& pageInfo = *SPageInfo::FromPhysAddr(*pages); |
|
405 |
pageInfo.SetReadOnly(); |
|
406 |
ThePager.SetClean(pageInfo); |
|
407 |
} |
|
408 |
MmuLock::Unlock(); |
|
409 |
||
410 |
pageList.Skip(1); |
|
411 |
} |
|
412 |
while(pageList.Count()); |
|
413 |
LOCK_USER_MEMORY(); |
|
414 |
||
415 |
// move on... |
|
416 |
pageIter.FindRelease(n); |
|
417 |
} |
|
418 |
||
419 |
// done... |
|
420 |
aMemory->iPages.FindEnd(0,aMemory->iSizeInPages); |
|
421 |
info.iLoaded = true; // allow ReadPage to start applying fixups when handling page faults |
|
422 |
} |