author | Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com> |
Mon, 18 Jan 2010 21:31:10 +0200 | |
changeset 36 | 538db54a451d |
parent 33 | 0173bcd7697c |
child 39 | 5d2844f35677 |
permissions | -rw-r--r-- |
0 | 1 |
// Copyright (c) 1994-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 |
// e32\include\kernel\kernel.h |
|
15 |
// Public header for device drivers |
|
16 |
// |
|
17 |
// WARNING: This file contains some APIs which are internal and are subject |
|
18 |
// to change without notice. Such APIs should therefore not be used |
|
19 |
// outside the Kernel and Hardware Services package. |
|
20 |
// |
|
21 |
||
22 |
||
23 |
#ifndef __K32STD_H__ |
|
24 |
#define __K32STD_H__ |
|
25 |
||
26 |
#include <kernel/klib.h> |
|
27 |
#include <e32kpan.h> |
|
28 |
#include <u32std.h> |
|
29 |
#include <e32ldr.h> |
|
33
0173bcd7697c
Revision: 201001
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
31
diff
changeset
|
30 |
#include <e32ldr_private.h> |
0 | 31 |
#include <e32event.h> |
32 |
#include <e32event_private.h> |
|
33 |
#include <d32locd.h> |
|
34 |
#include <kernel/localise.h> |
|
35 |
#include <nkern.h> |
|
36 |
#include <kernel/sproperty.h> |
|
37 |
||
38 |
class DObject; |
|
39 |
class DObjectCon; |
|
40 |
class DThread; |
|
41 |
class DCodeSeg; |
|
42 |
class DProcess; |
|
43 |
class DLibrary; |
|
44 |
class DMutex; |
|
45 |
class DSemaphore; |
|
46 |
class DChunk; |
|
47 |
class DShPool; |
|
48 |
class DShBuf; |
|
49 |
||
50 |
||
51 |
/** Data type for physical addresses |
|
52 |
@publishedPartner |
|
53 |
@released |
|
54 |
*/ |
|
55 |
typedef TUint32 TPhysAddr; |
|
56 |
||
57 |
||
58 |
/** |
|
59 |
A constant representing an invalid physical address. |
|
60 |
@publishedPartner |
|
61 |
@released |
|
62 |
*/ |
|
63 |
const TPhysAddr KPhysAddrInvalid=0xFFFFFFFFu; |
|
64 |
||
65 |
||
66 |
/** @internalComponent */ |
|
67 |
_LIT(KLitKernExec, "KERN-EXEC"); |
|
68 |
||
69 |
/******************************************** |
|
70 |
* HAL entry array |
|
71 |
********************************************/ |
|
72 |
||
73 |
/** @internalTechnology */ |
|
74 |
const TInt KMaxHalGroups=32; |
|
75 |
||
76 |
||
77 |
||
78 |
||
79 |
/** |
|
80 |
@publishedPartner |
|
81 |
@released |
|
82 |
||
83 |
Defines the signature for a HAL handler function. |
|
84 |
*/ |
|
85 |
typedef TInt (*THalFunc)(TAny*,TInt,TAny*,TAny*); |
|
86 |
||
87 |
/** @internalTechnology */ |
|
88 |
const TInt KMaxHalEntries=8; |
|
89 |
||
90 |
/** @internalTechnology */ |
|
91 |
struct SHalEntry |
|
92 |
{ |
|
93 |
THalFunc iFunction; |
|
94 |
TAny* iPtr; |
|
95 |
}; |
|
96 |
||
97 |
/** @internalTechnology */ |
|
98 |
struct SHalEntry2 : public SHalEntry |
|
99 |
{ |
|
100 |
SHalEntry* iExtendedEntries; |
|
101 |
}; |
|
102 |
||
103 |
/******************************************** |
|
104 |
* Exports from layer 1 of the kernel |
|
105 |
********************************************/ |
|
106 |
class TThreadMessage; |
|
107 |
class DObjectCon; |
|
108 |
class DPowerModel; |
|
109 |
class TSuperPage; |
|
110 |
class TMachineConfig; |
|
111 |
||
112 |
/******************************************** |
|
113 |
* Thread creation info block |
|
114 |
********************************************/ |
|
115 |
||
116 |
/** |
|
117 |
@publishedPartner |
|
118 |
@released |
|
119 |
||
120 |
Defines a set of thread types. |
|
121 |
*/ |
|
122 |
enum TThreadType |
|
123 |
{ |
|
124 |
/** The thread is the initial thread |
|
125 |
@internalComponent |
|
126 |
*/ |
|
127 |
EThreadInitial, |
|
128 |
||
129 |
/** The thread runs in supervisor mode */ |
|
130 |
EThreadSupervisor, |
|
131 |
||
132 |
/** The thread runs in supervisor mode and has no handles array */ |
|
133 |
EThreadMinimalSupervisor, |
|
134 |
||
135 |
/** The thread runs in user mode */ |
|
136 |
EThreadUser, |
|
137 |
||
138 |
/** The thread is the initial thread on a non-boot processor (SMP only) |
|
139 |
@internalComponent |
|
140 |
*/ |
|
141 |
EThreadAPInitial, |
|
142 |
}; |
|
143 |
||
144 |
/******************************************** |
|
145 |
* Kernel Mutex Ordering |
|
146 |
********************************************/ |
|
147 |
const TUint8 KMutexOrdNone = 0xff; /**< @internalComponent */ |
|
148 |
const TUint8 KMutexOrdUser = 0xfe; /**< @internalComponent */ |
|
149 |
||
150 |
/** |
|
151 |
Mutex order value for general purpose use. This value is higher than any used internally |
|
152 |
by the kernel, therefore there are no mutex ordering restrictions that limit which kernel |
|
153 |
functions may be called whilst a mutex of this order is held. |
|
154 |
@see Kern::MutexCreate() |
|
155 |
@publishedPartner |
|
156 |
@released |
|
157 |
*/ |
|
158 |
const TUint8 KMutexOrdGeneral7 = 0xf7; |
|
159 |
||
160 |
/** |
|
161 |
Mutex order value for general purpose use. This value is higher than any used internally |
|
162 |
by the kernel, therefore there are no mutex ordering restrictions that limit which kernel |
|
163 |
functions may be called whilst a mutex of this order is held. |
|
164 |
@see Kern::MutexCreate() |
|
165 |
@publishedPartner |
|
166 |
@released |
|
167 |
*/ |
|
168 |
const TUint8 KMutexOrdGeneral6 = 0xf6; |
|
169 |
||
170 |
/** |
|
171 |
Mutex order value for general purpose use. This value is higher than any used internally |
|
172 |
by the kernel, therefore there are no mutex ordering restrictions that limit which kernel |
|
173 |
functions may be called whilst a mutex of this order is held. |
|
174 |
@see Kern::MutexCreate() |
|
175 |
@publishedPartner |
|
176 |
@released |
|
177 |
*/ |
|
178 |
const TUint8 KMutexOrdGeneral5 = 0xf5; |
|
179 |
||
180 |
/** |
|
181 |
Mutex order value for general purpose use. This value is higher than any used internally |
|
182 |
by the kernel, therefore there are no mutex ordering restrictions that limit which kernel |
|
183 |
functions may be called whilst a mutex of this order is held. |
|
184 |
@see Kern::MutexCreate() |
|
185 |
@publishedPartner |
|
186 |
@released |
|
187 |
*/ |
|
188 |
const TUint8 KMutexOrdGeneral4 = 0xf4; |
|
189 |
||
190 |
/** |
|
191 |
Mutex order value for general purpose use. This value is higher than any used internally |
|
192 |
by the kernel, therefore there are no mutex ordering restrictions that limit which kernel |
|
193 |
functions may be called whilst a mutex of this order is held. |
|
194 |
@see Kern::MutexCreate() |
|
195 |
@publishedPartner |
|
196 |
@released |
|
197 |
*/ |
|
198 |
const TUint8 KMutexOrdGeneral3 = 0xf3; |
|
199 |
||
200 |
/** |
|
201 |
Mutex order value for general purpose use. This value is higher than any used internally |
|
202 |
by the kernel, therefore there are no mutex ordering restrictions that limit which kernel |
|
203 |
functions may be called whilst a mutex of this order is held. |
|
204 |
@see Kern::MutexCreate() |
|
205 |
@publishedPartner |
|
206 |
@released |
|
207 |
*/ |
|
208 |
const TUint8 KMutexOrdGeneral2 = 0xf2; |
|
209 |
||
210 |
/** |
|
211 |
Mutex order value for general purpose use. This value is higher than any used internally |
|
212 |
by the kernel, therefore there are no mutex ordering restrictions that limit which kernel |
|
213 |
functions may be called whilst a mutex of this order is held. |
|
214 |
@see Kern::MutexCreate() |
|
215 |
@publishedPartner |
|
216 |
@released |
|
217 |
*/ |
|
218 |
const TUint8 KMutexOrdGeneral1 = 0xf1; |
|
219 |
||
220 |
/** |
|
221 |
Mutex order value for general purpose use. This value is higher than any used internally |
|
222 |
by the kernel, therefore there are no mutex ordering restrictions that limit which kernel |
|
223 |
functions may be called whilst a mutex of this order is held. |
|
224 |
@see Kern::MutexCreate() |
|
225 |
@publishedPartner |
|
226 |
@released |
|
227 |
*/ |
|
228 |
const TUint8 KMutexOrdGeneral0 = 0xf0; |
|
229 |
||
230 |
||
231 |
const TUint8 KMutexOrdRamDrive = KMutexOrdGeneral7; /**< @internalComponent */ |
|
36
538db54a451d
Revision: 201003
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
33
diff
changeset
|
232 |
const TUint8 KMutexOrdDmaChannel = 0x70; /**< @internalComponent */ |
0 | 233 |
const TUint8 KMutexOrdShPool = 0x68; /**< @internalComponent */ |
234 |
const TUint8 KMutexOrdCodeSegLock = 0x60; /**< @internalComponent */ |
|
235 |
const TUint8 KMutexOrdPubSub2 = 0x5e; /**< @internalComponent */ |
|
236 |
||
237 |
/** |
|
238 |
@internalComponent |
|
239 |
@prototype |
|
240 |
*/ |
|
241 |
const TUint8 KMutexOrdPageIn = 0x5c; |
|
242 |
||
243 |
const TUint8 KMutexOrdRamDefrag = 0x59; /**< @internalComponent */ |
|
244 |
const TUint8 KMutexOrdPowerMgr = 0x58; /**< @internalComponent */ |
|
245 |
const TUint8 KMutexOrdPubSub = 0x50; /**< @internalComponent */ |
|
246 |
const TUint8 KMutexOrdProcessLock = 0x48; /**< @internalComponent */ |
|
247 |
const TUint8 KMutexOrdDebug = 0x47; /**< @internalComponent */ |
|
248 |
const TUint8 KMutexOrdTimer = 0x40; /**< @internalComponent */ |
|
249 |
const TUint8 KMutexOrdObjectCon2 = 0x38; /**< @internalComponent */ // servers |
|
250 |
const TUint8 KMutexOrdHandle = 0x30; /**< @internalComponent */ |
|
251 |
const TUint8 KMutexOrdObjectCon = 0x28; /**< @internalComponent */ |
|
252 |
const TUint8 KMutexOrdMachineConfig = 0x20; /**< @internalComponent */ |
|
253 |
const TUint8 KMutexOrdHwChunk = 0x10; /**< @internalComponent */ |
|
254 |
const TUint8 KMutexOrdKernelHeap = 0x08; /**< @internalComponent */ |
|
255 |
const TUint8 KMutexOrdRamAlloc = 0x04; /**< @internalComponent */ |
|
256 |
#if defined(__MEMMODEL_FLEXIBLE__) |
|
257 |
const TUint8 KMutexOrdSyncPhysMem = 0x03; /**< @internalComponent */ |
|
258 |
#endif |
|
259 |
const TUint8 KMutexOrdPageOut = 0x02; /**< @internalComponent */ |
|
260 |
const TUint8 KMutexOrdResourceManager = 0x01; /**< @internalComponent */ |
|
261 |
||
262 |
||
263 |
/******************************************** |
|
264 |
* Kernel Extension Priority Ordering |
|
265 |
********************************************/ |
|
266 |
||
267 |
/** |
|
268 |
@internalComponent |
|
269 |
@prototype 9.5 |
|
270 |
*/ |
|
271 |
const TUint8 KExtensionMaximumPriority = 0xff; |
|
272 |
||
273 |
/** |
|
274 |
@internalComponent |
|
275 |
@prototype 9.5 |
|
276 |
*/ |
|
277 |
const TUint8 KExtensionStandardPriority = 0; |
|
278 |
||
279 |
||
280 |
/** |
|
281 |
Defines a function type that implements a polling operation. |
|
282 |
||
283 |
A function of this type takes a single TAny* type argument, and returns |
|
284 |
a TBool type, and is passed as an argument to Kern::PollingWait(). |
|
285 |
||
286 |
@see Kern::PollingWait() |
|
287 |
||
288 |
@publishedPartner |
|
289 |
@released |
|
290 |
*/ |
|
291 |
typedef TBool (*TPollFunction)(TAny*); |
|
292 |
||
293 |
||
294 |
||
295 |
||
296 |
/** |
|
297 |
Structure used to specify parameters to Kern::ChunkCreate() |
|
298 |
@see Kern::ChunkCreate() |
|
299 |
@publishedPartner |
|
300 |
@released |
|
301 |
*/ |
|
302 |
class TChunkCreateInfo |
|
303 |
{ |
|
304 |
public: |
|
305 |
/** |
|
306 |
Enumeration representing the type of chunk to be created. |
|
307 |
*/ |
|
308 |
enum TType |
|
309 |
{ |
|
310 |
/** |
|
311 |
A chunk which may only be opened by one user side process at a time. |
|
312 |
Chunks of this type are slightly more efficient than the |
|
313 |
ESharedKernelMultiple type when used on the Moving Memory Model. |
|
314 |
*/ |
|
315 |
ESharedKernelSingle = 9, |
|
316 |
||
317 |
/** |
|
318 |
A chunk which may be opened by any number of user side processes. |
|
319 |
*/ |
|
320 |
ESharedKernelMultiple = 10, |
|
321 |
}; |
|
322 |
||
323 |
/** |
|
324 |
The chunk type to be created. |
|
325 |
@see TChunkCreateInfo::TType |
|
326 |
*/ |
|
327 |
TType iType; |
|
328 |
||
329 |
/** |
|
330 |
The size of linear address space to reserve for this chunk. |
|
331 |
*/ |
|
332 |
TInt iMaxSize; |
|
333 |
||
334 |
/** |
|
335 |
Caching attributes for the chunks memory. |
|
336 |
||
337 |
This is a value constructed from the TMappingAttributes values. |
|
338 |
E.g. EMapAttrFullyBlocking (no caching) or EMapAttrCachedMax (full caching). |
|
339 |
||
340 |
Note that if the MMU doesn't support the requested attributes then a lesser |
|
341 |
cached attribute will be used. The actual value used is returned in aMapAttr of |
|
342 |
Kern::ChunkCreate() |
|
343 |
||
344 |
@see TMappingAttributes |
|
345 |
*/ |
|
346 |
TUint32 iMapAttr; |
|
347 |
||
348 |
/** |
|
349 |
Set to true if the chunk is to own its committed memory. In which case all |
|
350 |
memory committed to the chunk will come from the system's free pool and will be |
|
351 |
returned there when the chunk is destroyed. |
|
352 |
*/ |
|
353 |
TUint8 iOwnsMemory; |
|
354 |
||
355 |
/** |
|
356 |
@internalComponent |
|
357 |
Reserved for future expansion. |
|
358 |
*/ |
|
359 |
TInt8 iSpare8[3]; |
|
360 |
||
361 |
/** |
|
362 |
Pointer to a DFC which will be queued on destruction of chunk. |
|
363 |
*/ |
|
364 |
TDfc* iDestroyedDfc; |
|
365 |
||
366 |
/** |
|
367 |
@internalComponent |
|
368 |
Reserved for future expansion. |
|
369 |
*/ |
|
370 |
TInt32 iSpare32[2]; |
|
371 |
public: |
|
372 |
/** |
|
373 |
Constructor which zeros all member data. |
|
374 |
*/ |
|
375 |
inline TChunkCreateInfo() |
|
376 |
{ memset(this,0,sizeof(*this)); } |
|
377 |
}; |
|
378 |
||
379 |
||
380 |
||
381 |
/** |
|
382 |
Generic kernel hook function. |
|
383 |
@internalComponent |
|
384 |
*/ |
|
385 |
typedef TInt (*TKernelHookFn)(); |
|
386 |
||
387 |
/** |
|
388 |
Available kernel hooks. |
|
389 |
@internalComponent |
|
390 |
*/ |
|
391 |
enum TKernelHookType |
|
392 |
{ |
|
393 |
EHookTrace, |
|
394 |
EHookNanoWait, |
|
395 |
EHookInitialTime, |
|
396 |
||
397 |
ENumKernelHooks |
|
398 |
}; |
|
399 |
||
400 |
||
401 |
/* |
|
402 |
Specifies the origin of the log when calling trace handler hook. |
|
403 |
@publishedPartner |
|
404 |
@released |
|
405 |
*/ |
|
406 |
enum TTraceSource |
|
407 |
{ |
|
408 |
/** |
|
409 |
User side tracing |
|
410 |
@see User::DebugPrint |
|
411 |
*/ |
|
412 |
EUserTrace, |
|
413 |
/** |
|
414 |
Kernel tracing |
|
415 |
@see Kern::Print |
|
416 |
*/ |
|
417 |
EKernelTrace, |
|
418 |
/** |
|
419 |
Platform security tracing |
|
420 |
*/ |
|
421 |
EPlatSecTrace, |
|
422 |
}; |
|
423 |
||
424 |
/* |
|
425 |
Trace handler hook |
|
426 |
@param aText Debug log. The content of the descriptor resides in kernel memory. |
|
427 |
@param aTraceType Identifies the origin of the debug log. |
|
428 |
@see TTraceHandlerType |
|
429 |
@return Specifies whether the log is processed or not. |
|
430 |
If ETrue, the log is processed. Kernel will drop the log (it won't be passed to trace port - UART) |
|
431 |
If EFalse, the log is not processed. Kernel will pass the log to the trace port, as well. |
|
432 |
@publishedPartner |
|
433 |
@released |
|
434 |
*/ |
|
435 |
typedef TBool (*TTraceHandler)(const TDesC8& /*aText*/, TTraceSource /*aTraceSource*/); |
|
436 |
||
437 |
||
438 |
/** |
|
439 |
Defines the prototype of the kernel hook for the Kern::NanoWait implementation. |
|
440 |
@see Kern::NanoWait |
|
441 |
@see Kern::SetNanoWaitHandler |
|
442 |
@publishedPartner |
|
443 |
@released |
|
444 |
*/ |
|
445 |
typedef void (*TNanoWaitHandler)(TUint32 aInterval); |
|
446 |
||
447 |
||
448 |
/** |
|
449 |
Defines the prototype of the kernel hook to get the initial system time. |
|
450 |
||
451 |
The hook is called during boot to get the inital system time. It should attempt |
|
452 |
to read the time from the hardware RTC. If the contents of the RTC are invalid |
|
453 |
it should return KErrCorrupt. |
|
454 |
||
455 |
@return The time in seconds from 00:00:00 01-01-2000, or one of the |
|
456 |
system-wide error codes. |
|
457 |
||
458 |
@see Kern::SetInitialTimeHandler |
|
459 |
@see P::InitSystemTime |
|
460 |
@publishedPartner |
|
461 |
@released |
|
462 |
*/ |
|
463 |
typedef TInt (*TInitialTimeHandler)(); |
|
464 |
||
465 |
||
466 |
/** |
|
467 |
A thread's realtime state. |
|
468 |
||
469 |
Some non-realtime behaviour can be detected by the kernel. When it does so, action is taken |
|
470 |
depending on the thread state: |
|
471 |
||
472 |
- ERealtimeStateOff - no action. |
|
473 |
- ERealtimeStateOn - the the thread will be panicked with KERN-EXEC 61 (EIllegalFunctionForRealtimeThread). |
|
474 |
- ERealtimeStateWarn - no action. However, if the kernel trace flag KREALTIME is enabled |
|
475 |
then tracing will be emitted as if the thread state was ERealtimeStateOn. |
|
476 |
||
477 |
@publishedPartner |
|
478 |
@released |
|
479 |
*/ |
|
480 |
enum TThreadRealtimeState |
|
481 |
{ |
|
482 |
ERealtimeStateOff, /**< Thread is not realtime */ |
|
483 |
ERealtimeStateOn, /**< Thread is realtime */ |
|
484 |
ERealtimeStateWarn /**< Thread is realtime but doesn't want this enforced */ |
|
485 |
}; |
|
486 |
||
487 |
||
488 |
/** |
|
489 |
A DFC queue intended to be created and destroyed as needed. |
|
490 |
||
491 |
This class extends the TDfcQue class with a destroy method. |
|
492 |
||
493 |
@publishedPartner |
|
494 |
@released |
|
495 |
*/ |
|
496 |
class TDynamicDfcQue : public TDfcQue |
|
497 |
{ |
|
498 |
public: |
|
499 |
TDynamicDfcQue(); |
|
500 |
IMPORT_C void Destroy(); |
|
501 |
IMPORT_C void SetRealtimeState(TThreadRealtimeState aNewState); |
|
502 |
private: |
|
503 |
TDfc iKillDfc; |
|
504 |
}; |
|
505 |
||
506 |
||
507 |
/** |
|
508 |
An object representing an asynchronous request from a user thread, containing a TRequestStatus |
|
509 |
pointer. |
|
510 |
||
511 |
It can be queued for completion when the thread next returns to user-mode, to move the impact of any |
|
512 |
page faults from the thread posting the completion to the thread that made the request. |
|
513 |
||
514 |
@publishedPartner |
|
515 |
@released |
|
516 |
*/ |
|
517 |
class TClientRequest : public TUserModeCallback |
|
518 |
{ |
|
519 |
public: |
|
520 |
IMPORT_C TInt SetStatus(TRequestStatus*); |
|
521 |
IMPORT_C void Reset(); |
|
522 |
IMPORT_C TRequestStatus* StatusPtr(); |
|
523 |
IMPORT_C TBool IsReady(); |
|
524 |
public: |
|
525 |
void Close(); |
|
526 |
protected: |
|
527 |
enum TState |
|
528 |
{ |
|
529 |
EFree, |
|
530 |
EReady, |
|
531 |
EInUse, |
|
532 |
EClosing, |
|
533 |
EBad |
|
534 |
}; |
|
535 |
TClientRequest(TUserModeCallbackFunc aCallback = CallbackFunc); |
|
536 |
~TClientRequest(); |
|
537 |
TState State(); |
|
538 |
static TState GetState(T_UintPtr aStatus); |
|
539 |
TBool StartComplete(DThread* aThread, TInt aReason); |
|
540 |
void EndComplete(DThread* aThread); |
|
541 |
static void CallbackFunc(TAny* aData, TUserModeCallbackReason aReason); |
|
542 |
private: |
|
543 |
static TDfc DeadClientCleanupDfc; |
|
544 |
static void DoDeadClientCleanup(TAny*); |
|
545 |
private: |
|
546 |
T_UintPtr MakeFree(); |
|
547 |
public: |
|
548 |
volatile T_UintPtr iStatus; // holds TRequestStatus pointer and state flag bits |
|
549 |
TInt iResult; |
|
550 |
friend class Kern; |
|
551 |
friend class K; |
|
552 |
}; |
|
553 |
||
554 |
||
555 |
/** |
|
556 |
Base classs for TClientDataRequest. |
|
557 |
||
558 |
@internalTechnology |
|
559 |
*/ |
|
560 |
class TClientDataRequestBase : public TClientRequest |
|
561 |
{ |
|
562 |
public: |
|
563 |
/** |
|
564 |
Set the destination in the client's address space where the data will be copied to when the |
|
565 |
request is completed. |
|
566 |
@publishedPartner |
|
567 |
@released |
|
568 |
*/ |
|
569 |
inline void SetDestPtr(TAny* aPtr) { iDestPtr = aPtr; } /**< */ |
|
570 |
/** |
|
571 |
Get the destination address in the client's address space. |
|
572 |
@publishedPartner |
|
573 |
@released |
|
574 |
*/ |
|
575 |
inline TAny* DestPtr() { return iDestPtr; } |
|
576 |
/** |
|
577 |
Get the local address of the buffer where the structure data will be held until it is copied to |
|
578 |
the client. |
|
579 |
@publishedPartner |
|
580 |
@released |
|
581 |
*/ |
|
582 |
inline TUint8* Buffer() { return (TUint8*)this + _ALIGN_UP(sizeof(*this), 8); } |
|
583 |
protected: |
|
584 |
TClientDataRequestBase(TInt aBufferSize); |
|
585 |
~TClientDataRequestBase() { } // call Close(), don't delete |
|
586 |
static void CallbackFunc(TAny* aData, TUserModeCallbackReason aReason); |
|
587 |
public: |
|
588 |
TInt iSize; |
|
589 |
TAny* iDestPtr; |
|
590 |
friend class Kern; |
|
591 |
}; |
|
592 |
||
593 |
/** |
|
594 |
An object representing an asynchronous request from a user thread that involves copying a small |
|
595 |
fixed-size structure to the client. It contains a TRequestStatus pointer and a buffer to hold the |
|
596 |
structure. |
|
597 |
||
598 |
It can be queued for completion when the thread next returns to user-mode, to move the impact of any |
|
599 |
page faults from the thread posting the completion to the thread that made the request. |
|
600 |
||
601 |
@publishedPartner |
|
602 |
@released |
|
603 |
*/ |
|
604 |
template <class T> |
|
605 |
class TClientDataRequest : public TClientDataRequestBase |
|
606 |
{ |
|
607 |
public: |
|
608 |
T& Data() { return *(T*)Buffer(); } |
|
609 |
private: |
|
610 |
TClientDataRequest(); |
|
611 |
~TClientDataRequest(); // call Close(), don't delete |
|
612 |
}; |
|
613 |
||
614 |
/** |
|
615 |
Base classs for TClientDataRequest2. |
|
616 |
||
617 |
@prototype |
|
618 |
@internalTechnology |
|
619 |
*/ |
|
620 |
class TClientDataRequestBase2 : public TClientRequest |
|
621 |
{ |
|
622 |
public: |
|
623 |
inline void SetDestPtr1(TAny* aPtr) { iDestPtr1 = aPtr; } |
|
624 |
inline TAny* DestPtr1() { return iDestPtr1; } |
|
625 |
inline TUint8* Buffer1() { return (TUint8*)this + _ALIGN_UP(sizeof(*this), 8); } |
|
626 |
inline void SetDestPtr2(TAny* aPtr) { iDestPtr2 = aPtr; } |
|
627 |
inline TAny* DestPtr2() { return iDestPtr2; } |
|
628 |
inline TUint8* Buffer2() { return Buffer1() + _ALIGN_UP(iSize1, 8); } |
|
629 |
protected: |
|
630 |
TClientDataRequestBase2(TInt aBufferSize1, TInt aBufferSize2); |
|
631 |
~TClientDataRequestBase2() { } // call Close(), don't delete |
|
632 |
static void CallbackFunc(TAny* aData, TUserModeCallbackReason aReason); |
|
633 |
public: |
|
634 |
TInt iSize1; |
|
635 |
TAny* iDestPtr1; |
|
636 |
TInt iSize2; |
|
637 |
TAny* iDestPtr2; |
|
638 |
friend class Kern; |
|
639 |
}; |
|
640 |
||
641 |
/** |
|
642 |
An object representing an asynchronous request from a user thread that involves copying two small |
|
643 |
fixed-size structures to the client. It contains a TRequestStatus pointer and two buffer to hold |
|
644 |
the structures. |
|
645 |
||
646 |
It can be queued for completion when the thread next returns to user-mode, to move the impact of any |
|
647 |
page faults from the thread posting the completion to the thread that made the request. |
|
648 |
||
649 |
@prototype |
|
650 |
@internalTechnology |
|
651 |
*/ |
|
652 |
template <class T1, class T2> |
|
653 |
class TClientDataRequest2 : public TClientDataRequestBase2 |
|
654 |
{ |
|
655 |
public: |
|
656 |
T1& Data1() { return *(T1*)Buffer1(); } |
|
657 |
T2& Data2() { return *(T2*)Buffer2(); } |
|
658 |
private: |
|
659 |
TClientDataRequest2(); |
|
660 |
~TClientDataRequest2(); // call Close(), don't delete |
|
661 |
}; |
|
662 |
||
663 |
/** |
|
664 |
A parsed descriptor header. |
|
665 |
||
666 |
This has the same internal structure as TRawDesHeader but the header data is stored in a parsed |
|
667 |
representation. |
|
668 |
||
669 |
@see TRawDesHeader. |
|
670 |
||
671 |
@prototype |
|
672 |
@internalTechnology |
|
673 |
*/ |
|
674 |
class TDesHeader |
|
675 |
{ |
|
676 |
public: |
|
677 |
enum { KConstMaxLength = (TUint)KErrBadDescriptor }; |
|
678 |
inline TDesHeader(); |
|
679 |
/// Set the contents of this object |
|
680 |
inline void Set(TUint32 aTypeAndLength, TLinAddr aDataPtr, TUint aMaxLength = KConstMaxLength); |
|
681 |
/// Reset the object to its initial un-set state |
|
682 |
inline void Unset(); |
|
683 |
/// Determine whether this object has been set to a valid descriptor header |
|
684 |
inline TBool IsSet() const; |
|
685 |
/// Set both type and length fields in one operation |
|
686 |
inline void SetTypeAndLength(TUint32 aTypeAndLength); |
|
687 |
// Accessors |
|
688 |
inline const TUint32& TypeAndLength() const; |
|
689 |
inline TDesType Type() const; |
|
690 |
inline TInt Length() const; |
|
691 |
inline TBool IsWriteable() const; |
|
692 |
inline TInt MaxLength() const; |
|
693 |
inline TLinAddr DataPtr() const; |
|
694 |
private: |
|
695 |
enum { KUnsetFlag = 0xffffffff }; |
|
696 |
TUint32 iData[3]; |
|
697 |
}; |
|
698 |
||
699 |
inline TDesHeader::TDesHeader() |
|
700 |
{ |
|
701 |
iData[0] = (TUint32)KUnsetFlag; |
|
702 |
} |
|
703 |
||
704 |
inline void TDesHeader::Set(TUint32 aTypeAndLength, TLinAddr aDataPtr, TUint aMaxLength) |
|
705 |
{ |
|
706 |
iData[0] = aTypeAndLength; |
|
707 |
iData[1] = aMaxLength; |
|
708 |
iData[2] = aDataPtr; |
|
709 |
} |
|
710 |
||
711 |
inline void TDesHeader::Unset() |
|
712 |
{ |
|
713 |
iData[0] = (TUint32)KUnsetFlag; |
|
714 |
} |
|
715 |
||
716 |
inline TBool TDesHeader::IsSet() const |
|
717 |
{ |
|
718 |
return iData[0] != KUnsetFlag; |
|
719 |
} |
|
720 |
||
721 |
inline void TDesHeader::SetTypeAndLength(TUint32 aTypeAndLength) |
|
722 |
{ |
|
723 |
iData[0] = aTypeAndLength; |
|
724 |
} |
|
725 |
||
726 |
inline const TUint32& TDesHeader::TypeAndLength() const |
|
727 |
{ |
|
728 |
return iData[0]; |
|
729 |
} |
|
730 |
||
731 |
inline TDesType TDesHeader::Type() const |
|
732 |
{ |
|
733 |
return (TDesType)(iData[0] >> KShiftDesType); |
|
734 |
} |
|
735 |
||
736 |
inline TInt TDesHeader::Length() const |
|
737 |
{ |
|
738 |
return (TInt)(iData[0] & KMaskDesLength); |
|
739 |
} |
|
740 |
||
741 |
inline TBool TDesHeader::IsWriteable() const |
|
742 |
{ |
|
743 |
return iData[1] != KConstMaxLength; |
|
744 |
} |
|
745 |
||
746 |
inline TInt TDesHeader::MaxLength() const |
|
747 |
{ |
|
748 |
return (TInt)iData[1]; |
|
749 |
} |
|
750 |
||
751 |
inline TLinAddr TDesHeader::DataPtr() const |
|
752 |
{ |
|
753 |
return (TLinAddr)iData[2]; |
|
754 |
} |
|
755 |
||
756 |
/** |
|
757 |
An object representing a client buffer that resides in user-side memory. |
|
758 |
||
759 |
TClientBuffer objects can be used to specify memory to pin using Kern::PinVirtualMemory |
|
760 |
@see, and can be read and written using Kern::ThreadBufRead and Kern::ThreadBufWrite. |
|
761 |
||
762 |
@see TClientBufferRequest |
|
763 |
@see Kern::PinVirtualMemory |
|
764 |
@see Kern::UnpinVirtualMemory |
|
765 |
@see Kern::ThreadBufRead |
|
766 |
@see Kern::ThreadBufWrite |
|
767 |
||
768 |
@publishedPartner |
|
769 |
@released |
|
770 |
*/ |
|
771 |
class TClientBuffer |
|
772 |
{ |
|
773 |
public: |
|
774 |
IMPORT_C TClientBuffer(); |
|
775 |
IMPORT_C TInt SetFromDescriptor(TAny* aDesPtr, DThread* aClientThread = NULL); |
|
776 |
IMPORT_C void SetFromBuffer(TLinAddr aStartAddr, TInt aLength, TBool aWriteable); |
|
777 |
IMPORT_C TBool IsSet() const; |
|
778 |
IMPORT_C void Reset(); |
|
779 |
IMPORT_C TBool IsWriteable() const; |
|
780 |
IMPORT_C TInt Length() const; |
|
781 |
IMPORT_C TInt MaxLength() const; |
|
782 |
IMPORT_C TInt UpdateDescriptorLength(DThread* aClientThread = NULL); |
|
783 |
public: |
|
784 |
TAny* DesPtr() const; |
|
785 |
TAny* DataPtr() const; |
|
786 |
private: |
|
787 |
enum TFlags |
|
788 |
{ |
|
789 |
EIsBuffer = 1 |
|
790 |
}; |
|
791 |
private: |
|
792 |
TUint32 iPtr; |
|
793 |
TDesHeader iHeader; |
|
794 |
friend class Kern; |
|
795 |
}; |
|
796 |
||
797 |
class TVirtualPinObject; |
|
798 |
class TPhysicalPinObject; |
|
799 |
class TShPool; |
|
800 |
class TShBuf; |
|
801 |
||
802 |
/** |
|
803 |
An object representing a device driver request that involves writing data to one or more user-side |
|
804 |
buffers. |
|
805 |
||
806 |
It handles pinning of the buffers when the request is set up, so that the memory can be accessed in |
|
807 |
kernel thread context. |
|
808 |
||
809 |
It can be queued for completion when the thread next returns to user-mode. Any writeable |
|
810 |
descriptors have their lengths written back to the client at the same time as the completion value. |
|
811 |
||
812 |
The following operations can only be called from client thread context: |
|
813 |
||
814 |
StartSetup |
|
815 |
AddBuffer |
|
816 |
EndSetup |
|
817 |
||
818 |
These operations can be called from any thread context: |
|
819 |
||
820 |
Kern::QueueRequestComplete |
|
821 |
||
822 |
@publishedPartner |
|
823 |
@released |
|
824 |
*/ |
|
825 |
class TClientBufferRequest : private TClientRequest |
|
826 |
{ |
|
827 |
public: |
|
828 |
enum TFlags |
|
829 |
{ |
|
830 |
/** A flag indicating that buffers should have their virtual memory pinned. */ |
|
831 |
EPinVirtual = 1 |
|
832 |
}; |
|
833 |
IMPORT_C TInt StartSetup(TRequestStatus* aStatus); |
|
834 |
IMPORT_C TInt AddBuffer(TClientBuffer*& aBufOut, TAny* aDesPtr); |
|
835 |
IMPORT_C TInt AddBuffer(TClientBuffer*& aBufOut, TLinAddr aStartAddr, TInt aLength, TBool aWriteable = EFalse); |
|
836 |
IMPORT_C void EndSetup(); |
|
837 |
IMPORT_C void Reset(); |
|
838 |
inline TInt Setup(TClientBuffer*& aBufOut, TRequestStatus* aStatus, TAny* aDesPtr); |
|
839 |
inline TInt Setup(TClientBuffer*& aBufOut, TRequestStatus* aStatus, TLinAddr aStartAddr, TInt aLength, TBool aWriteable = EFalse); |
|
840 |
inline TBool IsReady(); |
|
841 |
private: |
|
842 |
struct SBufferData : public SDblQueLink |
|
843 |
{ |
|
844 |
TClientBuffer iBuffer; |
|
845 |
TVirtualPinObject* iPinObject; |
|
846 |
}; |
|
847 |
TClientBufferRequest(TUint aFlags); |
|
848 |
~TClientBufferRequest(); // call Close(), don't delete |
|
849 |
TInt Construct(TInt aMaxBuffers); |
|
850 |
void Close(); |
|
851 |
TInt AllocateBufferData(); |
|
852 |
SBufferData* StartAddBuffer(); |
|
853 |
TInt EndAddBuffer(TClientBuffer*& aBufOut, SBufferData* aBuf); |
|
854 |
void QueueComplete(DThread* aThread, TInt aReason); |
|
855 |
static void CallbackFunc(TAny* aData, TUserModeCallbackReason aReason); |
|
856 |
private: |
|
857 |
TUint iFlags; |
|
858 |
DThread* iSetupThread; |
|
859 |
SDblQue iBufferList; |
|
860 |
static NFastMutex Lock; |
|
861 |
friend class Kern; |
|
862 |
}; |
|
863 |
||
864 |
inline TInt TClientBufferRequest::Setup(TClientBuffer*& aBufOut, TRequestStatus* aStatus, TAny* aDesPtr) |
|
865 |
{ |
|
866 |
TInt r = StartSetup(aStatus); |
|
867 |
if (r == KErrNone) |
|
868 |
r = AddBuffer(aBufOut, aDesPtr); |
|
869 |
if (r == KErrNone) |
|
870 |
EndSetup(); |
|
871 |
return r; |
|
872 |
} |
|
873 |
||
874 |
inline TInt TClientBufferRequest::Setup(TClientBuffer*& aBufOut, TRequestStatus* aStatus, TLinAddr aStartAddr, TInt aLength, TBool aWriteable) |
|
875 |
{ |
|
876 |
TInt r = StartSetup(aStatus); |
|
877 |
if (r == KErrNone) |
|
878 |
r = AddBuffer(aBufOut, aStartAddr, aLength, aWriteable); |
|
879 |
if (r == KErrNone) |
|
880 |
EndSetup(); |
|
881 |
return r; |
|
882 |
} |
|
883 |
||
884 |
inline TBool TClientBufferRequest::IsReady() |
|
885 |
{ |
|
886 |
return TClientRequest::IsReady(); |
|
887 |
} |
|
888 |
||
889 |
class DPagingDevice; |
|
890 |
class DLogicalDevice; |
|
891 |
class DPhysicalDevice; |
|
892 |
class TShPoolCreateInfo; |
|
893 |
||
894 |
class Kern |
|
895 |
/** |
|
896 |
Kernel utility functions |
|
897 |
||
898 |
@publishedPartner |
|
899 |
@released |
|
900 |
*/ |
|
901 |
{ |
|
902 |
public: |
|
903 |
/** |
|
904 |
Bit values to be used with the aMode parameter of Kern::SetSytemTime() to |
|
905 |
specify the mode of operation of Kern::SetSytemTime(). |
|
906 |
*/ |
|
907 |
enum TTimeSetMode |
|
908 |
{ |
|
909 |
ETimeSet_SetHwRtc = 1, /**< Set HW as well as SW RTC */ |
|
910 |
ETimeSet_LocalTime = 2, /**< The Kern::SetSytemTime() parameter aTime is specified in local time rather than UTC */ |
|
911 |
ETimeSet_SyncNotify = 4, /**< Synchronously trigger change notifiers*/ |
|
912 |
ETimeSet_AsyncNotify = 8, /**< Asynchronously trigger change notifiers*/ |
|
913 |
ETimeSet_Secure = 16 /**< Set the secure clock (implies ETimeSet_SetHwRtc)*/ |
|
914 |
}; |
|
915 |
public: |
|
916 |
IMPORT_C static void Printf(const char* aFmt, ...); |
|
917 |
IMPORT_C static TInt AddHalEntry(TInt aId, THalFunc aFunc, TAny* aPtr); |
|
918 |
IMPORT_C static TInt AddHalEntry(TInt aId, THalFunc aFunc, TAny* aPtr, TInt aDeviceNumber); |
|
919 |
IMPORT_C static TInt RemoveHalEntry(TInt aId); |
|
920 |
IMPORT_C static TInt RemoveHalEntry(TInt aId, TInt aDeviceNumber); |
|
921 |
IMPORT_C static SHalEntry* FindHalEntry(TInt aId); |
|
922 |
IMPORT_C static SHalEntry* FindHalEntry(TInt aId, TInt aDeviceNumber); |
|
923 |
IMPORT_C static void SafeClose(DObject*& aObj, TAny* aPtr); |
|
924 |
IMPORT_C static TInt ValidateName(const TDesC& aName); |
|
925 |
IMPORT_C static TInt ValidateFullName(const TDesC& aName); |
|
926 |
IMPORT_C static TBool PowerGood(); |
|
927 |
IMPORT_C static void NotifyChanges(TUint aChangesMask); |
|
928 |
IMPORT_C static void NotifyThreadDeath(DThread* aDeadThread); /**< @internalComponent */ |
|
929 |
IMPORT_C static void AsyncNotifyChanges(TUint aChangesMask); |
|
930 |
IMPORT_C static void InfoCopy(TDes8& aDest, const TDesC8& aSrc); |
|
931 |
IMPORT_C static void InfoCopy(TDes8& aDest, const TUint8* aPtr, TInt aLength); |
|
932 |
IMPORT_C static void RequestComplete(DThread* aThread, TRequestStatus*& aStatus, TInt aReason); |
|
933 |
IMPORT_C static void RequestComplete(TRequestStatus*& aStatus, TInt aReason); |
|
934 |
IMPORT_C static void QueueRequestComplete(DThread* aThread, TClientRequest* aRequest, TInt aReason); |
|
935 |
IMPORT_C static TInt CreateClientRequest(TClientRequest*& aRequestPtr); |
|
936 |
||
937 |
template <class T> inline static TInt CreateClientDataRequest(TClientDataRequest<T>*& aRequestPtr) |
|
938 |
{ |
|
939 |
TInt r = Kern::CreateClientDataRequestBase((TClientDataRequestBase*&)aRequestPtr, sizeof(T)); |
|
940 |
if (r == KErrNone) |
|
941 |
new (aRequestPtr->Buffer()) T; |
|
942 |
return r; |
|
943 |
} |
|
944 |
||
945 |
template <class T1, class T2> inline static TInt CreateClientDataRequest2(TClientDataRequest2<T1,T2>*& aRequestPtr) |
|
946 |
{ |
|
947 |
TInt r = Kern::CreateClientDataRequestBase2((TClientDataRequestBase2*&)aRequestPtr, sizeof(T1), sizeof(T2)); |
|
948 |
if (r == KErrNone) |
|
949 |
{ |
|
950 |
new (aRequestPtr->Buffer1()) T1; |
|
951 |
new (aRequestPtr->Buffer2()) T2; |
|
952 |
} |
|
953 |
return r; |
|
954 |
} |
|
955 |
||
956 |
IMPORT_C static void DestroyClientRequest(TClientRequest*& aRequestPtr); |
|
957 |
template <class T> inline static void DestroyClientRequest(TClientDataRequest<T>*& aRequestPtr) |
|
958 |
{ DestroyClientRequest((TClientRequest*&)aRequestPtr); } /**< @prototype */ |
|
959 |
template <class T, class T2> inline static void DestroyClientRequest(TClientDataRequest2<T,T2>*& aRequestPtr) |
|
960 |
{ DestroyClientRequest((TClientRequest*&)aRequestPtr); } /**< @prototype */ |
|
961 |
IMPORT_C static TInt CreateClientBufferRequest(TClientBufferRequest*& aRequestPtr, TUint aInitialBuffers, TUint aFlags); |
|
962 |
IMPORT_C static void DestroyClientBufferRequest(TClientBufferRequest*& aRequestPtr); |
|
963 |
IMPORT_C static void QueueBufferRequestComplete(DThread* aThread, TClientBufferRequest* aRequest, TInt aReason); |
|
964 |
IMPORT_C static TDfcQue* DfcQue0(); |
|
965 |
IMPORT_C static TDfcQue* DfcQue1(); |
|
966 |
IMPORT_C static TDfcQue* TimerDfcQ(); |
|
967 |
IMPORT_C static TDfcQue* SvMsgQue(); |
|
968 |
IMPORT_C static DObjectCon* const *Containers(); /**< @internalComponent */ |
|
969 |
IMPORT_C static SDblQue* CodeSegList(); |
|
970 |
IMPORT_C static DMutex* CodeSegLock(); |
|
971 |
IMPORT_C static DPowerModel* PowerModel(); |
|
972 |
IMPORT_C static TInt SetThreadPriority(TInt aPriority, DThread* aThread=NULL); |
|
973 |
IMPORT_C static void SetRealtimeState(TThreadRealtimeState aNewState); |
|
974 |
IMPORT_C static DObject* ObjectFromHandle(DThread* aThread, TInt aHandle, TInt aType); |
|
975 |
IMPORT_C static DObject* ObjectFromHandle(DThread* aThread, TInt aHandle, TInt aType, TUint& aAttr); |
|
976 |
IMPORT_C static DThread* ThreadFromId(TUint aId); |
|
977 |
IMPORT_C static DProcess* ProcessFromId(TUint aId); |
|
978 |
IMPORT_C static void ThreadSuspend(DThread& aThread, TInt aCount); |
|
979 |
IMPORT_C static void ThreadResume(DThread& aThread); |
|
980 |
IMPORT_C static TInt MutexWait(DMutex& aMutex); |
|
981 |
IMPORT_C static void MutexSignal(DMutex& aMutex); |
|
982 |
IMPORT_C static TInt MutexCreate(DMutex*& aMutex, const TDesC& aName, TUint aOrder); |
|
983 |
IMPORT_C static TInt SemaphoreWait(DSemaphore& aSem, TInt aNTicks=0); |
|
984 |
IMPORT_C static void SemaphoreSignal(DSemaphore& aSem); |
|
985 |
IMPORT_C static TInt SemaphoreCreate(DSemaphore*& aSem, const TDesC& aName, TInt aInitialCount); |
|
986 |
IMPORT_C static TInt ThreadCreate(SThreadCreateInfo& aInfo); |
|
987 |
IMPORT_C static TInt DfcQInit(TDfcQue* aDfcQ, TInt aPriority, const TDesC* aName=NULL); |
|
988 |
IMPORT_C static TInt DfcQCreate(TDfcQue*& aDfcQ, TInt aPriority, const TDesC* aName=NULL); |
|
989 |
IMPORT_C static TInt DynamicDfcQCreate(TDynamicDfcQue*& aDfcQ, TInt aPriority, const TDesC& aBaseName); |
|
990 |
IMPORT_C static TInt ProcessCreate(DProcess*& aProcess, TProcessCreateInfo& aInfo, HBuf*& aCommand, TInt* aHandle); /**< @internalComponent */ |
|
991 |
IMPORT_C static TSupplyStatus MachinePowerStatus(); |
|
992 |
IMPORT_C static void AppendFormat(TDes8& aDes, const char* aFmt, VA_LIST aList); |
|
993 |
IMPORT_C static TSuperPage& SuperPage(); |
|
994 |
IMPORT_C static TMachineConfig& MachineConfig(); |
|
995 |
IMPORT_C static TUint32 Random(); |
|
996 |
IMPORT_C static void RandomSalt(TUint32 aBit); |
|
997 |
IMPORT_C static void WaitForRequest(TRequestStatus& aStatus); /**< @internalTechnology */ |
|
998 |
IMPORT_C static TAny* Alloc(TInt aSize); |
|
999 |
IMPORT_C static TAny* AllocZ(TInt aSize); |
|
1000 |
IMPORT_C static void Free(TAny* aPtr); |
|
1001 |
IMPORT_C static void AsyncFree(TAny* aPtr); |
|
1002 |
IMPORT_C static TAny* ReAlloc(TAny* aPtr, TInt aSize, TInt aMode=0); |
|
1003 |
IMPORT_C static TInt SafeReAlloc(TAny*& aPtr, TInt aOldSize, TInt aNewSize); |
|
1004 |
IMPORT_C static void ValidateHeap(); |
|
1005 |
IMPORT_C static void PanicCurrentThread(const TDesC& aCategory, TInt aReason); |
|
1006 |
IMPORT_C static TBool QueryVersionSupported(const TVersion& aCurrent,const TVersion& aRequested); |
|
1007 |
IMPORT_C static TTimeK SystemTimeSecure(); |
|
1008 |
IMPORT_C static TTimeK SystemTime(); |
|
1009 |
IMPORT_C static TInt SetSystemTime(const TTimeK& aTime, TUint aMode); |
|
1010 |
IMPORT_C static TInt HalFunction(TInt aGroup, TInt aFunction, TAny* a1, TAny* a2); |
|
1011 |
IMPORT_C static TInt HalFunction(TInt aGroup, TInt aFunction, TAny* a1, TAny* a2, TInt aDeviceNumber); |
|
1012 |
IMPORT_C static TInt AddEvent(const TRawEvent& aEvent); |
|
1013 |
IMPORT_C static TInt AddEvent(const TRawEvent& aEvent, TBool aResetUserActivity); |
|
1014 |
IMPORT_C static void Exit(TInt aReason); |
|
1015 |
IMPORT_C static TInt TickPeriod(); |
|
1016 |
IMPORT_C static void KUDesGet(TDes8& aDest, const TDesC8& aSrc); |
|
1017 |
IMPORT_C static void KUDesPut(TDes8& aDest, const TDesC8& aSrc); |
|
1018 |
IMPORT_C static const TUint8* KUDesInfo(const TDesC8& aSrc, TInt& aLength, TInt& aMaxLength); |
|
1019 |
IMPORT_C static void KUDesSetLength(TDes8& aDes, TInt aLength); |
|
1020 |
IMPORT_C static TInt ThreadDesRead(DThread* aThread, const TAny* aSrc, TDes8& aDest, TInt aOffset, TInt aMode); |
|
1021 |
IMPORT_C static TInt ThreadRawRead(DThread* aThread, const TAny* aSrc, TAny* aDest, TInt aSize); |
|
1022 |
IMPORT_C static TInt ThreadDesWrite(DThread* aThread, TAny* aDest, const TDesC8& aSrc, TInt aOffset, TInt aMode, DThread* aOrigThread); |
|
1023 |
IMPORT_C static TInt ThreadRawWrite(DThread* aThread, TAny* aDest, const TAny* aSrc, TInt aSize, DThread* aOrigThread=NULL); |
|
1024 |
inline static TInt ThreadDesRead(DThread* aThread, const TAny* aSrc, TDes8& aDest, TInt aOffset); |
|
1025 |
inline static TInt ThreadDesWrite(DThread* aThread, TAny* aDest, const TDesC8& aSrc, TInt aOffset, DThread* aOrigThread=NULL); |
|
1026 |
IMPORT_C static TInt ThreadBufRead(DThread* aThread, const TClientBuffer* aSrc, TDes8& aDest, TInt aOffset, TInt aMode); |
|
1027 |
IMPORT_C static TInt ThreadBufWrite(DThread* aThread, TClientBuffer* aDest, const TDesC8& aSrc, TInt aOffset, TInt aMode, DThread* aOrigThread); |
|
1028 |
IMPORT_C static TInt ThreadGetDesLength(DThread* aThread, const TAny* aDes); |
|
1029 |
IMPORT_C static TInt ThreadGetDesMaxLength(DThread* aThread, const TAny* aDes); |
|
1030 |
IMPORT_C static TInt ThreadGetDesInfo(DThread* aThread, const TAny* aDes, TInt& aLength, TInt& aMaxLength, TUint8*& aPtr, TBool aWriteable); |
|
1031 |
IMPORT_C static void ThreadKill(DThread* aThread, TExitType aType, TInt aReason, const TDesC& aCategory); |
|
1032 |
IMPORT_C static TAny* KUSafeRead(const TAny* aSrc, TAny* aDest, TInt aSize); /**< @internalTechnology */ |
|
1033 |
IMPORT_C static TAny* SafeRead(const TAny* aSrc, TAny* aDest, TInt aSize); /**< @internalTechnology */ |
|
1034 |
IMPORT_C static TAny* KUSafeWrite(TAny* aDest, const TAny* aSrc, TInt aSize); /**< @internalTechnology */ |
|
1035 |
IMPORT_C static TAny* SafeWrite(TAny* aDest, const TAny* aSrc, TInt aSize); /**< @internalTechnology */ |
|
1036 |
IMPORT_C static TInt KUSafeInc(TInt& aValue); /**< @internalTechnology */ |
|
1037 |
IMPORT_C static TInt KUSafeDec(TInt& aValue); /**< @internalTechnology */ |
|
1038 |
IMPORT_C static DThread& CurrentThread(); |
|
1039 |
IMPORT_C static DProcess& CurrentProcess(); |
|
1040 |
IMPORT_C static TThreadMessage& Message(); |
|
1041 |
IMPORT_C static TInt FreeRamInBytes(); |
|
1042 |
IMPORT_C static void Fault(const char* aCat, TInt aFault); |
|
1043 |
IMPORT_C static TBool ColdStart(); |
|
1044 |
IMPORT_C static void NanoWait(TUint32 aInterval); |
|
1045 |
IMPORT_C static TUint32 TickCount(); |
|
1046 |
IMPORT_C static TInt PollingWait(TPollFunction aFunction, TAny* aPtr, TInt aPollPeriodMs, TInt aMaxPoll); |
|
1047 |
IMPORT_C static TUint32 RoundToPageSize(TUint32 aSize); |
|
1048 |
IMPORT_C static TUint32 RoundToChunkSize(TUint32 aSize); |
|
1049 |
IMPORT_C static void Restart(TInt aMode); /**< @internalTechnology */ |
|
1050 |
IMPORT_C static void AccessCode(); |
|
1051 |
IMPORT_C static void EndAccessCode(); |
|
1052 |
IMPORT_C static DThread* NThreadToDThread(NThread* aNThread); |
|
1053 |
IMPORT_C static TInt PrepareMemoryForDMA(DThread* aThread, TAny* aAddress, TInt aSize, TPhysAddr* aPageList); /**< @internalComponent */ |
|
1054 |
IMPORT_C static TInt ReleaseMemoryFromDMA(DThread* aThread, TAny* aAddress, TInt aSize, TPhysAddr* aPageList);/**< @internalComponent */ |
|
1055 |
||
1056 |
#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__ |
|
1057 |
/** |
|
1058 |
Checks whether the process that owns the current thread has the specified capability. |
|
1059 |
||
1060 |
When a check fails the action taken is determined by the system wide Platform Security |
|
1061 |
configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted. |
|
1062 |
If PlatSecEnforcement is OFF, then this function will return True even though the |
|
1063 |
check failed. |
|
1064 |
||
1065 |
@param aCapability The capability to be tested. |
|
1066 |
@param aDiagnosticText A string that will be emitted along with any diagnostic message |
|
1067 |
that may be issued if the test finds the capability is not present. |
|
1068 |
This string must be enclosed in the __PLATSEC_DIAGNOSTIC_STRING macro |
|
1069 |
which enables it to be easily removed from the system. |
|
1070 |
||
1071 |
@return True if the current thread's process has the capability, False otherwise. |
|
1072 |
*/ |
|
1073 |
inline static TBool CurrentThreadHasCapability(TCapability aCapability, const char* aDiagnosticText=0) |
|
1074 |
{ return DoCurrentThreadHasCapability(aCapability, aDiagnosticText); } |
|
1075 |
#else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__ |
|
1076 |
// Only available to NULL arguments |
|
1077 |
/** |
|
1078 |
Checks whether the process that owns the current thread has the specified capability. |
|
1079 |
||
1080 |
When a check fails the action taken is determined by the system wide Platform Security |
|
1081 |
configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted. |
|
1082 |
If PlatSecEnforcement is OFF, then this function will return True even though the |
|
1083 |
check failed. |
|
1084 |
||
1085 |
@param aCapability The capability to be tested. |
|
1086 |
||
1087 |
@return True if the current thread's process has the capability, False otherwise. |
|
1088 |
*/ |
|
1089 |
inline static TBool CurrentThreadHasCapability(TCapability aCapability, OnlyCreateWithNull /*aDiagnosticText*/=NULL) |
|
1090 |
{ return DoCurrentThreadHasCapability(aCapability); } |
|
1091 |
#endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__ |
|
1092 |
||
1093 |
IMPORT_C static TVendorId ThreadVendorId(DThread* aThread); |
|
1094 |
IMPORT_C static TVendorId ProcessVendorId(DProcess* aProcess); |
|
1095 |
IMPORT_C static TSecureId ThreadSecureId(DThread* aThread); |
|
1096 |
IMPORT_C static TSecureId ProcessSecureId(DProcess* aProcess); |
|
1097 |
||
1098 |
IMPORT_C static DCodeSeg* CodeSegFromAddress(TLinAddr aAddr, DProcess* aProcess); |
|
1099 |
IMPORT_C static void CodeSegGetMemoryInfo(DCodeSeg& aCodeSeg, TModuleMemoryInfo& aInfo, DProcess* aProcess); |
|
1100 |
IMPORT_C static TInt MakeHandleAndOpen(DThread* aThread, DObject* aObject); |
|
31
56f325a607ea
Revision: 200951
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
1101 |
IMPORT_C static TInt MakeHandleAndOpen(DThread* aThread, DObject* aObject, TOwnerType aType); |
0 | 1102 |
IMPORT_C static TInt CloseHandle(DThread* aThread, TInt aHandle); |
1103 |
IMPORT_C static TInt ChunkCreate(const TChunkCreateInfo& aInfo, DChunk*& aChunk, TLinAddr& aKernAddr, TUint32& iMapAttr); |
|
1104 |
IMPORT_C static TInt ChunkCommit(DChunk* aChunk, TInt aOffset, TInt aSize); |
|
1105 |
IMPORT_C static TInt ChunkCommitContiguous(DChunk* aChunk, TInt aOffset, TInt aSize, TUint32& aPhysicalAddress); |
|
1106 |
IMPORT_C static TInt ChunkCommitPhysical(DChunk* aChunk, TInt aOffset, TInt aSize, TUint32 aPhysicalAddress); |
|
1107 |
IMPORT_C static TInt ChunkCommitPhysical(DChunk* aChunk, TInt aOffset, TInt aSize, const TUint32* aPhysicalAddressList); |
|
1108 |
IMPORT_C static TInt ChunkClose(DChunk* aChunk); |
|
1109 |
IMPORT_C static DChunk* OpenSharedChunk(DThread* aThread, const TAny* aAddress, TBool aWrite, TInt& aOffset); |
|
1110 |
IMPORT_C static DChunk* OpenSharedChunk(DThread* aThread, TInt aChunkHandle, TBool aWrite); |
|
1111 |
IMPORT_C static TInt ChunkAddress(DChunk* aChunk, TInt aOffset, TInt aSize, TLinAddr& aKernelAddress); |
|
1112 |
IMPORT_C static TInt ChunkPhysicalAddress(DChunk* aChunk, TInt aOffset, TInt aSize, TLinAddr& aKernelAddress, TUint32& aMapAttr, TUint32& aPhysicalAddress, TUint32* aPhysicalPageList=NULL); |
|
1113 |
IMPORT_C static TUint8* ChunkUserBase(DChunk* aChunk, DThread* aThread); |
|
1114 |
||
1115 |
/** |
|
1116 |
Enumeration indicating the behaviour of text trace messages. |
|
1117 |
@publishedPartner |
|
1118 |
@released |
|
1119 |
*/ |
|
1120 |
enum TTextTraceMode |
|
1121 |
{ |
|
1122 |
/** Traces are sent to the serial port if not already handled by other means. */ |
|
1123 |
ESerialOutDefault = 0, |
|
1124 |
/** Traces are never sent to the serial port. */ |
|
1125 |
ESerialOutNever = 1, |
|
1126 |
/** Traces are always sent to the serial port. */ |
|
1127 |
ESerialOutAlways = 2, |
|
1128 |
/** Mask for serial port mode values. */ |
|
1129 |
ESerialOutMask = 3 |
|
1130 |
}; |
|
1131 |
IMPORT_C static TUint SetTextTraceMode(TUint aMode, TUint aMask); |
|
1132 |
IMPORT_C static TTraceHandler SetTraceHandler(TTraceHandler aHandler); |
|
1133 |
inline static TNanoWaitHandler SetNanoWaitHandler(TNanoWaitHandler aHandler); |
|
1134 |
inline static TInitialTimeHandler SetInitialTimeHandler(TInitialTimeHandler aHandler); |
|
1135 |
||
1136 |
/** |
|
1137 |
Install the specified paging device. |
|
1138 |
@param aDevice The device. |
|
1139 |
@return KErrNone or standard error code. |
|
1140 |
@post The devices DPagingDevice::iDeviceId has been set. |
|
1141 |
@internalTechnology |
|
1142 |
*/ |
|
1143 |
IMPORT_C static TInt InstallPagingDevice(DPagingDevice* aDevice); |
|
1144 |
IMPORT_C static TInt InstallLogicalDevice(DLogicalDevice* aDevice); /**< @internalTechnology */ |
|
1145 |
IMPORT_C static TInt InstallPhysicalDevice(DPhysicalDevice* aDevice); /**< @internalTechnology */ |
|
1146 |
||
1147 |
IMPORT_C static TInt CreateVirtualPinObject(TVirtualPinObject*& aPinObject); // prototype |
|
1148 |
IMPORT_C static TInt PinVirtualMemory(TVirtualPinObject* aPinObject, TLinAddr aStart, TUint aSize, DThread* aThread=NULL); // prototype |
|
1149 |
IMPORT_C static TInt PinVirtualMemory(TVirtualPinObject* aPinObject, const TClientBuffer& aDes, DThread* aThread=NULL); // prototype |
|
1150 |
IMPORT_C static TInt CreateAndPinVirtualMemory(TVirtualPinObject*& aPinObject, TLinAddr aStart, TUint aSize); //prototype |
|
1151 |
IMPORT_C static void UnpinVirtualMemory(TVirtualPinObject* aPinObject); // prototype |
|
1152 |
IMPORT_C static void DestroyVirtualPinObject(TVirtualPinObject*& aPinObject); // prototype |
|
1153 |
||
1154 |
IMPORT_C static TInt CreatePhysicalPinObject(TPhysicalPinObject*& aPinObject); // prototype |
|
1155 |
IMPORT_C static TInt PinPhysicalMemory(TPhysicalPinObject* aPinObject, TLinAddr aStart, TUint aSize, TBool aReadOnly, TPhysAddr& aAddress, TPhysAddr* aPages, TUint32& aMapAttr, TUint& aColour, DThread* aThread=NULL); |
|
1156 |
IMPORT_C static TInt UnpinPhysicalMemory(TPhysicalPinObject* aPinObject); // prototype |
|
1157 |
IMPORT_C static TInt DestroyPhysicalPinObject(TPhysicalPinObject*& aPinObject); // prototype |
|
1158 |
||
1159 |
||
1160 |
IMPORT_C static TInt ShPoolCreate(TShPool*& aPool, TShPoolCreateInfo& aInfo, TBool aMap, TUint aFlags); |
|
1161 |
IMPORT_C static TInt ShPoolOpen(TShPool*& aPool, DThread* aThread, TInt aHandle, TBool aMap, TUint aFlags); |
|
1162 |
IMPORT_C static TInt ShPoolClose(TShPool* aPool); |
|
1163 |
IMPORT_C static TInt ShPoolMakeHandleAndOpen(TShPool* aPool, DThread* aThread, TUint aAttr); |
|
1164 |
IMPORT_C static TInt ShPoolSetBufferWindow(TShPool* aPool, TInt aWindowSize); |
|
1165 |
IMPORT_C static TInt ShPoolAlloc(TShPool* aPool, TShBuf*& aBuf, TUint aFlags); |
|
1166 |
IMPORT_C static void ShPoolGetInfo(TShPool* aPool, TShPoolInfo& aInfo); |
|
1167 |
IMPORT_C static TUint ShPoolBufSize(TShPool* aPool); |
|
1168 |
IMPORT_C static TUint ShPoolFreeCount(TShPool* aPool); |
|
1169 |
IMPORT_C static TInt ShBufOpen(TShBuf*& aBuf, DThread* aThread, TInt aHandle); |
|
1170 |
IMPORT_C static TInt ShBufClose(TShBuf* aBuf); |
|
1171 |
IMPORT_C static TInt ShBufMakeHandleAndOpen(TShBuf* aBuf, DThread* aThread); |
|
1172 |
IMPORT_C static void ShBufCopyFrom(TShBuf* aBuf, const TDesC8& aSrc, TUint aOffset); |
|
1173 |
IMPORT_C static TUint8* ShBufPtr(TShBuf* aBuf); |
|
1174 |
IMPORT_C static TUint ShBufSize(TShBuf* aBuf); |
|
1175 |
IMPORT_C static TInt ShBufPin(TShBuf* aBuf, TPhysicalPinObject* aPinObject, TBool aReadOnly, TPhysAddr& Address, TPhysAddr* aPages, TUint32& aMapAttr, TUint& aColour); |
|
1176 |
||
1177 |
||
1178 |
private: |
|
1179 |
IMPORT_C static TBool DoCurrentThreadHasCapability(TCapability aCapability, const char* aDiagnosticText); |
|
1180 |
IMPORT_C static TBool DoCurrentThreadHasCapability(TCapability aCapability); |
|
1181 |
IMPORT_C static TKernelHookFn SetHook(TKernelHookType aType, TKernelHookFn aFunction, TBool aAllowOveride=EFalse); |
|
1182 |
IMPORT_C static TInt CreateClientDataRequestBase(TClientDataRequestBase*& aRequestPtr, TInt aSize); /**< @internalTechnology */ |
|
1183 |
IMPORT_C static TInt CreateClientDataRequestBase2(TClientDataRequestBase2*& aRequestPtr, TInt aSize1, TInt aSize2); /**< @internalTechnology */ |
|
1184 |
friend class DThread; |
|
1185 |
}; |
|
1186 |
||
1187 |
||
1188 |
||
1189 |
/** |
|
1190 |
Reads an 8-bit descriptor from the specified thread's address space, enforcing |
|
1191 |
checks on validity of source and destination if necessary. |
|
1192 |
||
1193 |
It is used especially by device drivers to transfer data from a user thread. |
|
1194 |
aDes might be accessed with user permission validation. |
|
1195 |
||
1196 |
@param aThread The thread from whose address space data is to be read. |
|
1197 |
@param aSrc Pointer to a source descriptor in the specified thread's address |
|
1198 |
space. This must not be NULL. |
|
1199 |
@param aDest Target descriptor |
|
1200 |
@param aOffset Offset in aSrc from where to start reading data. |
|
1201 |
||
1202 |
@return KErrNone, if sucessful; KErrBadDescriptor, if aPtr or aDes is an |
|
1203 |
invalid decriptor; KErrArgument if anOffset is negative; KErrDied if aThread |
|
1204 |
is dead. |
|
1205 |
*/ |
|
1206 |
inline TInt Kern::ThreadDesRead(DThread* aThread, const TAny* aSrc, TDes8& aDest, TInt aOffset) |
|
1207 |
{ return ThreadDesRead(aThread,aSrc,aDest,aOffset,KChunkShiftBy0); } |
|
1208 |
||
1209 |
||
1210 |
||
1211 |
||
1212 |
/** |
|
1213 |
Writes an 8-bit descriptor to the specified thread's address space, enforcing |
|
1214 |
checks on validity of source and destination if necessary. |
|
1215 |
||
1216 |
It is used especially by device drivers to transfer data to a user thread. |
|
1217 |
aDes might be accessed with user permission validation. |
|
1218 |
||
1219 |
@param aThread The thread into whose address space data is to be written. |
|
1220 |
@param aDest Pointer to a target descriptor in the specified thread's address |
|
1221 |
space. It must not be NULL |
|
1222 |
@param aSrc Source descriptor |
|
1223 |
@param aOffset Offset in aDest to start writing data to. |
|
1224 |
@param aOrigThread The thread on behalf of which this operation is performed (eg client of device driver). |
|
1225 |
||
1226 |
@return KErrNone, if sucessful; KErrBadDescriptor, if aPtr or aDes is an |
|
1227 |
invalid decriptor; KErrArgument if anOffset is negative; KErrDied if aThread |
|
1228 |
is dead. |
|
1229 |
*/ |
|
1230 |
inline TInt Kern::ThreadDesWrite(DThread* aThread, TAny* aDest, const TDesC8& aSrc, TInt aOffset, DThread* aOrigThread) |
|
1231 |
{ return ThreadDesWrite(aThread,aDest,aSrc,aOffset,KChunkShiftBy0,aOrigThread); } |
|
1232 |
||
1233 |
||
1234 |
/** |
|
1235 |
Register the function used to implement Kern::NanoWait. |
|
1236 |
||
1237 |
This should be called from the variant to supply an accurate implementation for Kern::NanoWait. |
|
1238 |
||
1239 |
@return The previous implemention. |
|
1240 |
||
1241 |
@see Kern::NanoWait |
|
1242 |
||
1243 |
@publishedPartner |
|
1244 |
@released |
|
1245 |
*/ |
|
1246 |
inline TNanoWaitHandler Kern::SetNanoWaitHandler(TNanoWaitHandler aHandler) |
|
1247 |
{ |
|
1248 |
return (TNanoWaitHandler) SetHook(EHookNanoWait, (TKernelHookFn)aHandler, ETrue); |
|
1249 |
} |
|
1250 |
||
1251 |
||
1252 |
||
1253 |
/** |
|
1254 |
Register the function used to read the initial system time. |
|
1255 |
||
1256 |
This may be called from the variant to override the default behaviour. If so it |
|
1257 |
should be called in phase 1 of initialisation. |
|
1258 |
||
1259 |
@return The previous implemention. |
|
1260 |
||
1261 |
@publishedPartner |
|
1262 |
@released |
|
1263 |
*/ |
|
1264 |
inline TInitialTimeHandler Kern::SetInitialTimeHandler(TInitialTimeHandler aHandler) |
|
1265 |
{ |
|
1266 |
return (TInitialTimeHandler) SetHook(EHookInitialTime, (TKernelHookFn)aHandler, ETrue); |
|
1267 |
} |
|
1268 |
||
1269 |
||
1270 |
||
1271 |
struct SMiscNotifierQ; |
|
1272 |
class TMiscNotifierMgr; |
|
1273 |
class DObject : public DBase |
|
1274 |
/** |
|
1275 |
Base class for reference-counted kernel side objects. |
|
1276 |
||
1277 |
@publishedPartner |
|
1278 |
@released |
|
1279 |
*/ |
|
1280 |
// NOTE: Any changes to the structure of this class should be duplicated in class DMonObject |
|
1281 |
{ |
|
1282 |
public: |
|
1283 |
||
1284 |
/** |
|
1285 |
Defines a set of bit values that are returned from calls |
|
1286 |
to DObject::Close(), or by an overriding implementation of Close() provided |
|
1287 |
by a derived class. |
|
1288 |
||
1289 |
The values describe the state of the object on return from Close(). |
|
1290 |
*/ |
|
1291 |
enum TCloseReturn |
|
1292 |
{ |
|
1293 |
||
1294 |
/** |
|
1295 |
If set, indicates that the object has been deleted. |
|
1296 |
*/ |
|
1297 |
EObjectDeleted=1, |
|
1298 |
||
1299 |
/** |
|
1300 |
If set, indicates that the last reference |
|
1301 |
from a user process has been removed. |
|
1302 |
||
1303 |
Note that this only applies to DLibrary objects. |
|
1304 |
*/ |
|
1305 |
EObjectUnmapped=2, |
|
1306 |
}; |
|
1307 |
||
1308 |
/** @internalComponent */ |
|
1309 |
enum TObjectProtection |
|
1310 |
{ |
|
1311 |
ELocal=0, // Private |
|
1312 |
EProtected, |
|
1313 |
EGlobal, // Public |
|
1314 |
}; |
|
1315 |
||
1316 |
/** @internalComponent */ |
|
1317 |
enum TObjectFlags |
|
1318 |
{ |
|
1319 |
EObjectExtraReference = (1<<0), |
|
1320 |
EObjectDeferKernelCodesegCleanup = (1<<1) |
|
1321 |
}; |
|
1322 |
||
1323 |
public: |
|
1324 |
/** @internalComponent */ |
|
1325 |
inline TInt Inc() { return __e32_atomic_tas_ord32(&iAccessCount, 1, 1, 0); } |
|
1326 |
||
1327 |
/** @internalComponent */ |
|
1328 |
inline TInt Dec() { return __e32_atomic_tas_ord32(&iAccessCount, 1, -1, 0); } |
|
1329 |
||
1330 |
IMPORT_C DObject(); |
|
1331 |
IMPORT_C ~DObject(); |
|
1332 |
||
1333 |
/** |
|
1334 |
Opens this kernel side reference-counted object. |
|
1335 |
||
1336 |
Opening a reference-counted object increments its reference count |
|
1337 |
by one. The increment operation is done atomically. |
|
1338 |
||
1339 |
@return KErrNone, if the increment operation succeeds; |
|
1340 |
KErrGeneral, if the reference count value is either zero |
|
1341 |
or negative before performing the increment operation; |
|
1342 |
the reference count is initialised to 1 on construction |
|
1343 |
of the object, and can never be less than 1. |
|
1344 |
*/ |
|
1345 |
inline TInt Open() { return(Inc()?KErrNone:KErrGeneral); } |
|
1346 |
IMPORT_C void CheckedOpen(); |
|
1347 |
IMPORT_C virtual TInt Close(TAny* aPtr); |
|
1348 |
IMPORT_C virtual TInt RequestUserHandle(DThread* aThread, TOwnerType aType); |
|
1349 |
IMPORT_C virtual TInt RequestUserHandle(DThread* aThread, TOwnerType aType, TUint aAttr); |
|
1350 |
IMPORT_C virtual TInt AddToProcess(DProcess* aProcess); |
|
1351 |
IMPORT_C virtual TInt AddToProcess(DProcess* aProcess, TUint aAttr); |
|
1352 |
IMPORT_C TInt AsyncClose(); |
|
1353 |
IMPORT_C virtual void DoAppendName(TDes& aName); |
|
1354 |
IMPORT_C void DoAppendFullName(TDes& aFullName); |
|
1355 |
IMPORT_C void Name(TDes& aName); |
|
1356 |
IMPORT_C void AppendName(TDes& aName); |
|
1357 |
IMPORT_C void FullName(TDes& aFullName); |
|
1358 |
IMPORT_C void AppendFullName(TDes& aFullName); |
|
1359 |
IMPORT_C TInt SetName(const TDesC* aName); |
|
1360 |
IMPORT_C TInt SetOwner(DObject* aOwner); |
|
1361 |
IMPORT_C void TraceAppendName(TDes8& aName, TBool aLock); |
|
1362 |
IMPORT_C void TraceAppendFullName(TDes8& aFullName, TBool aLock); |
|
1363 |
inline DObject* Owner(); |
|
1364 |
inline TInt AccessCount(); |
|
1365 |
inline TInt UniqueID(); |
|
1366 |
inline HBuf* NameBuf(); |
|
1367 |
inline void SetProtection(TObjectProtection aProtection); |
|
1368 |
inline TUint Protection(); |
|
1369 |
void BaseName(TDes& aName); |
|
1370 |
inline TUint64 ObjectId() const; /**< @internalComponent */ |
|
1371 |
public: |
|
1372 |
/** @internalComponent */ |
|
1373 |
TInt iAccessCount; // must be first |
|
1374 |
||
1375 |
/** @internalComponent */ |
|
1376 |
DObject* iOwner; |
|
1377 |
||
1378 |
/** A TObjectType value with one added |
|
1379 |
@internalComponent */ |
|
1380 |
TUint8 iContainerID; |
|
1381 |
||
1382 |
/** A TObjectProtection value |
|
1383 |
@internalComponent */ |
|
1384 |
TUint8 iProtection; |
|
1385 |
||
1386 |
/** Bit field made of values from TObjectFlags |
|
1387 |
@internalComponent */ |
|
1388 |
TUint8 iObjectFlags; |
|
1389 |
||
1390 |
/** @internalComponent */ |
|
1391 |
TUint8 iNotQLow; |
|
1392 |
||
1393 |
/** @internalComponent */ |
|
1394 |
HBuf* iName; |
|
1395 |
||
1396 |
/** A unique ID. |
|
1397 |
@internalComponent */ |
|
1398 |
TUint64 iObjectId; |
|
1399 |
||
1400 |
/** @internalComponent */ |
|
1401 |
// SMiscNotifierQ* iNotifierQ; |
|
1402 |
||
1403 |
public: |
|
1404 |
static NFastMutex Lock; |
|
1405 |
private: |
|
1406 |
inline SMiscNotifierQ* NotifierQ() const; /**< @internalComponent */ |
|
1407 |
inline void SetNotifierQ(SMiscNotifierQ*); /**< @internalComponent */ |
|
1408 |
inline TBool HasNotifierQ() const; /**< @internalComponent */ |
|
1409 |
private: |
|
1410 |
static TUint64 NextObjectId; |
|
1411 |
||
1412 |
friend class DObjectCon; |
|
1413 |
friend class RObjectIx; |
|
1414 |
friend class Monitor; |
|
1415 |
friend class Debugger; |
|
1416 |
friend void Kern::AppendFormat(TDes8&, const char*, VA_LIST); |
|
1417 |
friend class K; |
|
1418 |
friend struct SMiscNotifierQ; |
|
1419 |
friend class TMiscNotifierMgr; |
|
1420 |
}; |
|
1421 |
||
1422 |
/** |
|
1423 |
Gets the number of open references to |
|
1424 |
this reference-counted kernel side object. |
|
1425 |
||
1426 |
@return The number of open references. |
|
1427 |
*/ |
|
1428 |
inline TInt DObject::AccessCount() |
|
1429 |
{ return iAccessCount; } |
|
1430 |
||
1431 |
/** |
|
1432 |
Gets a pointer to the kernel-side reference counted object |
|
1433 |
that owns this kernel side reference-counted object. |
|
1434 |
||
1435 |
@return A pointer to the owning reference-counted object. |
|
1436 |
This is NULL, if there is no owner. |
|
1437 |
*/ |
|
1438 |
inline DObject* DObject::Owner() |
|
1439 |
{ return iOwner; } |
|
1440 |
||
1441 |
/** @internalComponent */ |
|
1442 |
inline HBuf* DObject::NameBuf() |
|
1443 |
{ return iName; } |
|
1444 |
||
1445 |
/** @internalComponent */ |
|
1446 |
inline TInt DObject::UniqueID() |
|
1447 |
{return(iContainerID);} |
|
1448 |
||
1449 |
/** @internalComponent */ |
|
1450 |
inline TUint DObject::Protection() |
|
1451 |
{return (TUint8)iProtection;} |
|
1452 |
||
1453 |
/** @internalComponent */ |
|
1454 |
inline void DObject::SetProtection(TObjectProtection aProtection) |
|
1455 |
{iProtection=(TUint8)aProtection;} |
|
1456 |
||
1457 |
/******************************************** |
|
1458 |
* Device driver base classes |
|
1459 |
********************************************/ |
|
1460 |
||
1461 |
/** |
|
1462 |
@publishedPartner |
|
1463 |
@released |
|
1464 |
||
1465 |
If set, it indicates that the use of units is valid. |
|
1466 |
||
1467 |
@see DLogicalDevice::iParsemask |
|
1468 |
*/ |
|
1469 |
const TUint KDeviceAllowUnit=0x01; |
|
1470 |
||
1471 |
||
1472 |
||
1473 |
||
1474 |
/** |
|
1475 |
@publishedPartner |
|
1476 |
@released |
|
1477 |
||
1478 |
If set, then an LDD requires a PDD. |
|
1479 |
||
1480 |
@see DLogicalDevice::iParsemask |
|
1481 |
*/ |
|
1482 |
const TUint KDeviceAllowPhysicalDevice=0x02; |
|
1483 |
||
1484 |
||
1485 |
||
1486 |
||
1487 |
/** |
|
1488 |
@publishedPartner |
|
1489 |
@released |
|
1490 |
||
1491 |
If set, it indicates that the use of additional information is allowed. |
|
1492 |
||
1493 |
@see DLogicalDevice::iParsemask |
|
1494 |
*/ |
|
1495 |
const TUint KDeviceAllowInfo=0x04; |
|
1496 |
||
1497 |
||
1498 |
||
1499 |
||
1500 |
/** |
|
1501 |
@publishedPartner |
|
1502 |
@released |
|
1503 |
||
1504 |
Combines all of: KDeviceAllowUnit, KDeviceAllowPhysicalDevice and KDeviceAllowInfo. |
|
1505 |
||
1506 |
@see DLogicalDevice::iParsemask |
|
1507 |
*/ |
|
1508 |
const TUint KDeviceAllowAll=(KDeviceAllowUnit|KDeviceAllowPhysicalDevice|KDeviceAllowInfo); |
|
1509 |
||
1510 |
||
1511 |
||
1512 |
||
1513 |
/** |
|
1514 |
@publishedPartner |
|
1515 |
@released |
|
1516 |
||
1517 |
A flag bit that can set in the aMode parameter passed to the |
|
1518 |
Kern::ThreadDesWrite(DThread* ,TAny*, const TDesC8&, TInt, TInt aMode, DThread*); |
|
1519 |
variant. |
|
1520 |
||
1521 |
It ensures that the length of data copied to the target descriptor is |
|
1522 |
truncated, if necesary, to prevent the maximum length of that target descriptor |
|
1523 |
from being exceeded. |
|
1524 |
||
1525 |
@see Kern::ThreadDesWrite() |
|
1526 |
*/ |
|
1527 |
const TInt KTruncateToMaxLength=(TInt)0x40000000; |
|
1528 |
||
1529 |
||
1530 |
||
1531 |
||
1532 |
/** |
|
1533 |
@publishedPartner |
|
1534 |
@released |
|
1535 |
||
1536 |
Used internally by Symbian OS. |
|
1537 |
*/ |
|
1538 |
const TInt KCheckLocalAddress=(TInt)0x20000000; |
|
1539 |
||
1540 |
||
1541 |
||
1542 |
||
1543 |
/** |
|
1544 |
@internalTechnology |
|
1545 |
@prototype |
|
1546 |
||
1547 |
A flag bit that can set in the aMode parameter passed to the |
|
1548 |
Kern::ThreadDesWrite(DThread* ,TAny*, const TDesC8&, TInt, TInt aMode, DThread*); |
|
1549 |
variant. |
|
1550 |
||
1551 |
It indicates that the descriptor header should not be updated to reflect the new length. |
|
1552 |
||
1553 |
@see Kern::ThreadDesWrite() |
|
1554 |
*/ |
|
1555 |
const TInt KDoNotUpdateDesLength=(TInt)0x10000000; |
|
1556 |
||
1557 |
class DLogicalDevice; |
|
1558 |
class DPhysicalDevice; |
|
1559 |
||
1560 |
||
1561 |
||
1562 |
||
1563 |
/** |
|
1564 |
@publishedPartner |
|
1565 |
@released |
|
1566 |
||
1567 |
The abstract base class for a logical channel. |
|
1568 |
*/ |
|
1569 |
class DLogicalChannelBase : public DObject |
|
1570 |
{ |
|
1571 |
public: |
|
1572 |
IMPORT_C virtual ~DLogicalChannelBase(); |
|
1573 |
public: |
|
1574 |
/** |
|
1575 |
Handles a client request in the client context. |
|
1576 |
||
1577 |
The function is called from within the kernel, but the implementation |
|
1578 |
must be provided by external code. |
|
1579 |
*/ |
|
1580 |
virtual TInt Request(TInt aReqNo, TAny* a1, TAny* a2)=0; |
|
1581 |
IMPORT_C virtual TInt DoCreate(TInt aUnit, const TDesC8* aInfo, const TVersion& aVer); |
|
1582 |
public: |
|
1583 |
DLogicalDevice* iDevice; |
|
1584 |
DPhysicalDevice* iPhysicalDevice; |
|
1585 |
DBase* iPdd; |
|
1586 |
}; |
|
1587 |
||
1588 |
||
1589 |
||
1590 |
||
1591 |
/** |
|
1592 |
@publishedPartner |
|
1593 |
@released |
|
1594 |
||
1595 |
The abstract base class for an LDD factory object. |
|
1596 |
*/ |
|
1597 |
class DLogicalDevice : public DObject |
|
1598 |
{ |
|
1599 |
public: |
|
1600 |
IMPORT_C virtual ~DLogicalDevice(); |
|
1601 |
IMPORT_C virtual TBool QueryVersionSupported(const TVersion& aVer) const; |
|
1602 |
IMPORT_C virtual TBool IsAvailable(TInt aUnit, const TDesC* aDriver, const TDesC8* aInfo) const; |
|
1603 |
TInt ChannelCreate(DLogicalChannelBase*& pC, TChannelCreateInfo& aInfo); |
|
1604 |
TInt FindPhysicalDevice(DLogicalChannelBase* aChannel, TChannelCreateInfo& aInfo); |
|
1605 |
||
1606 |
||
1607 |
/** |
|
1608 |
Second stage constructor for derived objects. |
|
1609 |
This must at least set a name for the driver object. |
|
1610 |
||
1611 |
@return KErrNone or standard error code. |
|
1612 |
*/ |
|
1613 |
virtual TInt Install()=0; |
|
1614 |
||
1615 |
||
1616 |
/** |
|
1617 |
Gets the driver's capabilities. |
|
1618 |
||
1619 |
This is called in the response to an RDevice::GetCaps() request. |
|
1620 |
||
1621 |
@param aDes A user-side descriptor into which capabilities information is to be wriiten. |
|
1622 |
*/ |
|
1623 |
virtual void GetCaps(TDes8& aDes) const =0; |
|
1624 |
||
1625 |
||
1626 |
/** |
|
1627 |
Called by the kernel's device driver framework to create a Logical Channel. |
|
1628 |
This is called in the context of the user thread (client) which requested the creation of a Logical Channel |
|
1629 |
(e.g. through a call to RBusLogicalChannel::DoCreate). |
|
1630 |
The thread is in a critical section. |
|
1631 |
||
1632 |
@param aChannel Set to point to the created Logical Channel |
|
1633 |
||
1634 |
@return KErrNone or standard error code. |
|
1635 |
*/ |
|
1636 |
virtual TInt Create(DLogicalChannelBase*& aChannel)=0; |
|
1637 |
||
1638 |
||
1639 |
public: |
|
1640 |
/** |
|
1641 |
The version of this factory object. |
|
1642 |
||
1643 |
This is used to check that an LDD and PDD are compatible. |
|
1644 |
Typically, this is set by the constructor of a derived class. |
|
1645 |
*/ |
|
1646 |
TVersion iVersion; |
|
1647 |
||
1648 |
||
1649 |
/** |
|
1650 |
A bitmask that indicates device properties. |
|
1651 |
||
1652 |
This can take the following values: |
|
1653 |
KDeviceAllowUnit |
|
1654 |
KDeviceAllowPhysicalDevice |
|
1655 |
KDeviceAllowInfo |
|
1656 |
KDeviceAllowAll |
|
1657 |
||
1658 |
Typically, this is set by the constructor of a derived class. |
|
1659 |
||
1660 |
@see RBusLogicalChannel::DoCreate() |
|
1661 |
@see KDeviceAllowUnit |
|
1662 |
@see KDeviceAllowPhysicalDevice |
|
1663 |
@see KDeviceAllowInfo |
|
1664 |
@see KDeviceAllowAll |
|
1665 |
*/ |
|
1666 |
TUint iParseMask; |
|
1667 |
||
1668 |
||
1669 |
/** |
|
1670 |
Indicates which units are valid. |
|
1671 |
||
1672 |
If units are allowed, i.e. the KDeviceAllowUnit bit is set in iParseMask, |
|
1673 |
then this mask indicates which of the units (from 0 to 31) are valid. |
|
1674 |
||
1675 |
The DPhysicalDevice object associated with the PDD has a similar mask, |
|
1676 |
and both masks are used to indicate which units the LDD-PDD pair |
|
1677 |
can handle. |
|
1678 |
||
1679 |
Typically, this is set by the constructor of a derived class. |
|
1680 |
||
1681 |
@see KDeviceAllowUnit |
|
1682 |
*/ |
|
1683 |
TUint iUnitsMask; |
|
1684 |
||
1685 |
||
1686 |
/** |
|
1687 |
Pointer to the DCodeSeg object which contains the executable code |
|
1688 |
for this LDD. |
|
1689 |
*/ |
|
1690 |
DCodeSeg* iCodeSeg; |
|
1691 |
||
1692 |
||
1693 |
/** |
|
1694 |
Number of DLogicalChannelBase objects currently in existence which |
|
1695 |
have been created from this LDD. |
|
1696 |
*/ |
|
1697 |
TInt iOpenChannels; |
|
1698 |
}; |
|
1699 |
||
1700 |
/** @internalComponent */ |
|
1701 |
typedef DLogicalDevice* (*TLogicalDeviceNew)(); |
|
1702 |
||
1703 |
||
1704 |
||
1705 |
||
1706 |
/** |
|
1707 |
@publishedPartner |
|
1708 |
@released |
|
1709 |
||
1710 |
The abstract base class for a PDD factory object. |
|
1711 |
*/ |
|
1712 |
class DPhysicalDevice : public DObject |
|
1713 |
{ |
|
1714 |
public: |
|
1715 |
enum TInfoFunction |
|
1716 |
{ |
|
1717 |
EPriority=0, |
|
1718 |
||
1719 |
/** if implemented (i.e. Info(EMediaDriverPersistent) returns KErrNone) implies the media driver |
|
1720 |
created by this DPhysicalDevice will not be unloaded when the peripheral bus is powered down */ |
|
1721 |
EMediaDriverPersistent=1, |
|
1722 |
}; |
|
1723 |
public: |
|
1724 |
IMPORT_C virtual ~DPhysicalDevice(); |
|
1725 |
IMPORT_C virtual TBool QueryVersionSupported(const TVersion& aVer) const; |
|
1726 |
IMPORT_C virtual TBool IsAvailable(TInt aUnit, const TDesC8* aInfo) const; |
|
1727 |
||
1728 |
/** |
|
1729 |
Second stage constructor for derived objects. |
|
1730 |
This must at least set a name for the driver object. |
|
1731 |
||
1732 |
@return KErrNone or standard error code. |
|
1733 |
*/ |
|
1734 |
virtual TInt Install() =0; |
|
1735 |
||
1736 |
/** |
|
1737 |
Returns the drivers capabilities. This is not used by the Symbian OS device driver framework |
|
1738 |
but may be useful for the LDD to use. |
|
1739 |
||
1740 |
@param aDes Descriptor to write capabilities information into |
|
1741 |
*/ |
|
1742 |
virtual void GetCaps(TDes8& aDes) const =0; |
|
1743 |
||
1744 |
/** |
|
1745 |
Called by the kernel's device driver framework to create a Physical Channel. |
|
1746 |
This is called in the context of the user thread (client) which requested the creation of a Logical Channel |
|
1747 |
(E.g. through a call to RBusLogicalChannel::DoCreate) |
|
1748 |
The thread is in a critical section. |
|
1749 |
||
1750 |
@param aChannel Set to point to the created Physical Channel |
|
1751 |
@param aUnit The unit argument supplied by the client to RBusLogicalChannel::DoCreate |
|
1752 |
@param aInfo The info argument supplied by the client to RBusLogicalChannel::DoCreate |
|
1753 |
@param aVer The version number of the Logical Channel which will use this Physical Channel |
|
1754 |
||
1755 |
@return KErrNone or standard error code. |
|
1756 |
*/ |
|
1757 |
virtual TInt Create(DBase*& aChannel, TInt aUnit, const TDesC8* aInfo, const TVersion& aVer) =0; |
|
1758 |
||
1759 |
/** |
|
1760 |
Called by the kernel's device driver framework to check if this PDD is suitable for use with a Logical Channel. |
|
1761 |
This is called in the context of the user thread (client) which requested the creation of a Logical Channel |
|
1762 |
(E.g. through a call to RBusLogicalChannel::DoCreate) |
|
1763 |
The thread is in a critical section. |
|
1764 |
||
1765 |
@param aUnit The unit argument supplied by the client to RBusLogicalChannel::DoCreate |
|
1766 |
@param aInfo The info argument supplied by the client to RBusLogicalChannel::DoCreate |
|
1767 |
@param aVer The version number of the Logical Channel which will use this Physical Channel |
|
1768 |
||
1769 |
@return KErrNone or standard error code. |
|
1770 |
*/ |
|
1771 |
virtual TInt Validate(TInt aUnit, const TDesC8* aInfo, const TVersion& aVer) =0; |
|
1772 |
IMPORT_C virtual TInt Info(TInt aFunction, TAny* a1); |
|
1773 |
public: |
|
1774 |
TVersion iVersion; |
|
1775 |
TUint iUnitsMask; |
|
1776 |
DCodeSeg* iCodeSeg; |
|
1777 |
}; |
|
1778 |
||
1779 |
||
1780 |
||
1781 |
||
1782 |
/** @internalComponent */ |
|
1783 |
typedef DPhysicalDevice* (*TPhysicalDeviceNew)(); |
|
1784 |
||
1785 |
// Utility stuff for PDD finding |
|
1786 |
||
1787 |
/** @internalTechnology */ |
|
1788 |
struct SPhysicalDeviceEntry |
|
1789 |
{ |
|
1790 |
TInt iPriority; |
|
1791 |
DPhysicalDevice* iPhysicalDevice; |
|
1792 |
}; |
|
1793 |
||
1794 |
/** @internalTechnology */ |
|
1795 |
class RPhysicalDeviceArray : public RArray<SPhysicalDeviceEntry> |
|
1796 |
{ |
|
1797 |
public: |
|
1798 |
IMPORT_C RPhysicalDeviceArray(); |
|
1799 |
IMPORT_C void Close(); |
|
1800 |
IMPORT_C TInt GetDriverList(const TDesC& aMatch, TInt aUnit, const TDesC8* aInfo, const TVersion& aVersion); |
|
1801 |
}; |
|
1802 |
||
1803 |
/******************************************** |
|
1804 |
* Kernel-side messages and message queues. |
|
1805 |
********************************************/ |
|
1806 |
class TMessageQue; |
|
1807 |
||
1808 |
||
1809 |
||
1810 |
||
1811 |
/** |
|
1812 |
@publishedPartner |
|
1813 |
@released |
|
1814 |
||
1815 |
The base class for a kernel side message. |
|
1816 |
||
1817 |
This is a means of communication between Symbian OS threads |
|
1818 |
executing kernel-side code. |
|
1819 |
*/ |
|
1820 |
class TMessageBase : public SDblQueLink |
|
1821 |
{ |
|
1822 |
public: |
|
1823 |
/** @internalComponent */ |
|
1824 |
enum TState {EFree,EDelivered,EAccepted}; |
|
1825 |
public: |
|
1826 |
TMessageBase() : iState(EFree), iQueue(NULL) {} |
|
1827 |
IMPORT_C void Send(TMessageQue* aQ); |
|
1828 |
IMPORT_C TInt SendReceive(TMessageQue* aQ); |
|
1829 |
IMPORT_C void Forward(TMessageQue* aQ, TBool aReceiveNext); |
|
1830 |
IMPORT_C void Complete(TInt aResult, TBool aReceiveNext); |
|
1831 |
IMPORT_C void Cancel(); /**< @internalComponent */ |
|
1832 |
IMPORT_C void PanicClient(const TDesC& aCategory, TInt aReason); |
|
1833 |
public: |
|
1834 |
IMPORT_C DThread* Client(); |
|
1835 |
public: |
|
1836 |
TUint8 iState; /**< @internalComponent */ |
|
1837 |
TMessageQue* iQueue; /**< @internalComponent */ |
|
1838 |
NFastSemaphore iSem; /**< @internalComponent */ |
|
1839 |
TInt iValue; /**< @internalComponent */ // msg id/return code |
|
1840 |
}; |
|
1841 |
||
1842 |
||
1843 |
||
1844 |
||
1845 |
/** |
|
1846 |
@publishedPartner |
|
1847 |
@released |
|
1848 |
||
1849 |
A queue for kernel-side messages. |
|
1850 |
||
1851 |
Objects of this type consist of a DFC plus a doubly-linked list |
|
1852 |
of received messages. |
|
1853 |
*/ |
|
1854 |
class TMessageQue : private TDfc |
|
1855 |
{ |
|
1856 |
public: |
|
1857 |
IMPORT_C TMessageQue(TDfcFn aFunction, TAny* aPtr, TDfcQue* aDfcQ, TInt aPriority); |
|
1858 |
IMPORT_C void Receive(); |
|
1859 |
IMPORT_C TMessageBase* Poll(); |
|
1860 |
IMPORT_C TMessageBase* Last(); |
|
1861 |
IMPORT_C void CompleteAll(TInt aResult); |
|
1862 |
using TDfc::SetDfcQ; |
|
1863 |
public: |
|
1864 |
inline static void Lock() {NKern::FMWait(&MsgLock);} /**< @internalComponent */ |
|
1865 |
inline static void Unlock() {NKern::FMSignal(&MsgLock);} /**< @internalComponent */ |
|
1866 |
inline void UnlockAndKick() {Enque(&MsgLock);} /**< @internalComponent */ |
|
1867 |
public: |
|
1868 |
SDblQue iQ; /**< @internalComponent */ |
|
1869 |
TBool iReady; /**< @internalComponent */ |
|
1870 |
TMessageBase* iMessage; /**< @internalComponent */ |
|
1871 |
static NFastMutex MsgLock; /**< @internalComponent */ |
|
1872 |
friend class TMessageBase; |
|
1873 |
}; |
|
1874 |
||
1875 |
||
1876 |
||
1877 |
||
1878 |
/** |
|
1879 |
@publishedPartner |
|
1880 |
@released |
|
1881 |
||
1882 |
Synchronous kernel-side messages. |
|
1883 |
||
1884 |
There is one per thread, and the thread always blocks while the message is outstanding. |
|
1885 |
The iPtr field of a DFC points to the message. |
|
1886 |
*/ |
|
1887 |
class TThreadMessage : public TMessageBase |
|
1888 |
{ |
|
1889 |
public: |
|
1890 |
/** |
|
1891 |
Returns argument 0 as an integer. |
|
1892 |
*/ |
|
1893 |
inline TInt Int0() const {return (TInt)iArg[0];} |
|
1894 |
||
1895 |
/** |
|
1896 |
Returns argument 1 as an integer. |
|
1897 |
*/ |
|
1898 |
inline TInt Int1() const {return (TInt)iArg[1];} |
|
1899 |
||
1900 |
/** |
|
1901 |
Returns argument 2 as an integer. |
|
1902 |
*/ |
|
1903 |
inline TInt Int2() const {return (TInt)iArg[2];} |
|
1904 |
||
1905 |
/** |
|
1906 |
Returns argument 3 as an integer. |
|
1907 |
*/ |
|
1908 |
inline TInt Int3() const {return (TInt)iArg[3];} |
|
1909 |
||
1910 |
/** |
|
1911 |
Returns argument 0 as a pointer type. |
|
1912 |
*/ |
|
1913 |
inline TAny* Ptr0() const {return iArg[0];} |
|
1914 |
||
1915 |
/** |
|
1916 |
Returns argument 1 as a pointer type. |
|
1917 |
*/ |
|
1918 |
inline TAny* Ptr1() const {return iArg[1];} |
|
1919 |
||
1920 |
/** |
|
1921 |
Returns argument 2 as a pointer type. |
|
1922 |
*/ |
|
1923 |
inline TAny* Ptr2() const {return iArg[2];} |
|
1924 |
||
1925 |
/** |
|
1926 |
Returns argument 3 as a pointer type. |
|
1927 |
*/ |
|
1928 |
inline TAny* Ptr3() const {return iArg[3];} |
|
1929 |
public: |
|
1930 |
/** |
|
1931 |
Message arguments. |
|
1932 |
*/ |
|
1933 |
TAny* iArg[10]; // message arguments |
|
1934 |
}; |
|
1935 |
||
1936 |
||
1937 |
||
1938 |
||
1939 |
/** |
|
1940 |
@publishedPartner |
|
1941 |
@released |
|
1942 |
||
1943 |
An abstract class for a logical channel that provides a framework in which |
|
1944 |
user-side client requests are executed in the context of |
|
1945 |
a single kernel-side thread. |
|
1946 |
*/ |
|
1947 |
class DLogicalChannel : public DLogicalChannelBase |
|
1948 |
{ |
|
1949 |
public: |
|
1950 |
enum { |
|
1951 |
/** |
|
1952 |
Defines the smallest request number that Request() accepts. |
|
1953 |
Smaller request numbers will raise a panic. |
|
1954 |
*/ |
|
1955 |
EMinRequestId=(TInt)0xc0000000, |
|
1956 |
||
1957 |
/** |
|
1958 |
The value of the close message sent to the device driver thread |
|
1959 |
by Close(). |
|
1960 |
*/ |
|
1961 |
ECloseMsg=(TInt)0x80000000}; |
|
1962 |
public: |
|
1963 |
IMPORT_C DLogicalChannel(); |
|
1964 |
IMPORT_C virtual ~DLogicalChannel(); |
|
1965 |
IMPORT_C virtual TInt Close(TAny*); |
|
1966 |
IMPORT_C virtual TInt Request(TInt aReqNo, TAny* a1, TAny* a2); |
|
1967 |
IMPORT_C virtual TInt SendMsg(TMessageBase* aMsg); |
|
1968 |
||
1969 |
/** |
|
1970 |
Processes a message for this logical channel. |
|
1971 |
This function is called in the context of a DFC thread. |
|
1972 |
||
1973 |
@param aMsg The message to process. |
|
1974 |
The iValue member of this distinguishes the message type: |
|
1975 |
iValue==ECloseMsg, channel close message |
|
1976 |
iValue==KMaxTInt, a 'DoCancel' message |
|
1977 |
iValue>=0, a 'DoControl' message with function number equal to iValue |
|
1978 |
iValue<0, a 'DoRequest' message with function number equal to ~iValue |
|
1979 |
*/ |
|
1980 |
IMPORT_C virtual void HandleMsg(TMessageBase* aMsg)=0; |
|
1981 |
IMPORT_C void SetDfcQ(TDfcQue* aDfcQ); |
|
1982 |
public: |
|
1983 |
static void MsgQFunc(TAny* aPtr); |
|
1984 |
public: |
|
1985 |
TDfcQue* iDfcQ; |
|
1986 |
TMessageQue iMsgQ; |
|
1987 |
}; |
|
1988 |
||
1989 |
||
1990 |
||
1991 |
||
1992 |
/******************************************** |
|
1993 |
* Timers based on the system tick |
|
1994 |
********************************************/ |
|
1995 |
||
1996 |
/** |
|
1997 |
@publishedPartner |
|
1998 |
@released |
|
1999 |
||
2000 |
Defines the signature for a tick timer callback function. |
|
2001 |
*/ |
|
2002 |
typedef void (*TTickCallBack)(TAny* aPtr); |
|
2003 |
||
2004 |
||
2005 |
||
2006 |
||
2007 |
/** |
|
2008 |
@publishedPartner |
|
2009 |
@released |
|
2010 |
||
2011 |
Relative timer with the resolution of one Symbian OS tick (generally 1/64 second). |
|
2012 |
||
2013 |
Tick timers are general purpose interval timers which are used where there |
|
2014 |
is no need for high resolution or great accuracy. They correspond to the |
|
2015 |
timing functions available to user side code on EKA1 (User::After, |
|
2016 |
RTimer::After, RTimer::Lock). |
|
2017 |
||
2018 |
@see User::After() |
|
2019 |
@see RTimer::After() |
|
2020 |
@see RTimer::Lock() |
|
2021 |
*/ |
|
2022 |
class TTickLink : public SDeltaQueLink |
|
2023 |
{ |
|
2024 |
public: |
|
2025 |
IMPORT_C TTickLink(); |
|
2026 |
IMPORT_C void Periodic(TInt aPeriod, TTickCallBack aCallBack, TAny* aPtr); |
|
2027 |
IMPORT_C void OneShot(TInt aTime, TTickCallBack aCallBack, TAny* aPtr); |
|
2028 |
IMPORT_C void Lock(TInt aTicks, TTickCallBack aCallBack, TAny* aPtr); |
|
2029 |
IMPORT_C void Cancel(); |
|
2030 |
void DoCancel(); |
|
2031 |
TInt GetNextLock(TTimerLockSpec aMark, TInt &aTickCount) const; |
|
2032 |
public: |
|
2033 |
TInt iPeriod; /**< @internalComponent */ |
|
2034 |
TAny *iPtr; /**< @internalComponent */ |
|
2035 |
TTickCallBack iCallBack; /**< @internalComponent */ |
|
2036 |
Int64 iLastLock; /**< @internalComponent */ |
|
2037 |
}; |
|
2038 |
||
2039 |
||
2040 |
||
2041 |
||
2042 |
/** |
|
2043 |
@publishedPartner |
|
2044 |
@released |
|
2045 |
||
2046 |
Defines the signature for a second timer callback function. |
|
2047 |
||
2048 |
@see TSecondLink |
|
2049 |
*/ |
|
2050 |
typedef void (*TSecondCallBack)(TAny* aPtr); |
|
2051 |
||
2052 |
||
2053 |
||
2054 |
||
2055 |
/** |
|
2056 |
@publishedPartner |
|
2057 |
@released |
|
2058 |
||
2059 |
Absolute timer with a resolution of 1 second. |
|
2060 |
||
2061 |
Second timers are used when an event needs to occur at a specific date and |
|
2062 |
time of day, rather than after a specified interval. They have a resolution of |
|
2063 |
1 second. |
|
2064 |
||
2065 |
They are typically used for user alarms, and, if necessary, will power up |
|
2066 |
the system at the expiry time. |
|
2067 |
*/ |
|
2068 |
class TSecondLink : public SDblQueLink |
|
2069 |
{ |
|
2070 |
public: |
|
2071 |
IMPORT_C TSecondLink(); |
|
2072 |
IMPORT_C TInt At(const TTimeK& aUTCTime, TSecondCallBack aCallBack, TAny* aPtr); |
|
2073 |
IMPORT_C void Cancel(); |
|
2074 |
public: |
|
2075 |
Int64 iTime; /**< @internalComponent */ |
|
2076 |
TAny* iPtr; /**< @internalComponent */ |
|
2077 |
TSecondCallBack iCallBack; /**< @internalComponent */ |
|
2078 |
}; |
|
2079 |
||
2080 |
||
2081 |
||
2082 |
||
2083 |
/** |
|
2084 |
@publishedPartner |
|
2085 |
@released |
|
2086 |
||
2087 |
Defines the signature for an inactivity timer callback function. |
|
2088 |
||
2089 |
@see TInactivityLink |
|
2090 |
*/ |
|
2091 |
typedef void (*TInactivityCallBack)(TAny*); |
|
2092 |
||
2093 |
||
2094 |
||
2095 |
||
2096 |
/** |
|
2097 |
@publishedPartner |
|
2098 |
@released |
|
2099 |
||
2100 |
Inactivity timer. |
|
2101 |
||
2102 |
Inactivity timers are used to detect a specified period of user inactivity, |
|
2103 |
for example to enable device auto power down or screen saver functionality. |
|
2104 |
*/ |
|
2105 |
class TInactivityLink : public SDblQueLink |
|
2106 |
{ |
|
2107 |
public: |
|
2108 |
IMPORT_C TInactivityLink(); |
|
2109 |
IMPORT_C TInt Start(TInt aSeconds, TInactivityCallBack aCallBack, TAny* aPtr); |
|
2110 |
IMPORT_C void Cancel(); |
|
2111 |
public: |
|
2112 |
TUint32 iTime; /**< @internalComponent */ // expiry time in ticks |
|
2113 |
TAny* iPtr; /**< @internalComponent */ |
|
2114 |
TInactivityCallBack iCallBack; /**< @internalComponent */ |
|
2115 |
}; |
|
2116 |
||
2117 |
/******************************************** |
|
2118 |
* Internal RAM drive |
|
2119 |
********************************************/ |
|
2120 |
||
2121 |
/** |
|
2122 |
@internalTechnology |
|
2123 |
*/ |
|
2124 |
class TInternalRamDrive |
|
2125 |
{ |
|
2126 |
public: |
|
2127 |
static TInt Create(); |
|
2128 |
IMPORT_C static TLinAddr Base(); |
|
2129 |
IMPORT_C static TInt Size(); |
|
2130 |
IMPORT_C static TInt MaxSize(); |
|
2131 |
IMPORT_C static TInt Adjust(TInt aNewSize); |
|
2132 |
IMPORT_C static void Lock(); |
|
2133 |
IMPORT_C static void Unlock(); |
|
2134 |
IMPORT_C static void Wait(); |
|
2135 |
IMPORT_C static void Signal(); |
|
2136 |
public: |
|
2137 |
static DMutex* Mutex; |
|
2138 |
friend class Monitor; |
|
2139 |
}; |
|
2140 |
||
2141 |
/********************************************/ |
|
2142 |
||
2143 |
/** List of all supported events. |
|
2144 |
||
2145 |
By default, all events, except the explicitly mentioned ones, are sent only |
|
2146 |
if the kernel is built with __DEBUGGER_SUPPORT__ defined. |
|
2147 |
||
2148 |
This event set may be extended in the future, so clients should handle |
|
2149 |
unknown events gracefully. |
|
2150 |
||
2151 |
@see DKernelEventHandler |
|
2152 |
@publishedPartner |
|
2153 |
@released |
|
2154 |
*/ |
|
2155 |
enum TKernelEvent |
|
2156 |
{ |
|
2157 |
/** |
|
2158 |
Event delivered when a user-side software exception occurs. |
|
2159 |
This event is always sent. |
|
2160 |
The following conditions are true: |
|
2161 |
- a1 contains a TExcType instance. |
|
2162 |
- The current thread is the thread taking the exception. |
|
2163 |
*/ |
|
2164 |
EEventSwExc, |
|
2165 |
||
2166 |
/** |
|
2167 |
Event delivered when a hardware exception occurs. |
|
2168 |
This event is always sent. |
|
2169 |
The following conditions are true: |
|
2170 |
- a1 points to the CPU-specific structure stored on the |
|
2171 |
stack where the processor state has been saved. For ARM, |
|
2172 |
the structure is TArmExcInfo. |
|
2173 |
- The current thread is the thread taking the exception. |
|
2174 |
On exit, use DKernelEventHandler::EExcHandled to indicate event |
|
2175 |
handled. |
|
2176 |
*/ |
|
2177 |
EEventHwExc, |
|
2178 |
||
2179 |
/** |
|
2180 |
Event delivered when a process is created (i.e. during a call to |
|
2181 |
RProcess::Create or Kern::ProcessCreate()). |
|
2182 |
The following conditions are true: |
|
2183 |
- a1 points to the process being created. |
|
2184 |
- a2 points to the creator thread (which may not be the current thread). |
|
2185 |
In some case the creator thread can not be reliably determined and a2 |
|
2186 |
will be set to NULL. |
|
2187 |
- The process being created is partly constructed (no threads and no chunks yet). |
|
2188 |
*/ |
|
2189 |
EEventAddProcess, |
|
2190 |
||
2191 |
/** |
|
2192 |
Event delivered after a process attribute change. Currently this applies |
|
2193 |
only to process renaming and address space change (chunk addition/removal) |
|
2194 |
but may be extended in the future. |
|
2195 |
The following conditions are true: |
|
2196 |
- a1 points to the process being modified. |
|
2197 |
- The process lock may be held |
|
2198 |
*/ |
|
2199 |
EEventUpdateProcess, |
|
2200 |
||
2201 |
/** |
|
2202 |
Event delivered when a process terminates. |
|
2203 |
The following conditions are true: |
|
2204 |
- a1 points to the process being terminated. |
|
2205 |
- The current thread is the kernel server thread. |
|
2206 |
- The process is partly destructed so its resources should be accessed |
|
2207 |
only after checking they still exist. |
|
2208 |
*/ |
|
2209 |
EEventRemoveProcess, |
|
2210 |
||
2211 |
/** |
|
2212 |
Event delivered when a user or kernel thread is created (i.e. during a call |
|
2213 |
to RProcess::Create(), RThread::Create() or Kern::ThreadCreate()). |
|
2214 |
The following conditions are true: |
|
2215 |
- a1 points to the thread being created. |
|
2216 |
- a2 points to the creator thread (which may not be the current thread). |
|
2217 |
- The thread being created is fully constructed but has not executed any code yet. |
|
2218 |
*/ |
|
2219 |
EEventAddThread, |
|
2220 |
||
2221 |
/** |
|
2222 |
Event delivered when a user or kernel thread is scheduled for the first time. |
|
2223 |
The following conditions are true: |
|
2224 |
- a1 points to the thread being scheduled. |
|
2225 |
- The current thread is the thread being scheduled. |
|
2226 |
- The thread has not executed any code yet. |
|
2227 |
*/ |
|
2228 |
EEventStartThread, |
|
2229 |
||
2230 |
/** |
|
2231 |
Event delivered after a thread attribute change. Currently this applies |
|
2232 |
only to thread renaming but may be extended in the future. |
|
2233 |
a1 points to the thread being modified. |
|
2234 |
*/ |
|
2235 |
EEventUpdateThread, |
|
2236 |
||
2237 |
/** |
|
2238 |
Event delivered when a user or kernel thread terminates. |
|
2239 |
This event is always sent. |
|
2240 |
The following conditions are true: |
|
2241 |
- a1 points to the thread being terminated. |
|
2242 |
- The current thread is the thread being terminated. |
|
2243 |
- The current thread is in the ECSExitInProgress state, |
|
2244 |
and so can not be suspended. |
|
2245 |
- The thread's address space can be inspected. |
|
2246 |
*/ |
|
2247 |
EEventKillThread, |
|
2248 |
||
2249 |
/** |
|
2250 |
Event delivered when a user or kernel thread is about to be closed. |
|
2251 |
The following conditions are true: |
|
2252 |
- a1 points to the thread being terminated. |
|
2253 |
- The current thread is the supervisor thread. |
|
2254 |
- The thread is partly destructed so its resources should be accessed |
|
2255 |
only after checking if they still exist. |
|
2256 |
*/ |
|
2257 |
EEventRemoveThread, |
|
2258 |
||
2259 |
/** |
|
2260 |
Event delivered when a chunk is created. |
|
2261 |
The following conditions are true: |
|
2262 |
- a1 points to the chunk being created. |
|
2263 |
*/ |
|
2264 |
EEventNewChunk, |
|
2265 |
||
2266 |
/** |
|
2267 |
Event delivered when physical memory is committed to/decommitted from a |
|
2268 |
chunk. |
|
2269 |
The following conditions are true: |
|
2270 |
- a1 points to the chunk being modified. |
|
2271 |
*/ |
|
2272 |
EEventUpdateChunk, |
|
2273 |
||
2274 |
/** |
|
2275 |
Event delivered when a chunk is deleted. |
|
2276 |
The following conditions are true: |
|
2277 |
- a1 points to the chunk being deleted. |
|
2278 |
*/ |
|
2279 |
EEventDeleteChunk, |
|
2280 |
||
2281 |
/** |
|
2282 |
Event delivered when a user-side DLL is explicitly loaded. |
|
2283 |
The following conditions are true: |
|
2284 |
- a1 points to the DLibrary instance being loaded. |
|
2285 |
- a2 points to the creator thread. |
|
2286 |
- DLibrary::iMapCount is equals to 1 if the DLL is loaded for the first |
|
2287 |
time into the creator thread's address space. |
|
2288 |
- If the DLL is loaded for the first time, its global c'tors (if any) |
|
2289 |
haven't been called yet. |
|
2290 |
- The DLL and all its dependencies have been mapped. |
|
2291 |
- The system-wide mutex DCodeSeg::CodeSegLock is held. |
|
2292 |
*/ |
|
2293 |
EEventAddLibrary, |
|
2294 |
||
2295 |
/** |
|
2296 |
Event delivered when a previously explicitly loaded user-side DLL is |
|
2297 |
closed or unloaded (i.e. call to RLibrary::Close()). |
|
2298 |
The following conditions are true: |
|
2299 |
- a1 points to the DLibrary instance being unloaded. |
|
2300 |
- DLibrary::iMapCount is equals to 0 if the DLL is about to be unloaded. |
|
2301 |
- If the DLL is about to be unloaded, its global d'tors have been called |
|
2302 |
but it is still mapped (and so are its dependencies). |
|
2303 |
- The current thread may be the kernel server. |
|
2304 |
- The system-wide mutex DCodeSeg::CodeSegLock is held. |
|
2305 |
*/ |
|
2306 |
EEventRemoveLibrary, |
|
2307 |
||
2308 |
/** |
|
2309 |
Event delivered when a LDD is loaded. |
|
2310 |
The following conditions are true: |
|
2311 |
- a1 points to the LDD's code segment (DCodeSeg instance). |
|
2312 |
- The current thread is the loader thread. |
|
2313 |
- The LDD factory function has not been called yet. |
|
2314 |
*/ |
|
2315 |
EEventLoadLdd, |
|
2316 |
||
2317 |
/** |
|
2318 |
Event delivered when a LDD is unloaded. |
|
2319 |
The following conditions are true: |
|
2320 |
- a1 points to the LDD's code segment (DCodeSeg instance). |
|
2321 |
- The current thread is the loader thread. |
|
2322 |
*/ |
|
2323 |
EEventUnloadLdd, |
|
2324 |
||
2325 |
/** |
|
2326 |
Event delivered when a PDD is loaded. |
|
2327 |
The following conditions are true: |
|
2328 |
- a1 points to the PDD's code segment (DCodeSeg instance). |
|
2329 |
- The current thread is the loader thread. |
|
2330 |
- The PDD factory function has not been called yet. |
|
2331 |
*/ |
|
2332 |
EEventLoadPdd, |
|
2333 |
||
2334 |
/** |
|
2335 |
Event delivered when a PDD is unloaded. |
|
2336 |
The following conditions are true: |
|
2337 |
- a1 points to the PDD's code segment (DCodeSeg instance). |
|
2338 |
- The current thread is the loader thread. |
|
2339 |
*/ |
|
2340 |
EEventUnloadPdd, |
|
2341 |
||
2342 |
/** |
|
2343 |
Event delivered when RDebug::Print is called in user-side code. |
|
2344 |
The following conditions are true: |
|
2345 |
- a1 points to the user-side buffer containing the unicode string |
|
2346 |
for printing. The characters can not be accessed directly. The |
|
2347 |
string must copied instead using kumemget() and, as the event |
|
2348 |
is delivered in thread critical section, the call to kumemget() |
|
2349 |
must be protected with XTRAP. |
|
2350 |
- a2 is a TInt which holds the length in characters of the string |
|
2351 |
for printing. As this is a unicode string, the size of the |
|
2352 |
user-side buffer is twice the length. |
|
2353 |
- The current thread is the user-side client. |
|
2354 |
On exit use DKernelEventHandler::ETraceHandled to indicate event handled. |
|
2355 |
*/ |
|
2356 |
EEventUserTrace, |
|
2357 |
||
2358 |
/** |
|
2359 |
Event delivered when a code segment is mapped into a process. |
|
2360 |
The following conditions are true: |
|
2361 |
- a1 points to the code segment. |
|
2362 |
- a2 points to the process. |
|
2363 |
- The system-wide mutex DCodeSeg::CodeSegLock is held. |
|
2364 |
*/ |
|
2365 |
EEventAddCodeSeg, |
|
2366 |
||
2367 |
/** |
|
2368 |
Event delivered when a code segment is unmapped from a process. |
|
2369 |
The following conditions are true: |
|
2370 |
- a1 points to the code segment. |
|
2371 |
- a2 points to the process. |
|
2372 |
- The system-wide mutex DCodeSeg::CodeSegLock is held. |
|
2373 |
*/ |
|
2374 |
EEventRemoveCodeSeg, |
|
2375 |
||
2376 |
/** |
|
2377 |
Event delivered when a process is created (i.e. during a call to |
|
2378 |
RProcess::Create or Kern::ProcessCreate()). |
|
2379 |
The following conditions are true: |
|
2380 |
- a1 points to the process. |
|
2381 |
- The process being created is fully constructed. |
|
2382 |
*/ |
|
2383 |
EEventLoadedProcess, |
|
2384 |
||
2385 |
/** |
|
2386 |
Event delivered when a process is being released, before its code segment, |
|
2387 |
stack chunk, etc. are unmapped. |
|
2388 |
The following conditions are true: |
|
2389 |
- a1 points to the process. |
|
2390 |
- The process being released is fully constructed. |
|
2391 |
*/ |
|
2392 |
EEventUnloadingProcess, |
|
2393 |
||
2394 |
/** |
|
2395 |
Must be last |
|
2396 |
*/ |
|
2397 |
EEventLimit |
|
2398 |
}; |
|
2399 |
||
2400 |
/** Access-counted event handler callback. |
|
2401 |
||
2402 |
The kernel maintains a queue of event handlers which are called in turn |
|
2403 |
when various events (thread creation, hardware exception, ...) occur. |
|
2404 |
||
2405 |
Typical clients would be drivers or kernel extensions implementing kernel |
|
2406 |
debug agents or profilers. This class could also be used to extend the |
|
2407 |
instruction set (by trapping undefined instructions). |
|
2408 |
||
2409 |
An access count needs to be maintained because handlers can not be dequeued |
|
2410 |
and destructed while one or more threads are executing some code inside the |
|
2411 |
callback. The access count, initially set to 1, is incremented every time |
|
2412 |
a thread enters the callback and decremented every time a thread exits the |
|
2413 |
callback. |
|
2414 |
||
2415 |
Consequently: |
|
2416 |
||
2417 |
- Client code should use Close() instead the operator delete to destroy the |
|
2418 |
event handler. |
|
2419 |
||
2420 |
- If the client is a LDD, the lifetime of the event handler may exceed that |
|
2421 |
of the logical channel and its user-side client thread. Therefore, the |
|
2422 |
callback should not refer to data stored in the channel and any |
|
2423 |
asynchronous request to be completed in the callback should be cancelled by |
|
2424 |
the channel destructor. |
|
2425 |
||
2426 |
If the client is a RAM-loaded LDD (or PDD), it is possible for the DLL to |
|
2427 |
be unloaded while the handler is still in use. This would result in an |
|
2428 |
exception. To avoid this, the handler must open a reference to the |
|
2429 |
DLogicalDevice (or DPhysicalDevice) and close it in its d'tor. |
|
2430 |
||
2431 |
@publishedPartner |
|
2432 |
@released |
|
2433 |
*/ |
|
2434 |
class DKernelEventHandler : public DBase |
|
2435 |
{ |
|
2436 |
public: |
|
2437 |
/** Values used to select where to insert the handler in the queue */ |
|
2438 |
enum TAddPolicy |
|
2439 |
{ |
|
2440 |
EAppend, /**< Append at end of queue */ |
|
2441 |
}; |
|
2442 |
||
2443 |
/** Bitmask returned by callback function */ |
|
2444 |
enum TReturnCode |
|
2445 |
{ |
|
2446 |
/** Run next handler if set, ignore remaining handlers if cleared */ |
|
2447 |
ERunNext = 1, |
|
2448 |
/** Available for EEventUserTrace only. Ignore trace statement if set. */ |
|
2449 |
ETraceHandled = 0x40000000, |
|
2450 |
/** Available for hardware exceptions only. Do not panic thread if set. */ |
|
2451 |
EExcHandled = (TInt)0x80000000, |
|
2452 |
}; |
|
2453 |
||
2454 |
/** Pointer to C callback function called when an event occurs. |
|
2455 |
aEvent designates what event is dispatched. a1 and a2 are event-specific. |
|
2456 |
aPrivateData is specified when the handler is created, typically a pointer |
|
2457 |
to the event handler. |
|
2458 |
The function is always called in thread critical section. |
|
2459 |
@see TReturnCode |
|
2460 |
*/ |
|
2461 |
typedef TUint (*TCallback)(TKernelEvent aEvent, TAny* a1, TAny* a2, TAny* aPrivateData); |
|
2462 |
public: |
|
2463 |
// external interface |
|
2464 |
IMPORT_C static TBool DebugSupportEnabled(); |
|
2465 |
IMPORT_C DKernelEventHandler(TCallback aCb, TAny* aPrivateData); |
|
2466 |
IMPORT_C TInt Add(TAddPolicy aPolicy = EAppend); |
|
2467 |
IMPORT_C TInt Close(); |
|
2468 |
inline TBool IsQueued() const; |
|
2469 |
public: |
|
2470 |
// kernel internal interface |
|
2471 |
static TUint Dispatch(TKernelEvent aEvent, TAny* a1, TAny* a2); |
|
2472 |
private: |
|
2473 |
static SDblQue HandlersQ; |
|
2474 |
private: |
|
2475 |
TInt iAccessCount; |
|
2476 |
SDblQueLink iLink; |
|
2477 |
TCallback iCb; |
|
2478 |
TAny* iPrivateData; |
|
2479 |
}; |
|
2480 |
||
2481 |
/** Returns whether or not the handler has been queued. */ |
|
2482 |
inline TBool DKernelEventHandler::IsQueued() const |
|
2483 |
{ |
|
2484 |
return iLink.iNext != NULL; |
|
2485 |
} |
|
2486 |
||
2487 |
||
2488 |
/******************************************** |
|
2489 |
* Persistent Machine Configuration |
|
2490 |
********************************************/ |
|
2491 |
||
2492 |
/** |
|
2493 |
@internalTechnology |
|
2494 |
*/ |
|
2495 |
class TMachineConfig |
|
2496 |
{ |
|
2497 |
public: |
|
2498 |
TInt iLogSize; |
|
2499 |
TInt iLogMaxSize; |
|
2500 |
SLocaleData iLocale; |
|
2501 |
TInt iXtalError; |
|
2502 |
||
2503 |
/** The last time set by the user */ |
|
2504 |
TTimeK LastSetTime; |
|
2505 |
||
2506 |
/** The accumulated RTC correction due to crystal errors */ |
|
2507 |
TInt TheRTCCorrection; |
|
2508 |
}; |
|
2509 |
||
2510 |
/****************************************************************************** |
|
2511 |
* Macros for typical extensions/device drivers/ASSPs |
|
2512 |
******************************************************************************/ |
|
2513 |
#ifndef __WINS__ |
|
2514 |
/** |
|
2515 |
@internalComponent |
|
2516 |
@prototype 9.5 |
|
2517 |
||
2518 |
Defines the entry point for an extension that specifies a priority |
|
2519 |
Priorities are used to sequence calls to the entry point (KModuleEntryReasonExtensionInit1) |
|
2520 |
and may be used to ensure that extensions with higher priority are started before |
|
2521 |
ones with lower priority. When the priority of 2 extensions is the same, the order |
|
2522 |
they are started is the order they appear in the ROM header extension list. |
|
2523 |
The maximum priority is 255. Priority 0 is the lowest priority (standard extension). |
|
2524 |
@note This feature is not available for the emulator. |
|
2525 |
*/ |
|
2526 |
#define DECLARE_EXTENSION_WITH_PRIORITY(priority) \ |
|
2527 |
GLREF_C TInt InitExtension(); \ |
|
2528 |
TInt KernelModuleEntry(TInt aReason) \ |
|
2529 |
{ \ |
|
2530 |
if (aReason==KModuleEntryReasonExtensionInit0) \ |
|
2531 |
return priority; \ |
|
2532 |
if (aReason!=KModuleEntryReasonExtensionInit1) \ |
|
2533 |
return KErrArgument; \ |
|
2534 |
return InitExtension(); \ |
|
2535 |
} \ |
|
2536 |
GLDEF_C TInt InitExtension() |
|
2537 |
||
2538 |
||
2539 |
/** |
|
2540 |
@publishedPartner |
|
2541 |
@released |
|
2542 |
||
2543 |
Defines the entry point for a standard extension |
|
2544 |
*/ |
|
2545 |
#define DECLARE_STANDARD_EXTENSION() DECLARE_EXTENSION_WITH_PRIORITY(KExtensionStandardPriority) |
|
2546 |
||
2547 |
#else |
|
2548 |
/** |
|
2549 |
@publishedPartner |
|
2550 |
@released |
|
2551 |
||
2552 |
Defines the entry point for a standard extension |
|
2553 |
*/ |
|
2554 |
#define DECLARE_STANDARD_EXTENSION() \ |
|
2555 |
GLREF_C TInt InitExtension(); \ |
|
2556 |
TInt KernelModuleEntry(TInt aReason) \ |
|
2557 |
{ \ |
|
2558 |
if (aReason==KModuleEntryReasonExtensionInit0) \ |
|
2559 |
return KErrNone; \ |
|
2560 |
if (aReason!=KModuleEntryReasonExtensionInit1) \ |
|
2561 |
return KErrArgument; \ |
|
2562 |
return InitExtension(); \ |
|
2563 |
} \ |
|
2564 |
GLDEF_C TInt InitExtension() |
|
2565 |
||
2566 |
#endif |
|
2567 |
||
2568 |
/** |
|
2569 |
@publishedPartner |
|
2570 |
@released |
|
2571 |
||
2572 |
Defines the entry point for a standard logical device driver (LDD), |
|
2573 |
and declares the ordinal 1 export function for creating the LDD factory object |
|
2574 |
*/ |
|
2575 |
#define DECLARE_STANDARD_LDD() \ |
|
2576 |
TInt KernelModuleEntry(TInt) \ |
|
2577 |
{ return KErrNone; } \ |
|
2578 |
EXPORT_C DLogicalDevice* CreateLogicalDevice() |
|
2579 |
||
2580 |
||
2581 |
||
2582 |
||
2583 |
/** |
|
2584 |
@publishedPartner |
|
2585 |
@released |
|
2586 |
||
2587 |
Defines the entry point for a standard physical device driver (PDD), |
|
2588 |
and declares the ordinal 1 export function for creating the PDD factory object. |
|
2589 |
*/ |
|
2590 |
#define DECLARE_STANDARD_PDD() \ |
|
2591 |
TInt KernelModuleEntry(TInt) \ |
|
2592 |
{ return KErrNone; } \ |
|
2593 |
EXPORT_C DPhysicalDevice* CreatePhysicalDevice() |
|
2594 |
||
2595 |
||
2596 |
||
2597 |
||
2598 |
/** |
|
2599 |
@publishedPartner |
|
2600 |
@released |
|
2601 |
||
2602 |
Defines the entry point for a standard logical device driver (LDD) |
|
2603 |
that is also an extension, and declares the ordinal 1 export function |
|
2604 |
for creating the LDD factory object |
|
2605 |
*/ |
|
2606 |
#define DECLARE_EXTENSION_LDD() \ |
|
2607 |
EXPORT_C DLogicalDevice* CreateLogicalDevice() |
|
2608 |
||
2609 |
||
2610 |
||
2611 |
||
2612 |
/** |
|
2613 |
@publishedPartner |
|
2614 |
@released |
|
2615 |
||
2616 |
Defines the entry point for a standard physical device driver (PDD) |
|
2617 |
that is also an extension, and declares the ordinal 1 export function |
|
2618 |
for creating the PDD factory object |
|
2619 |
*/ |
|
2620 |
#define DECLARE_EXTENSION_PDD() \ |
|
2621 |
EXPORT_C DPhysicalDevice* CreatePhysicalDevice() |
|
2622 |
||
2623 |
||
2624 |
||
2625 |
||
2626 |
/** |
|
2627 |
@publishedPartner |
|
2628 |
@released |
|
2629 |
||
2630 |
Generates a stub entry point function and the AsicInitialise() function that |
|
2631 |
causes static constructors to be called. |
|
2632 |
||
2633 |
ASSP DLLs require static constructors to be called at the same time as |
|
2634 |
the variant is initialised. |
|
2635 |
*/ |
|
2636 |
#define DECLARE_STANDARD_ASSP() \ |
|
2637 |
extern "C" { GLREF_C TInt _E32Dll(TInt); } \ |
|
2638 |
GLDEF_C TInt KernelModuleEntry(TInt aReason) \ |
|
2639 |
{ return (aReason==KModuleEntryReasonExtensionInit1) \ |
|
2640 |
?KErrNone:KErrGeneral; } \ |
|
2641 |
EXPORT_C void AsicInitialise() \ |
|
2642 |
{ _E32Dll(KModuleEntryReasonExtensionInit1); } |
|
2643 |
||
2644 |
||
2645 |
/** |
|
2646 |
@internalComponent |
|
2647 |
*/ |
|
2648 |
#define __VARIANT_SUPPORTS_ADDITIONAL_INTERFACE_BLOCK__(x) \ |
|
2649 |
__Variant_Flags__ |= (x) |
|
2650 |
||
2651 |
/** |
|
2652 |
@internalTechnology |
|
2653 |
@prototype |
|
2654 |
Used to indicate that a variant supports the nanokernel interface block |
|
2655 |
*/ |
|
2656 |
#define __VARIANT_SUPPORTS_NANOKERNEL_INTERFACE_BLOCK__() \ |
|
2657 |
__VARIANT_SUPPORTS_ADDITIONAL_INTERFACE_BLOCK__(1) |
|
2658 |
||
2659 |
||
2660 |
class DemandPaging; |
|
2661 |
||
2662 |
/** |
|
2663 |
Memory locking on demand paging systems. |
|
2664 |
||
2665 |
This class is not thread safe. I.e. Only one method should be executed at any time |
|
2666 |
for a given instance of an object. |
|
2667 |
||
2668 |
@internalTechnology |
|
2669 |
@prototype |
|
2670 |
*/ |
|
2671 |
class DDemandPagingLock : public DBase |
|
2672 |
{ |
|
2673 |
public: |
|
2674 |
IMPORT_C DDemandPagingLock(); |
|
2675 |
||
2676 |
/** |
|
2677 |
Unlock and Free the memory associated with this object |
|
2678 |
*/ |
|
2679 |
inline ~DDemandPagingLock() { Free(); } |
|
2680 |
||
2681 |
/** |
|
2682 |
Reserve memory so that this object can be used for locking up to |
|
2683 |
the specified number of bytes. |
|
2684 |
||
2685 |
@param aSize Maximum number of bytes to be locked. |
|
2686 |
||
2687 |
@return KErrNone or standard error code. |
|
2688 |
*/ |
|
2689 |
IMPORT_C TInt Alloc(TInt aSize); |
|
2690 |
||
2691 |
/** |
|
2692 |
Unlock any memory locked by this object, then free the memory reserved with |
|
2693 |
Alloc(). This returns the object to the same state it was at immediately after |
|
2694 |
construction. |
|
2695 |
*/ |
|
2696 |
IMPORT_C void Free(); |
|
2697 |
||
2698 |
/** |
|
2699 |
Ensure all pages in the given region are present and lock them so that they will |
|
2700 |
not be paged out. If the region contained no demand paged memory, then no action |
|
2701 |
is performed. |
|
2702 |
||
2703 |
This function may not be called again until the previous memory has been |
|
2704 |
unlocked. |
|
2705 |
||
2706 |
@param aThread The thread in whoes process the memory lies. |
|
2707 |
@param aStart The address of the first byte of memory to be locked. |
|
2708 |
@param aSize The number of bytes to lock. |
|
2709 |
||
2710 |
@return 1 (one) if any memory was locked. 0 (KErrNone) if memory |
|
2711 |
did not need locking because it is not demand paged. Otherwise |
|
2712 |
KErrBadDescriptor to indicate that the memory region was not |
|
2713 |
valid. |
|
2714 |
||
2715 |
@pre Alloc must have been used to reserve sufficient RAM. |
|
2716 |
*/ |
|
2717 |
IMPORT_C TInt Lock(DThread* aThread, TLinAddr aStart, TInt aSize); |
|
2718 |
||
2719 |
/** |
|
2720 |
Unlock the memory region which was previousely locked with Lock. |
|
2721 |
This may be called even if memory wasn't previousely locked. |
|
2722 |
*/ |
|
2723 |
inline void Unlock() { if(iLockedPageCount) DoUnlock(); } |
|
2724 |
||
2725 |
private: |
|
2726 |
IMPORT_C void DoUnlock(); |
|
2727 |
private: |
|
2728 |
DemandPaging* iThePager; |
|
2729 |
TInt iReservedPageCount; |
|
2730 |
TInt iLockedPageCount; |
|
2731 |
TLinAddr iLockedStart; |
|
2732 |
DProcess* iProcess; |
|
2733 |
TPhysAddr* iPages; |
|
2734 |
TAny* iPinMapping; |
|
2735 |
TInt iMaxPageCount; |
|
2736 |
||
2737 |
friend class DemandPaging; |
|
2738 |
}; |
|
2739 |
||
2740 |
||
2741 |
||
2742 |
class DPagingRequestPool; |
|
2743 |
||
2744 |
/** |
|
2745 |
Base class for Paging Devices. |
|
2746 |
A Paging Device provides the paging system with access to storage media which holds |
|
2747 |
data being demand paged. |
|
2748 |
@internalTechnology |
|
2749 |
@prototype |
|
2750 |
*/ |
|
2751 |
class DPagingDevice : public DBase |
|
2752 |
{ |
|
2753 |
public: |
|
2754 |
/** The type of device this represents. */ |
|
2755 |
enum TType |
|
2756 |
{ |
|
2757 |
ERom = 1<<0, /**< Paged ROM device type. */ |
|
2758 |
ECode = 1<<1, /**< Code paging device type. */ |
|
2759 |
EData = 1<<2 /**< Data paging device type. */ |
|
2760 |
}; |
|
2761 |
||
2762 |
enum TSpecialDrives |
|
2763 |
{ |
|
2764 |
EDriveRomPaging = -1, /**< Special drive number to indicate rom paging. */ |
|
2765 |
EDriveDataPaging = -2, /**< Special drive number to indicate data paging. */ |
|
2766 |
}; |
|
2767 |
||
2768 |
/** |
|
2769 |
Called by the paging system to read data from the media represented by this |
|
2770 |
device. |
|
2771 |
||
2772 |
@param aBuffer The location where the read data should be stored. |
|
2773 |
@param aOffset The offset from the media start, in read units, from where |
|
2774 |
data should be read. |
|
2775 |
@param aSize The number of read units to be read. |
|
2776 |
||
2777 |
@param aDrvNumber The drive number for code paging or a member of TSpecialDrives for rom or data |
|
2778 |
paging. |
|
2779 |
||
2780 |
@return KErrNone or standard error code. |
|
2781 |
*/ |
|
2782 |
virtual TInt Read(TThreadMessage* aReq,TLinAddr aBuffer,TUint aOffset,TUint aSize, TInt aDrvNumber) = 0; |
|
2783 |
||
2784 |
/** |
|
2785 |
Called by the paging system to write data to the media represented by this device. |
|
2786 |
||
2787 |
This is only used in the implementation of data paging to write to the swap partition. |
|
2788 |
||
2789 |
@param aBuffer The location of the data to write. |
|
2790 |
@param aOffset The offset from the media start, in read units, to where data should be written. |
|
2791 |
@param aSize The number of read units to write. |
|
2792 |
@param aBackground If set, this indicates that the request should not count as making the device busy. |
|
2793 |
||
2794 |
@return KErrNone or standard error code. |
|
2795 |
*/ |
|
2796 |
inline virtual TInt Write(TThreadMessage* aReq,TLinAddr aBuffer,TUint aOffset,TUint aSize,TBool aBackground); |
|
2797 |
||
2798 |
/** |
|
2799 |
Called by the paging system to notify the media driver that data that was previously written is |
|
2800 |
now no longer needed. |
|
2801 |
||
2802 |
This is only used in the implementation of data paging when data in the swap partition is no |
|
2803 |
longer needed. |
|
2804 |
||
2805 |
@param aOffset The offset from the media start, in read units, to where data was written. |
|
2806 |
@param aSize The size in read units. |
|
2807 |
||
2808 |
@return KErrNone or standard error code. |
|
2809 |
*/ |
|
2810 |
inline virtual TInt DeleteNotify(TThreadMessage* aReq,TUint aOffset,TUint aSize); |
|
2811 |
||
2812 |
/** |
|
2813 |
Called by the paging device to notify the kernel that the device has just become idle and is not |
|
2814 |
currently processing any requests. |
|
2815 |
||
2816 |
This is used by the kernel to work out when to clean pages in the background. |
|
2817 |
||
2818 |
Note that write requests made by calling the DPagingDevice::Write() with the aBackground flag |
|
2819 |
set do not count towards the device being busy. |
|
2820 |
*/ |
|
2821 |
IMPORT_C void NotifyIdle(); |
|
2822 |
||
2823 |
/** |
|
2824 |
Called by the paging device to notify the kernel that the device has just become busy and is |
|
2825 |
currently processing requests. |
|
2826 |
||
2827 |
This is used by the kernel to work out when to clean pages in the background. |
|
2828 |
||
2829 |
Note that write requests made by calling the DPagingDevice::Write() with the aBackground flag |
|
2830 |
set do not count towards the device being busy. |
|
2831 |
*/ |
|
2832 |
IMPORT_C void NotifyBusy(); |
|
2833 |
||
2834 |
public: |
|
2835 |
/** The type of device this represents. */ |
|
2836 |
TUint32 iType; |
|
2837 |
||
2838 |
/** The local drives supported for code paging. |
|
2839 |
This is a bitmask containing one bit set for each local drive supported, where the bit set |
|
2840 |
is 1 << the local drive number. If this device does not support code paging, this should be |
|
2841 |
zero. */ |
|
2842 |
TUint32 iDrivesSupported; |
|
2843 |
||
2844 |
/** Zero terminated string representing the name of the device. |
|
2845 |
(Only used for debug tracing purposes.) */ |
|
2846 |
const char* iName; |
|
2847 |
||
2848 |
/** Log2 of the read unit size. A read unit is the number of bytes which |
|
2849 |
the device can optimally read from the underlying media. |
|
2850 |
E.g. for small block NAND, a read unit would be equal to the page size, |
|
2851 |
512 bytes, therefore iReadUnitShift would be set to 9. */ |
|
2852 |
TInt iReadUnitShift; |
|
2853 |
||
2854 |
/** The value the device should use to identify itself. |
|
2855 |
This value is set by Kern::InstallPagingDevice(). |
|
2856 |
The purpose of this Id is to distinguish multiple Code Paging devices. */ |
|
2857 |
TInt iDeviceId; |
|
2858 |
||
2859 |
/** For data paging only, the size of the swap partition supported by this device, in read units. |
|
2860 |
||
2861 |
If data paging is not supported, or has been disabled by the media driver, this should be |
|
2862 |
zero. |
|
2863 |
*/ |
|
2864 |
TInt iSwapSize; |
|
2865 |
||
2866 |
/** The pool of DPagingRequest objects used to issue requests for this device. |
|
2867 |
This is setup and used internally by the kernel. |
|
2868 |
*/ |
|
2869 |
DPagingRequestPool* iRequestPool; |
|
2870 |
||
2871 |
/** Reserved for future use. |
|
2872 |
*/ |
|
2873 |
TInt iSpare[4]; |
|
2874 |
}; |
|
2875 |
||
2876 |
inline TInt DPagingDevice::Write(TThreadMessage*,TLinAddr,TUint,TUint,TBool) |
|
2877 |
{ |
|
2878 |
// Default implementation, may be overriden by dervied classes |
|
2879 |
return KErrNotSupported; |
|
2880 |
} |
|
2881 |
||
2882 |
inline TInt DPagingDevice::DeleteNotify(TThreadMessage*,TUint,TUint) |
|
2883 |
{ |
|
2884 |
// Default implementation, may be overriden by dervied classes |
|
2885 |
return KErrNotSupported; |
|
2886 |
} |
|
2887 |
||
2888 |
extern "C" { extern TInt __Variant_Flags__; } |
|
2889 |
||
2890 |
/******************************************** |
|
2891 |
* Shareable Data Buffers |
|
2892 |
********************************************/ |
|
2893 |
/** |
|
2894 |
Pool create info |
|
2895 |
||
2896 |
@publishedPartner |
|
2897 |
@prototype |
|
2898 |
*/ |
|
2899 |
class TMappingAttributes2; |
|
2900 |
||
2901 |
#include <e32shbufcmn.h> |
|
2902 |
||
2903 |
class TShPoolCreateInfo |
|
2904 |
{ |
|
2905 |
public: |
|
2906 |
/** |
|
2907 |
Enumeration type to say that the shared pool is to be backed with memory supplied by the kernel. |
|
2908 |
*/ |
|
2909 |
enum TShPoolPageAlignedBuffers |
|
2910 |
{ |
|
2911 |
EPageAlignedBuffer = EShPoolPageAlignedBuffer, |
|
2912 |
}; |
|
2913 |
||
2914 |
/** |
|
2915 |
Enumeration type to say that the shared pool is to be backed with memory supplied by the kernel. |
|
2916 |
*/ |
|
2917 |
enum TShPoolNonPageAlignedBuffers |
|
2918 |
{ |
|
2919 |
ENonPageAlignedBuffer = EShPoolNonPageAlignedBuffer, |
|
2920 |
}; |
|
2921 |
||
2922 |
/** |
|
2923 |
Enumeration type to say that the shared pool is to be mapped onto device memory. |
|
2924 |
*/ |
|
2925 |
enum TShPoolMemoryDevice |
|
2926 |
{ |
|
2927 |
EDevice = EShPoolPhysicalMemoryPool, |
|
2928 |
}; |
|
2929 |
||
2930 |
IMPORT_C TShPoolCreateInfo(TShPoolPageAlignedBuffers aFlag, TUint aBufSize, TUint aInitialBufs); |
|
2931 |
IMPORT_C TShPoolCreateInfo(TShPoolNonPageAlignedBuffers aFlag, TUint aBufSize, TUint aInitialBufs, TUint aAlignment); |
|
2932 |
||
2933 |
IMPORT_C TShPoolCreateInfo(TShPoolMemoryDevice aFlag, TUint aBufSize, TUint aInitialBufs, TUint aAlignment, TUint aPages, TPhysAddr* aPhysicalAddressList); |
|
2934 |
||
2935 |
IMPORT_C TShPoolCreateInfo(TShPoolMemoryDevice aFlag, TUint aBufSize, TUint aInitialBufs, TUint aAlignment, TUint aPages, TPhysAddr aPhysicalAddress); |
|
2936 |
||
2937 |
IMPORT_C TInt SetSizingAttributes(TUint aMaxBufs, TUint aMinFreeBufs, TUint aGrowByBufs, TUint aShrinkByBufs); |
|
2938 |
IMPORT_C TInt SetExclusive(); |
|
2939 |
IMPORT_C TInt SetContiguous(); |
|
2940 |
IMPORT_C TInt SetGuardPages(); |
|
2941 |
||
2942 |
private: |
|
2943 |
friend class ExecHandler; |
|
2944 |
friend class DShPool; |
|
2945 |
friend class DMemModelShPool; |
|
2946 |
friend class DMemModelAlignedShPool; |
|
2947 |
friend class DMemModelNonAlignedShPool; |
|
2948 |
friend class DMemModelProcess; |
|
2949 |
friend class DWin32ShPool; |
|
2950 |
friend class DWin32AlignedShPool; |
|
2951 |
friend class DWin32NonAlignedShPool; |
|
2952 |
friend class DWin32Process; |
|
2953 |
friend class DShBufTestDrvChannel; |
|
2954 |
||
2955 |
inline TShPoolCreateInfo() ///< default constructor |
|
2956 |
{ |
|
2957 |
memclr(this, sizeof(TShPoolCreateInfo)); |
|
2958 |
}; |
|
2959 |
||
2960 |
TShPoolInfo iInfo; |
|
2961 |
||
2962 |
union PhysAddr |
|
2963 |
{ |
|
2964 |
TPhysAddr* iPhysAddrList; ///< physical addresses for hardware |
|
2965 |
TPhysAddr iPhysAddr; ///< physical address for hardware |
|
2966 |
} iPhysAddr; |
|
2967 |
||
2968 |
TUint iPages; ///< number of pages to commit |
|
2969 |
}; |
|
2970 |
||
2971 |
#endif //__K32STD_H__ |