MCTS i

Exam 70-571

Windows Embedded CE 6.0

Preparation Kit Self-Paced Training

Up to Date
with

R2
Content

Not for Resale.

Glossary
Application Programming Interface (API) An
API is the function interface that an
operating system or library provides to
support requests from application
programs.
Application Verifier (AppVerifier) AppVerifier
enables developers to find subtle
programming errors, such as heap
corruption and incorrect handle usage, that
can be difficult to identify with normal
application testing
Asynchronous Access When two or more
threads access the same buffer at the same
time.
Binary Image Builder (.bib) A .bib file defines
which modules and files are included in a
run-time image.
Boot Loader Piece of code executed at the
processor startup to initialize the processor
and then launch an operating system.
Board Support Package (BSP) A BSP is the
common name for all board hardware-
specific code. It typically consists of the boot
loader, the OEM adaptation layer (OAL),
and board-specific device drivers.
Catalog A container of components that
presents a selectable feature for an OSDesign
to the user.
Debugger Extension Commands (CeDe-
bugX) CeDebugX is an extension to the
Platform Builder debugger. It presents
detailed information about the state of the
system at break time and attempts to
diagnose crashes, hangs, and deadlocks.
Windows Embedded CE Test Kit (CETK) The
CETK is a tool you can use to test device
drivers that you develop for the Windows
Embedded CE operating system.
Cloning During cloning, you generate an
exact copy of files to keep a secure copy of
them before performing modifications. Code
in the PUBLIC folder should always be
cloned before making modifications.
Component A CE feature that can be added
to or removed from an OS Design using the
catalog.
Core Connectivity (CoreCon) Windows CE
supports a unified communications
infrastructure called Core Connectivity that
enables full-featured connectivity for
downloading and debugging.
Critical Section An object with a
synchronization process that is similar to a
mutex object. The difference is that a critical
section can only be accessed by the threads
of a single process.
Data Marshaling A process done on data to
check the access rights and validity of the
data for a different process.
Debug Zone A flag to enable or disable debug
messages related to a certain functionality or
mode of a driver.
Device Driver A device driver is software that
manages the operation of a device by
abstracting the functionality of a physical or
virtual device.
Dirs File A Dirs file is a text file that specifies
the subdirectories that contain source code
to be built.
Embedded Pointer A pointer embedded in a
memory structure.
309
310 Glossary
Environment Variable A Windows
environment variable that can enable or
disable features. It is generally used to
configure the build system and OS design
from the catalog
Event Synchronization objects used by
threads and the kernel to notify other
threads in the system.
Exception An exception is an abnormal
situation that happens while a program is
running.
Iltiming Iltiming determines interrupt service
routine (ISR) and interrupt service thread
(IST) latencies on a Windows Embedded CE
system.
Interrupt A trigger that suspends (interrupts)
the system temporarily to indicate that
something has happened that requires
processing. Each interrupt on a system is
associated with a particular Interrupt
Request (IRQ) value and this IRQ value is
associated with one or more ISR.
Interrupt Service Routine (ISR) An ISR is a
software routine that hardware invokes in
response to an interrupt. ISRs examine an
interrupt and determine how to handle it by
returning a SYSINTR value, which is then
associated with an IST.
Interrupt Service Thread (IST) The IST is a
thread that does most of the interrupt
processing. The OS wakes the IST when the
OS has an interrupt to process. After each
IST is associated to a SYSINTR value, the
SYSINTR value can be returned from an ISR,
and then the associated IST runs.
IRQ (Interrupt Request) IRQ values are
associated in hardware with interrupts. Each
IRQ value can be associated with one or
more ISRs that the system will run to
process the associated interrupt when it is
triggered.
Kernel Debugger The kernel debugger
integrates functionality required to
configure a connection to a target device and
download a run-time image to the target
device. It allows the debugging of the OS,
abbreviate drivers, and applications.
Kernel Independent Transport Layer (KITL)
The KITL is designed to provide an easy way to
support debugging services.
Kernel-Mode Driver A driver that runs in the
kernel’s memory space.
Kernel Tracker This tool provides a visual
representation on a development
workstation of OS and application events
occurring on a Windows Embedded CE–
based device.
Layered Driver A driver that is separated into
several layers to make it easier to maintain
and reuse code at a later date.
Model Device Driver (MDD) The MDD layer
of a layered driver has a standardized
interface to the OS and Platform Device
Driver (PDD) layer and performs all
hardware independent processing related to
the driver.
Monolithic Driver A driver that is not
separated into different layers. It can also
mean any driver that does not conform to
the standard Model Device Driver (MDD)/
Platform Device Driver (PDD) layer
architecture of CE, even if the driver does
have its own layering scheme.
Mutex A mutex object is a synchronization
object whose state is set to signaled when it
is not owned by any thread and nonsignaled
when it is owned. A mutex can only be
owned by a single thread at a time. It is used
to represent a resource that should only be
accessed by one thread at any given time,
such as a global variable or a hardware
device.

Native Driver Touchscreen, Keyboard and
Display drivers are the only native drivers
existing in Windows Embedded CE and are
managed by GWES rather than Device
Manager.
OEM adaptation layer (OAL) An OAL is a
layer of code that logically resides between
the Windows Embedded CE kernel and the
hardware of your target device. Physically,
the OAL is linked with the kernel libraries to
create the kernel executable file.
Operating System Benchmark (OSBench) A
tool that is used to measure the performance
of the scheduler.
OS Design A Platform Builder for Windows
Embedded CE6 R2 project that generates a
customized binary runtime image of the
Windows Embedded CE6 R2 operating
system
Platform Dependent Driver (PDD) The PDD
layer of a layered driver is the part that
interfaces directly with hardware and
performs any hardware-specific processing.
Power Manager Controls the power
consumption of the system by assigning a
power state between D0 (fully on) and D4
(fully off) to the system as a whole and to
individual drivers. It coordinates transitions
between these states based on user and
system activity, as well as specified
requirements.
Process A process is a program in Windows
Embedded CE. Each process can have
multiple threads. A process can run in either
user space or in kernel space.
Production Quality OAL (PQOAL) The
PQOAL is a standardized OAL structure that
simplifies and shortens the process of
developing an OAL. It provides you with an
improved level of OAL componentization
through code libraries, directory structures
that support code reuse, centralized
Glossary 311
configuration files, and a consistent
architecture across processor families and
hardware platforms.
Quick Fix Engineering (QFE) Windows
Embedded CE patches that are available
from Microsoft’s website. They fix bugs and
provide new features.
Reflector Service The service that allows user
mode drivers to access the kernel and
hardware by performing requests on their
behalf.
Registry The information store for Windows
Embedded CE that contains configuration
information for hardware and software
components.
Remote Performance Monitor This
application can track the real-time
performance of the operating system. It can
also track memory usage, network latencies,
and other elements
Run-time image The binary file that will be
deployed on a hardware device . It also
contains the complete operating system
required files for applications and drivers.
Semaphore A semaphore object is a
synchronization object that protects access
to a hardware or software resource, allowing
only a fixed number of concurrent threads
to access it. The semaphore maintains a
count between zero and a specified
maximum value. The count is decremented
each time a thread completes a wait for the
semaphore object and incremented each
time a thread releases the semaphore. When
the count reaches zero, no more threads can
access the resource protected by the
semaphore. The state of a semaphore is set
to signaled when its count is greater than
zero and nonsignaled when its count is zero.
Shell The shell is the software that will
interpret user interactions with the device. It
312 Glossary
launches when the device starts up. The
default shell is called AYGShell and includes
a desktop, start menu, and taskbar similar to
those in desktop versions of Windows.
Software Development Kit (SDK) Used to
allow third-party developers to make
applications for a customized Windows
Embedded CE6 R2 run-time image
Sources File A Sources file is a text file that
sets macro definitions for the source code in
a subdirectory. Build.exe uses these macro
definitions to determine how to compile and
link the source code.
Stream Interface Driver A stream interface
driver is any driver that exposes the stream
interface functions, regardless of the type of
device controlled by the driver. All drivers
other than the native drivers managed by
GWES export a stream interface.
Subproject A set of files that you can easily
integrate, remove and reuse in an OSDesign.
Synchronization Objects A synchronization
object is an object whose handle can be
specified in one of the wait functions to
coordinate the execution of multiple
threads.
Synchronous Access When two or more
separate threads are working with the same
buffer. Only one thread can access the buffer
at any given time and no other threads
access the buffer until the current thread is
finished with it.
Sysgen The Sysgen phase is the first step in
the build process done to filter the public
and BSP folders. It identifies the files
associated with the components selected in
an OSDesign. During this phase,
components selected in the OS Design are
linked into executables and copied into the
OS Design’s folder.
Sysgen Variable A directive to the sysgen
phase of the CE build process where
selected CE features are linked together.
SYSINTR The value that corresponds to an
IRQ. It is used to signal an associated event.
This value is returned by an ISR in response
to an interrupt.
Target Control Shell A shell in Platform
Builder for Visual Studio providing access to
debugger commands. The target control
shell will be available when attached to a
target system through KITL.
Thread The smallest software unit that the
scheduler can manage on the OS. There can
be multiple threads in a single driver or
application.
User Mode Drivers loaded in user mode and
all applications run in user memory space.
When they are in this mode, drivers and
applications do not have direct access to
hardware memory and have restricted access
to certain APIs and the kernel.
Virtual Memory Virtual memory is a way of
abstracting the physical memory in a system
to appear contiguous to processes that use it.
Each process in Windows Embedded CE 6.0
R2 has two gigabytes of virtual memory
space available, and to access physical
memory from a process this memory must
be mapped into the virtual address space of
the process using MmMapIoSpace or
OALPAtoVA.
Index
.NET Compact Framework 2.0 4, 29 Process Management API 104, 130
.pbcxml files 21 SignalStarted API 93
.tks files. See Test Kit Suite (.tks) files stream interface API 247, 250
__except keyword 120 Thread Management API 104
__finally keyword 121 Win32 API 84
__try keyword 121 application shortcuts on the desktop 55
32 processes limitation 219 Application Verifier tool 162, 179
3rdParty folder 22 architecture-generic tasks 214
4 GB address space 219 ARM–based platforms 223
assembly language 188
ASSERTMSG macro 151
A associating an OS design with multiple BSPs 10
abstraction between the underlying hardware and the asynchronous buffer access 288, 293
operating system 243 ATM. See automated teller machines (ATM)
access checks 293 attaching to a target device 71
ActivateDevice function 258 audio device driver registration 262
ActivateDeviceEx function 258 Autoexit parameter 182
ActiveSync 4, 29, 178 automated software testing 176
activity timers 128 automated teller machines (ATM) 101
registry settings for 129 automatic loading of drivers 259
address mappings automatic startup 91
virtual-to-physical 213 Autorun parameter 181
address table 213 Autos tool 161
ADEFINES directive 60 AUTOSIZE parameter 49
ad-hoc solutions 21
Advanced Build Commands 24, 43
Rebuild Current BSP And Subprojects 24
B
advanced debugger tools 161 backlight driver 25
Advanced Memory tool 162 battery life 125
AdvertiseInterface function 264, 284 battery critically low state 229
alerts 90 battery level reaches zero 232
AllocPhysMem function 226, 279, 290 Power Manager (PM.dll) and 127
analyzing build results 63–67 best practices for debug zones 157
analyzing CETK test results 184 binary image builder (.bib) files 46
API. See application programming interface (API) automatic startup 47
applets 97–98, 100 AUTOSIZE parameter 49
application caller buffer 291 BOOTJUMP parameter 49
application debugging 149 COMPRESSION parameter 49
application programming interface (API) 11 conditional processing in 53
CPlApplet API 98 CONFIG section 49
Critical Section API 111 file type definitions in 52
Event API 114 FILES section 51
file system API 247 FIXUPVAR parameter 50
GetProcAddress API 243 FSRAMPERCENT parameter 50
Interlock API 115 H flag 271
Mutex API 112 K flag 270
non-real-time 84 KERNELFIXUPS parameter 50
Power Manager APIs 126 MEMORY section 48

313
314 Index

MODULES section 51 code sharing between the OAL and the 214
NK memory region 270 debugging techniques for 188
noncontiguous memory and 49 driver globals and 207
OUTPUT parameter 50 Eboot 187
PROFILE parameter 50 Ethdbg 205
Q flag 271 Ethernet support functions 210
RAM_AUTOSIZE parameter 50 flash memory support 211
RAMIMAGE parameter 49 general task of a 186
RESETVECTOR parameter 50 hardware initialization tasks 209
ROM_AUTOSIZE parameter 50 kernel initialization routines and 187
ROMFLAGS parameter 50 memory mappings for a 206
ROMOFFSET parameter 50 menu of a 211
ROMSIZE parameter 50 network drivers and 188
ROMSTART parameter 50 run-time image download via Ethernet 210
ROMWIDTH parameter 50 serial debug output functions and 209
S flag 271 StartUp entry point 208
sections of 47 testing 186
SRE parameter 50 typical tasks of a 186
X86BOOT parameter 51 BootArgs. See boot arguments (BootArgs)
XIPSCHAIN parameter 51 BOOTJUMP parameter 49
binary ROM image file system (BinFS) 187 BootLoaderMain function 209
black shell 101 BOOTME packet 212
BLCOMMON framework 187 Bootpart 187
Bluetooth 29 bootstrap service 148
Board Support Package (BSP) 3, 168, 197–239 breaking into the debugger 119
adapting and configuring 199–218 breakpoints 149, 161
boot loader and 201 enabling and managing 171
cloning an existing reference BSP 201 hardware and 174
advanced debugger tools 202 interrupt handlers and 173
Cloning Wizard 202 restrictions 173
components of a 200 setting too many 173
configuration files 199, 201 Tux DLLs and 184
device drivers and 201 BSP development 24
folder structure of a 203 BSP. See Board Support Package (BSP)
hardware-independent code and 201 Bsp_cfg.h file 276
memory mapping of a 219–227 BSPIntrInit function 277
OEM adaptation layer (OAL) and 201 buffer handling 293
platform-specific source code 205 buffer marshaling 268
reducing development time 201 buffer overrun 274
serial debug output functions and 209 Buffer Tracked Events In RAM option 9
source code folders for device drivers 217 build commands 42
Board Support Packages wizard page 10 command line equivalents for 46
boot arguments (BootArgs) 171 build configuration files 57–62
driver globals and 207 build configuration management 6
boot loader Advanced Build Commands 24
architecture 186 build configuration files 57–62
assembly language and 188 build directives 59
binary ROM image file system (BinFS) and 187 build options 8
BLCOMMON framework 187 Clean Sysgen command and 45
Board Support Package (BSP) and 201 configurations files 14
BootLoaderMain function 209 Environment options 10
BOOTME packet 212 image configuration files 56
Bootpart 187 program database (.pdb) files 6
 Index 315

project properties 6 BusTransBusAddrToVirtual function 299

source control software 12
Strict Localization Checking In The Build option 8
subproject image settings 16
C
Build menu 41 C interface 99
build options 3 Call Stack tool 161
active OS design and 8 CAN. See Controller Area Network (CAN)
Buffer Tracked Events In RAM 9 Catalog Editor 22
Enable Eboot Space In Memory 9 Error Report Generator 70
Enable Event Tracking During Boot 9 catalog entry properties 22
Enable Hardware-Assisted Debugging Support 9 catalog files 21
Enable Kernel Debugger 9, 168 Catalog Item Dependencies window 6
Enable KITL 9, 168 catalog items 3
Enable Profiling 9 .pbcxml files 21
Flush Tracked Events To Release Directory 9 3rdParty folder 22
Run-Time Image Can Be Larger Than 32 MB 9 adding or removing in an OS design 45
Use Xcopy Instead Of Links To Populate Release Directory backlight driver 25
10 BSP development and 24
Write Run-Time Image To Flash Memory 10 Clone Catalog Item option 19
build phase 40 cloning of 18–20
errors during the 66 conditional processing based on 53
build process 37, 39 converting from the Public directory tree to a BSP
advanced build commands 43 component 20
analyzing build results 63–67 creating and modifying 22
batch files and 39 dependencies of 5, 24
build log files 64 East Asian languages 7
build phase 40 exporting of 24
compile phase 40 ID of 23
Copy Files To Release Directory command 41 Internet Explorer 6.0 Sample Browser catalog item 32
custom actions based on command-line tools 61 managing 21–25
directives based on environment variables and 41 properties of 22
errors during the 63 Windows Embedded CE Standard Shell 97
make run-time image phase 41 Catalog Items View 4, 31
phases during the 39 Clone Catalog Item option 19
Platform Builder and 37 display item dependencies in 53
release copy phase 41 filter items in 5
skipping the release copy phase 41 search for catalog items 6
Software Development Kit (SDK) and 40 Solution Explorer and 5
standard command prompt and 46 catalog system 21
Sysgen phase 40 CDEFINES directive 60
Visual Studio 41 CDEFINES entry 24
build reports 63 CE 6.0 OS design template. See design templates
Build tool (Build.exe) 57 CE Dump File Reader 70, 161, 169
Build.err file 63, 65 CE Stress tool 179
Build.log file 63–64 CE target control shell (CESH) 147
Build.wrn file 63, 65 Ce.bib file 47, 56
Buildrel errors 66 CeAllocAsynchronousBuffer function 295
BuiltIn registry key 261 CeAllocDuplicateBuffer function 295
bus drivers 249 CeCallUserProc function 268
Bus Enumerator (BusEnum) 261 CeCloseCallerBuffer function 293, 295
bus name access 249 CEDebugX. See debugger extension commands (CEDebugX)
bus-agnostic drivers 300 CeFreeAsynchronousBuffer function 295
BusEnum. See Bus Enumerator (BusEnum)
316 Index

CeFreeDuplicateBuffer function 295 open context 253

CeLog event-tracking system 116, 163 Control Panel 97
reference naming matching and 166 components 98
Remote Kernel Tracker tool and 164 CPlApplet API 98
ship builds and 164 messages 99
CeLogFlush tool 164 NEWCPLINFO information 100
central processing unit (CPU) 119 Power applet 129
CeOpenCallerBuffer function 293, 295 Sources file and 100
CESH. See CE target control shell (CESH) Controller Area Network (CAN) 4
CESysgen folder 12 controlling the build process 41
CETest.exe. See workstation server application (CETest.exe) Copy Files To Release Directory command 41
CETK parser (Cetkpar.exe) 185 copylink 10
CETK. See Windows CE Test Kit (CETK) Core Connectivity (CoreCon) 17
Chain.bin file 51 download layer for 69
Chain.lst file 51 infrastructure for 68
classical naming convention for stream drivers 248 target control architecture and 148
Clean Sysgen command 43 transport mechanisms and 70
client-side application (Clientside.exe) 177, 180 core debugging tools 167
standalone mode 182 CoreCon. See Core Connectivity (CoreCon)
start parameters 181 CPlApplet API 98
cloning components 18–20 CPU Monitor 179
Board Support Package (BSP) and 201 CPU. See central processing unit (CPU)
advanced debugger tools 202 CPU-accessible memory 186
Clone Catalog Item option 19, 23 CPU-dependent user kernel data 223
public tree modification 18 CreateFile function 257
Cloning Wizard 202 CreateInstance function 280
CLR. See Common Language Runtime (CLR) CreateMutex function 111
code pages 8 CreateProcess function 268
code reuse 197 CreateSemaphore function 112
code sharing between the boot loader and the OAL 214 CreateStaticMapping function 224
command processor shell 96 CreateThread function 105
comma-separated values (CSV) 185 creating threads 105
Common Language Runtime (CLR) 101 Critical Off state 229, 232
common release directory 37 Critical Section API 111
Common.bib file 47 critical sections 84, 110
compile phase 40 CSV. See comma-separated values (CSV)
compiler and linker (Nmake.exe) 57 custom build actions based on command-line tools 61
compiler errors 63 custom CETK tests 182
component cloning 18 custom design templates 4
componentized operating system 91
components of a Board Support Package (BSP) 200
COMPRESSION parameter 49
D
conditional file processing 53 data integrity 55
conditional statements and debugging 158 database (.db) files 46, 54
CONFIG section 49, 83 DbgMsg feature. See debug message (DbgMsg) feature
Config.bib file 83, 224, 270, 290 DBGPARAM variable 152
configuration files for Platform Builder 12, 199 DDI. See Device Driver Interface (DDI)
Configuration Manager 6, 11 DDKPCIINFO structure 299
connectivity options 68 DDKReg_GetPciInfo function 299
Console registry parameters 96 DDKReg_GetWindowInfo function 299
Consumer Media Device design template 4 DDKWINDOWINFO structure 299
context management 252 DeactivateDevice function 258
device context 253
 Index 317

deadlocks 115, 145, 159 dependency handling 93

Debug build configuration 6, 10 DependXX entry 93
debug message (DbgMsg) feature 147 deploying a run-time image 68–71
debug message options 150 design
debug message service 149, 155 advanced configurations 10
debug zones 151 build options 3
best practices for 157 catalog items 3
bypassing of 152 environment variables 10
DBGPARAM variable 152 file and directory structure 11
definition of 154 internationalization 7
dialog box for 155 language settings 7
dpCurSettings variable 156 multiple platforms support 10
enabling and disabling of 155, 157 operating system (OS) 1–35
overriding at startup 156 OS design overview 3
registration of 152 redistribute 11
registry settings for 156 subprojects 3
SetDbgZone function 155 template variants 4
Tux DLLs and 184 templates 4
Watch window and 155 design template variants 4
debugger extension commands (CEDebugX) 159 design templates 4
debugger options 70 Consumer Media Device 4
debugging 6, 145–196 custom 4
assembly language and 188 Device Emulator: ARMV4I 29
Board Support Package (BSP) and 168 Enterprise Terminal 97
boot loaders and 188 PBCXML structures 4
breakpoints for 149 PDA Device 4, 29
CE Dump File Reader 161 Small Footprint Device 4
conditional statements and 158 Thin Client 4
debug zones 151 DestroyInstance function 280
enabling 168–175 development cycle 145
essential components for 149 DEVFLAGS_LOADLIBRARY flag 83
excluding debugging code from release builds 158 device classes 135
hardware-assisted 169 device context 253
hardware-debugging interface 70 device driver 13
interrupt handlers and 173 application caller buffers and 291
kernel debugger 70 Board Support Package (BSP) and 201
macros for debug messages 150 building a 254
postmortem debugger 70, 118 bus-agnostic 300
retail macros for 150 context management 252
serial debug output functions 209 developing a 241–308
target control commands 159 device register access 226
Tux DLLs 184 DllMain function for a 243
verbosity of 150, 158 IClass value for a 264
DEBUGLED macro 151 interface GUIDs 264
DEBUGMSG macro 150 interrupt handlers in a 272–282
default locale 8 IOControl function in a 244
DefaultSuite parameter 181 kernel mode restrictions 268
defects on a target device 145 layered driver architecture 244
DEFFILE directive 61 legacy name for a 248
delayed startup 95 load procedure for a 261
Svcstart sample for 95 loading and unloading 247, 258
demand paging 50, 82 monolithic driver architecture 244
demonstrate the features of a new development board 4 naming conventions for 248
318 Index

native drivers 243 dynamically mapped virtual addresses 224

paging and 243 dynamic-link libraries (DLLs) 15
portability of a 297 C interface and 99
power management for a 283–287 device drivers and 243
power states 127 DYNLINK directive 60
Reflector service and 268
registry entries for a 263
resource sharing between the OAL and a 226
E
shared memory region for communication 226 East Asian languages 7
source code folders for a 217 Eboot boot loader 187
Sources file directives for a 257 Eboot.bib file 206
stream drivers 243 elements
Device Driver Interface (DDI) 243 .NET Compact Framework 2.0 4
Device Emulator (DMA) 69 catalog items 3
Device Emulator: ARMV4I 29 Internet Explorer 4
Device Manager 83 OS design 3
loading device drivers at boot time 261 WordPad 4
overview of 247 embedded operating systems
Power Manager (PM.dll) 125 UNIX–based 103
registry settings 93 embedded pointers 288, 292
shell of 247 Enable Eboot Space In Memory option 9
stream driver interaction 244 Enable Event Tracking During Boot option 9
device names 249 Enable Hardware-Assisted Debugging Support option 9
device register access 226 Enable Kernel Debugger option 9
DeviceIoControl function 247, 292 Enable Profiling option 9
DevicePowerNotify function 127, 133, 283 enabling all debug zones 157
DHCP. See Dynamic Host Configuration Protocol (DHCP) EnterCriticalSection function 110
diagnose the overall health of the system 160 Enterprise Terminal design template 4, 97
directives based on environment variables 41 EnumDevices function 267
directives for Sources files 61 environment options 10
Dirs files 57 environment variables 10, 103
DIRS keyword 57 _TARGETPLATROOT 203
DIRS_CE keyword 57 conditional statements based on 53
Disassembly tool 162 IMGNODEBUGGER 168
display item dependencies 53 IMGNOKITL 168
DLL. See dynamic-link libraries (DLLs) WINCEDEBUG 150
DLLENTRY directive 61 Error List window 64
DllMain function 243 Error Report Generator catalog item 70
download methods 68, 186 ERRORMSG macro 151
download progress indication 212 errors during the build process 63
dpCurSettings variable 156 Ethdbg boot loader 205
Dr. Watson 118 Ethernet download service 69
driver globals (DRV_GLB) 207 Ethernet support functions 210
driver power states 127 Event API 114
driver source code 205 event logging zones 163
DRIVER_GLOBALS structure 226 event objects 114
DriverDetect parameter 182 event tracking 9
Drivers\BuiltIn registry key 261 CeLog system and 116
DRV_GLB. See driver globals (DRV_GLB) exception handling 118–124
Dynamic Host Configuration Protocol (DHCP) 95, 187 first chance 119
dynamic management of debug messages 150 hardware 119
dynamic memory allocation 121 just in time (JIT) debugging 119
dynamically loading a driver 258
 Index 319

kernel debugger and 119 Dirs files 57

memory access and 296 Eboot.bib 206
minimizing the total number of committed memory pages Initdb.ini 56
through 121 Initobj.dat 55–56
postmortem debugger 118 Makefile file 61
raise exceptions 119 Nk.bin file 41
RaiseException function 119 Oalioctl.dll 226
second chance 119 Platform.bib 24, 51
syntax 120 Platform.dat 55
termination handler 121 Platform.reg 54
unhandled page faults 122 Project.bib 47
excluding debugging code from release builds 158 Project.dat 55
exclusion from a run-time image 17 Reginit.ini 56
eXDI. See Extended Debugging Interface (eXDI) shortcut files 94
execute in place (XIP) 220 Sources file 24, 59
EXEENTRY directive 61 Sysgen.bat 37
exiting threads 105 Udevice.exe 268
ExitThread function 106 FILES section 51
export directive 99 Filesys.exe 55, 231
exporting a catalog item from the catalog 24 FileSystemPowerFunction 231–232
exporting stream functions 255 FIQ. See Fast Interrupt (FIQ) line
Extended Debugging Interface (eXDI) 149 FIXUPVAR parameter 50
Extensible Data Interchange (XDI) 70 Flags registry value 266
Extensible Markup Language (XML) 4 flash memory support 211
Extensible Resource Identifier (XRI) 70 Flush the X86 TLB on X86 systems 50
Flush Tracked Events To Release Directory option 9
FMerge tool (FMerge.exe) 67
F FMerge.exe. See FMerge tool (FMerge.exe)
Fast Interrupt (FIQ) line 276 folder structure of a Board Support Package (BSP) 203
file and directory structure of OS designs 11 footprint of the operating system 1
file I/O operations 248 ForceDuplicate parameter 293
file system (.dat) files 46, 55 frame buffers of peripheral devices 224
file system APIs 247 FreeIntChainHandler function 280–281
file type definitions for MODULES and FILES sections 52 FreePhysMem function 226
files FSRAMPERCENT parameter 50
.bib files 46 full kernel mode 50
.dat files 46, 55
.db files 46, 54
.pbcxml files 21
G
.reg files 46, 54 General Purpose Input/Output (GPIO) 90
.tks files 179 general registry entries for device drivers 263
Bsp_cfg.h 276 generic installable ISR (GIISR) 281
Build.err 63 Getappverif_cetk.bat file 163
Build.log 63 GetExitCodeThread function 106
Build.wrn 63 GetProcAddress API 243
Ce.bib 47, 56 GIISR. See generic installable ISR (GIISR)
Chain.bin 51 globally unique identifier (GUID) 264
Chain.lst 51 GPIO. See General Purpose Input/Output (GPIO)
Common.bib 47 graphical user interface (GUI) 97
Config.bib 83, 224, 290 Graphics, Windowing, and Events Subsystem (GWES) 84, 92,
Device.dll 247 243
Devmgr.dll 247 GUI. See graphical user interface (GUI)
320 Index

GUID. See globally unique identifier (GUID) industrial control systems 101
GWES. SeeGraphics, Windowing, and Events Subsystem infinite loops 147
(GWES) INIT registry key 92
GwesPowerOffSystem function 230 Initdb.ini file 56
initializing a device context 253
initializing virtual memory 213
H Initobj.dat file 55–56
H flag 271 input/output operations 224
HalTranslateBusAddress function 290 installable ISR (IISR) 280
handles to system objects 103 architecture 280
hardware breakpoints 174 DLL functions 280
hardware conflicts 145 external dependencies and 281
hardware debugger stub (HdStub) 148 Plug and Play 280
hardware exceptions 119 registering an 281
hardware initialization tasks 209 instance-specific resources 252
hardware timer 83, 85 Institute of Electrical and Electronic Engineers (IEEE) 186
OEMIdle function and 136 integrated development environment (IDE) 5
hardware validation 90 IntelliSense 63
hardware-assisted debugging 169 interface GUIDs 264
hardware-debugging interface 70 Interlock API 115, 214
hardware-independent code 201 internal test applications 13
HdStub. See hardware debugger stub (HdStub) internationalization 7
Heap Walker 147 code pages 8
heaps 84 default locale 8
heat dissipation 125 locales 7
high-performance counters 85 Internet Explorer 4
honor the /base linker setting 50 Sample Browser catalog item 32
HookInterrupt function 276 thin client shell and 97
host process groups 270 inter-process communication 222
interrupt handlers
architecture of 272
I breakpoints and 173
I/O controls (IOCTLs) 132 communication between an ISR and an IST 279
I/O operations 248 device drivers and 272–282
IClass definitions 135 WaitForMultipleObjects function in 276
IClass value 264, 284–285 interrupt latency timing 85, 90, 216
IDE. See integrated development environment (IDE) Interrupt Latency Timing (ILTiming) tool 85, 216
Idle event 229 parameters for the 86
Idle mode 229 interrupt mappings
Idle power state 83 dynamic 277
idle threads 87 kernel arrays for 277
IEEE. See Institute of Electrical and Electronic Engineers shared 279
(IEEE) static 276
IISR. See installable ISR (IISR) Interrupt Service Routine (ISR) 216, 273–274
ILTiming. See Interrupt Latency Timing (ILTiming) tool Interrupt Service Thread (IST) 216, 273–274
image configuration files 56 InterruptDone function 273
IMGNODEBUGGER environment variable 168 InterruptInitialize function 275
IMGNOKITL environment variable 168 interrupts 272
inactivity timeout 229 synchronization capabilities in the OAL 272
INCLUDES directive 60 IOControl function 244, 280, 284
InCradle 128 IOCTLs. See I/O controls (IOCTLs)
increase code re-usability 203 IP address configuration 95
IPv6 4
 Index 321

ISR latency 85, 216 KERNELFIXUPS parameter 50

ISR. See Interrupt Service Routine (ISR) KernelIoControl function 226, 277
ISRHandler function 280 kernel-mode drivers 268
IST latency 85, 216 KernelStart function 214
IST. See Interrupt Service Thread (IST) keyboard events 272
kiosk mode 101
managed applications and 101
J sample code 138
JIT debugging. See just in time (JIT) debugging KITL. See Kernel Independent Transport Layer (KITL)
joint test action group (JTAG) probe 169, 186
JTAG probe. See joint test action group (JTAG) probe
just in time (JIT) debugging 119, 149
L
LAN. See Local Area Network (LAN)
language settings 7
K last known good configuration 55
K flag 270 latencies 85
Kato logging engine 182 ISRs and ISTs 85
Kato.exe. See test results logger (Kato.exe) LaunchXX entry 93
KdStub 70, 119, 148, 169 layered driver 245
kernel access checks 293 architecture 244
kernel address space 220 LDEFINES directive 60
kernel debugger 9, 149, 168–169 legacy names 248
application debugging and 149 LIBRARY directive 60
breaking into the 119 linker warnings and errors 63
exception handling and 119 List Nearest Symbols tool 162
KdStub 70, 119, 148 LoadDriver function 83, 243
obtaining run-time information 148 LoadIntChainHandler function 273, 279–281
kernel driver restrictions 268 LoadKernelLibrary function 224
Kernel Independent Transport Layer (KITL) 3 LoadLibrary function 83, 243
boot arguments for 171 Local Area Network (LAN) 29
communication interface 170 locale 6
enabling 9, 169 Localize The Build option 8
methods of operation 170 localize the OS design 7
Remote Kernel Tracker tool 116 lower power consumption 125
support functions 216
target control architecture and 148
transport mechanisms 70
M
kernel initialization routines 187 macros for debug messages 150
kernel interrupt mapping arrays 277 ASSERTMSG 151
kernel memory regions 221 DBGPARAM variable 152
kernel objects 84 debug zones and 151
critical sections 110 DEBUGLED 151
events 110 DEBUGMSG 150
interlocks 110 ERRORMSG 151
mutexes 110 RETAILLED 151
semaphores 110 RETAILMSG 151
thread synchronization and 110 main thread of a process 104
kernel process (Nk.exe) 291 MainMemoryEndAddress function 225
kernel profiler 9 Make Binary Image tool (Makeimg.exe) 37, 47
kernel space 219 make run-time image phase 41
kernel startup support functions 214 errors during the 67
Kernel Tracker 147 Makefile file 61
322 Index

Makeimg.exe. See Make Binary Image tool (Makeimg.exe) Microprocessor without Interlocked Pipeline Stages (MIPS)
managed applications 281
kiosk mode and 101 Microsoft kernel code 214
Windows Embedded CE Test Kit (CETK) and 178 Microsoft Platform Builder for Windows Embedded CE 6.0 1,
managed code development 32 37
mapping tables 213 advanced debugger tools 161
marshaling data across boundaries 288–296 analyzing build results 63–67
marshaling helpers 293 BSP Cloning Wizard 202
MDD. See model device driver (MDD) Catalog Editor 22
mechanical wear and tear 125 configuration files for 12
medical monitoring devices 101 Debug Message Options 150
memcpy 296 Debug Zones dialog box 155
memory access 288 Heap Walker 147
asynchronous 293, 295 Kernel Tracker 147
exception handling and 296 OS Design Wizard 3
synchronous 294 Process Viewer 147
memory layout 46 Software Development Kit (SDK) 26
kernel regions 221 Subproject Wizard 14, 254
memory mapping of a BSP 219–227 Target Control option 158
process regions 222 Target Device Connectivity Options dialog box 68, 169
reserved regions from system memory 291 Microsoft Visual Studio 2005 3
memory leaks 145, 159 Build menu 41
memory management building run-time images in 41–45
ARM–based platforms 223 Catalog Items View 4
critical sections and 84 Configuration Manager 6
demand paging 82 connectivity options in 68
DEVFLAGS_LOADLIBRARY flag 83 debug information in the Output window of 149
dynamic allocation 121 debugging a target device 171
dynamically mapped virtual addresses 224 Error List window 64
heaps 84 IntelliSense 63
LoadDriver function and 83 Open Build Window command 46
LoadLibrary function 83 Output window 64
MIPS–based platforms 223 Solution Explorer 5
mutexes and 84 Watch window 155
noncontiguous physical memory and 225 minimizing the total number of committed memory pages
pre-committing memory pages 121 121
processes and 84 MIPS. See Microprocessor without Interlocked Pipeline Stages
reuse of system memory 84 (MIPS)
ROMFLAGS option 83 MIPS–based platforms 223
sharing of memory 82 MmMapIoSpace function 226, 279, 290
SHx–based platforms 223 MMU. See Memory Management Unit (MMU)
statically mapped virtual addresses 224 MmUnmapIoSpace function 290
system memory pool 84 model device driver (MDD) 18, 245
unhandled page faults 122 MODULES section 51
virtual address space 103 Modules tool 162
x86–based platforms 223 monolithic driver 245
Memory Management Unit (MMU) 213, 223, 288 architecture 244
memory mappings 206 mouse tests 182
memory regions 221–222 multi-bin image notification 212
MEMORY section 48 multiple platforms support 10
Memory tool 162 multitasking 103
memory-mapped files 222 multithreaded operating system 103
menu of a boot loader 211 multithreaded programming 115
 Index 323

mutexes 84, 111 StartUp entry point of the 214

CreateMutex function 111 OEM address table 213
deadlocks 115 OEM. See Original Equipment Manufacturers (OEM)
Mutex API 112 OEMAddressTable table 213, 225
ReleaseMutex function 112 OEMEthGetFrame function 210
TerminateThread function and 106 OEMEthGetSecs function 210
My Documents directory 55 OEMEthSendFrame function 210
OEMGetExtensionDRAM function 225
OEMGLOBALS structure 214
N OEMIdle function 135, 229
naming conventions for drivers 248 OEMInit function 215, 272
native drivers 243 OEMInitGlobals function 214
new system of managing virtual memory 219 OEMInterruptDisable function 275
NEWCPLINFO information 100 OEMInterruptDone function 273, 275
NK memory region 270 OEMInterruptEnable function 275
Nk.bin file 41 OEMInterruptHandler function 275–276
NKCallIntChain function 279 OEMInterruptHandlerFIQ function 276
NKCreateStaticMapping function 224 OEMIoControl function 226
NKDbgPrintf function 150 OEMNMIHandler function 232
NKGLOBALS structure 214 OEMPlatformInit routine 209
Nmake.exe. See compiler and linker (Nmake.exe) OEMPowerOff routine 230
noise levels 125 OEMReadData function 210
NOLIBC=1 directive 281 OEMWriteDebugLED function 151
non-cached virtual addresses 224 OHCI. See Open Host Controller Interface (OHCI)
non-concurrent buffer access 294 Open Build Window command 46
noncontiguous memory 49 open context 253
physical 225 Open Host Controller Interface (OHCI) 277
non-real-time APIs 84 OpenDeviceKey function 266
non-real-time components 82 operating costs 125
NOTARGET directive 60 operating system (OS)
advanced configurations 10
black shell 101
O build options 3
OAL. See OEM adaptation layer (OAL) command processor shell 96
OALIntrRequestSysIntr function 277 componentized 91
OALIntrStaticTranslate function 277 creating and customizing 3–12
Oalioctl.dll 226 customization 5
OALPAtoVA function 279, 290 dependency handling 93
OALTimerIntrHandler function 85 design 1–35
object store 54 Device Manager 83
OEM adaptation layer (OAL) 3, 201 elements 3
architecture-generic tasks 214 environment variables 10
code sharing between the boot loader and the 214 footprint 1
interrupt management functions in the 275 internationalization 7
interrupt-synchronization capabilities in the 272 kernel objects 84
IOCTL codes 226 kiosk mode 101
OEMInit function 215 language settings 7
power management support and 228 managed code development 32
Power Manager (PM.dll) 125 multithreaded 103
power state transitions and 228 optimizing the performance 9
Profile timer support functions 217 power management 83
resource sharing between drivers and the 226 processing model 103
real-time performance of the 88
324 Index

redistribute and OS design 11 Personal Computer Memory Card International Association

run-time image 1 (PCMCIA) 249
shells 96–97 personal digital assistant (PDA) 228
source code 18 physical memory access restrictions 290
standard shell 97 physical memory allocation 290
system applications 91 Platform Builder Catalog XML (PBCXML) 4
thin client shell 97 Platform Builder. See Microsoft Platform Builder for Windows
UNIX–based 103 Embedded CE 6.0
Windows Task Manager (TaskMan) 97 Platform Builder–specific build commands 45
Windows-based Terminal (WBT) shell 97 platform device driver (PDD) 245
Operating System Benchmark (OSBench). See OSBench Platform.bib file 24, 51
OPTIONAL_DIRS keyword 57 Platform.dat file 55
Original Equipment Manufacturers (OEM) 197 Platform.reg file 54
OS Access (OsAxS) 148 platform-specific source code 205
OS Design Wizard 3, 5, 12, 29 Plug and Play 247, 280
Board Support Packages wizard page 10 pNKEnumExtensionDRAM function 225
multiple platforms support 10–11 pointer marshaling 293
standard shell and 97 pointer parameters 292
OS design. See operating system (OS) design portability of a device driver 297
OsAxS. See OS Access (OsAxS) PortNumber parameter 181
OSBench tool 85, 87 POSTLINK_PASS_CMD directive 61
parameters for the 88 postmortem debugger 70, 118
source code of 87 Power Control Panel applet 129
OutOfCradle 128 power management 83, 125–137
OUTPUT parameter 50 activity timers and 128
Output window 64 application interface 125, 133
overriding debug zones at startup 156 benefits 125
context switching 83
device drivers and 283–287
P device interface 126, 132
page faults driver power states 127
unhandled 122 I/O controls (IOCTLs) for 132, 284
PAN. See Personal Area Network (PAN) Idle event 229
PBCXML. See Platform Builder Catalog XML (PBCXML) Idle power state 83
PCI. See Peripheral Component Interconnect (PCI) notification interface 125, 130, 285
PCMCIA. See Personal Computer Memory Card International OEM adaptation layer (OAL) 125, 228
Association (PCMCIA) optimizing power consumption by using dynamic timers
PDA Device design template 4, 29 136
PDA. See personal digital assistant (PDA) processor idle state 135
PDD. See platform device driver (PDD) restrictions of 284
Pegasus registry key 157 sample code 138
performance monitoring 82–90 single-threaded mode and 284
alerts for 90 system power states 127
charts for 90 wakeup sources and 232
interrupt latency timing 85, 90 Power Manager (PM.dll) 125
reports for 90 APIs 126
waveform generators and 90 application interface 125, 133
performance optimization 9, 82–90 architecture 125
PerfToCsv parser tool 185 battery life and 127
Peripheral Component Interconnect (PCI) 241 components 125
persistent data storage 54 device drivers and 283
Personal Area Network (PAN) 29 device interface 126, 132
notification interface 125, 130
 Index 325

power states Q
activity timers and 128
configuration of 134 Q flag 271
Critical Off state 229, 232 QRimplicit-import 281
device classes and 135 quality assurance 145
driver 127 quantum 104
InCradle 128 QueryPerformanceCounter function 88
internal transitions of 133 QueryPerformanceFrequency function 88
OutOfCradle 128
overriding the configuration for an individual device 134 R
power-off state 229
processor idle 135 race conditions 147
registry entries for 134 RaiseException function 119
Suspend state 229–230 raising exceptions 119
system 127 RAM file system 50, 55
transitions of 128, 228 RAM_AUTOSIZE parameter 50
waking up from Suspend state 231 RAM-backed map files 222
power-off state 229 RAMIMAGE parameter 49, 225
PowerOffSystem function 126, 231 RDEFINES directive 60
PQOAL. See Production Quality OEM adaptation layer RDP. See Remote Desktop Protocol (RDP)
(PQOAL) Readlog tool 165
pre-boot routines 186 real-time performance 82, 88
pre-committing memory pages 121 measurement tools 84
preemptive multitasking 103 real-time systems design 81
PRELINK_PASS_CMD directive 61 rebuild commands 42
preprocessing conditions 54 Rebuild Current BSP And Subprojects 24
primary thread of execution 103 redistributing an OS design 11
priority list for threads 103 reducing BSP development time 201
process address space 222 reference naming matching 166
process identifier 103 Reflector service 268
Process Management API 104 Reginit.ini file 56, 266
Process Viewer 147 RegisterDevice function 258
processes and threads 103 Registers tool 162
Processes tool 162 registry (.reg) files 46, 54
processing model 103 registry settings 92
processor idle state 135 CELog registry parameters 163
Production Quality OEM adaptation layer (PQOAL) 197 CELogFlush tool 165
advanced debugger tools 201 Clientside.exe start parameters 181
professional Windows Embedded CE solutions 21 command processor shell 96
PROFILE parameter 50 Console key 96
Profile timer support functions 217 CurrentControlSet\State key 134
program database (.pdb) files 6 debug zones and 156
PROGRAM directive 60 DependXX entry 93
Program Files directory 55 device classes and 135
Project.bib file 47 device drivers and 263
Project.dat file 55 event logging zones and 163
Projsysgen.bat file 16 Flags registry value 266
public source code 18 HKEY_LOCAL_MACHINE\Drivers\Active 262, 297
modifications 19 HKEY_LOCAL_MACHINE\Drivers\BuiltIn 261, 297
public tree modification 18 HKEY_LOCAL_MACHINE\INIT 92
HKEY_LOCAL_MACHINE\System\CurrentControlSet\Co
ntrol\Power\Interfaces 285
interrupt-related 298
326 Index

LaunchXX entry 93 building and deploying 37–79

memory-related 299 building and deploying from the command line 46
PCI-related 299 configuration files for the 56
Pegasus registry key 157 content of a 46
power state definitions 134 deploying 68–71
startup parameters 92 download methods 186, 210
subprojects and 16 excluding a subproject from a 17
Svcstart sample service 95 Run-Time Image Can Be Larger Than 32 MB option 9
user mode driver host process (Udevice.exe) and 269
UserProcGroup registry entry 270
Reldir directory 12
S
Release build configuration 6, 10 S flag 271
release copy phase 41 sample code
errors during the 66 CreateFile function 257
skipping the 41 dynamic memory allocation technique 123
release directory 41 dynamically loading a driver 258
ReleaseMutex function 112 implementing stream functions 254
ReleaseSemaphore function 113 initializing a device context 253
RELEASETYPE directive 60 Interrupt Service Thread (IST) 275
Remote Desktop Protocol (RDP) 4, 97 IOCTL_HAL_REQUEST_SYSINTR and
Remote Kernel Tracker tool 116, 164 IOCTL_HAL_RELEASE_SYSINTR 277
Remote Performance Monitor 85, 88 kiosk mode 138
extension DLLs 89 non-concurrent buffer access 294
monitored objects 89 OEMAddressTable table 213
RequestDeviceNotifications function 267 OEMPlatformInit function 210
RESERVED keyword 291 power management 138
RESETVECTOR parameter 50 power notifications 131
Resource Consume tool 179 thread execution 138
resource sharing between drivers and the OAL 226 thread management 109
restrictions of power management 284 Sample Device Emulator eXDI2 Driver 70, 169
ResumeThread function 108 scheduling
resuming threads 108 quantum 104
retail macros for debugging 150 thread scheduler 136
RETAILLED macro 151 time-slice algorithm 104
RETAILMSG macro 151 SCM. See Service Control Manager (SCM)
reuse of code 197 SDK. See Software Development Kit (SDK)
reuse of system memory 84 search for catalog items 6
robustness of applications 118 sections of .bib files 47
ROM Image Builder tool (Romimage.exe) 47 CONFIG section 49
ROM image file system 187 MEMORY 48
ROM Windows directory 55 security context 103
ROM_AUTOSIZE parameter 50 SEH. See structured exception handling (SEH)
ROM–based applications 55 semaphores 112–113
ROMFLAGS option 83 CreateSemaphore function 112
ROMFLAGS parameter 50 nonsignaled state 113
Romimage.exe. See ROM Image Builder tool (Romimage.exe) ReleaseSemaphore function 113
ROMOFFSET parameter 50 sequential access scenario 295
ROMSIZE parameter 50 serial communication parameters 69
ROMSTART parameter 50 serial debug output functions 209
ROMWIDTH parameter 50 Serial Peripheral Interface (SPI) 252
RS232 connection 69 ServerIP parameter 181
run-time image 1 ServerName parameter 181
adding custom settings to a 46
 Index 327

Service Control Manager (SCM) 95 source control software 12

services host process (Services.exe) 95 SOURCELIBS directive 60
Services.exe. See services host process (Services.exe) SOURCES directive 60
SetDbgZone function 155 Sources file 24, 59
SetSystemPowerState function 230 ADEFINES directive 60
setting a breakpoint 172 CDEFINES directive 60
shared memory region for driver communication 226 CDEFINES entry 24
shells 96–97 Control Panel and 100
black shell 101 DEFFILE directive 61
command processor shell 96 DLLENTRY directive 61
standard shell 97 DYNLINK directive 60
thin client shell 97 EXEENTRY directive 61
Windows Task Manager (TaskMan) 97 INCLUDES directive 60
Windows-based Terminal (WBT) 97 LDEFINES directive 60
ship builds 164 LIBRARY directive 60
shortcut files 94 NOTARGET directive 60
shortcuts on the desktop 55 POSTLINK_PASS_CMD directive 61
SHx–based platforms 223 PRELINK_PASS_CMD directive 61
SignalStarted API 93, 101 PROGRAM directive 60
Simple Windows Embedded CE DLL Subproject template RDEFINES directive 60
254 RELEASETYPE directive 60
single-threaded mode 284 SKIPBUILD directive 61
skeleton Tux module 183 SOURCELIBS directive 60
SKIPBUILD directive 61 SOURCES directive 60
skipping the release copy phase 41 TARGETLIBS directive 60
Sleep function 83, 108 TARGETNAME directive 60
SleepTillTick function 108 TARGETPATH directive 60
Small Footprint Device design template 4 TARGETTYPE directive 60
small-footprint devices 82 WINCE_OVERRIDE_CFLAGS directive 61
software development cycle 145 WINCECPU directive 61
Software Development Kit (SDK) 26–28 WINCETARGETFILE0 directive 61
adding new files 27 WINCETARGETFILES directive 61
build process and 40 Sources file directives for a device driver 257
configuring and generating 26 SPI. See Serial Peripheral Interface (SPI)
generating and testing 35 SRE parameter 50
installation of 28 standalone mode 182
software exceptions 119 standard command prompt 46
software-related errors 147–167 standard directives for Sources files 61
Solution Explorer 5, 41 standard shell 97
Catalog Item Dependencies window 6 removing the 101
Catalog Items View 5 Start menu 55
Dirs files and 59 startup configuration 91
Property Pages dialog box 6 delayed startup and 95
Subproject Wizard 14 StartUp entry point of a boot loader 208
source code 18 Startup folder 94
Control Panel 98 restrictions 94
driver globals 207 StartUp function 187
drivers 205 startup registry parameters 92
Eboot.bib file 206 startup time
folders for device drivers 217 reducing 4
Power Manager (PM.dll) 126 StartupProcessFolder function 94
thread management sample code 109 starvation 161
Windows Task Manager (TaskMan) 97 static libraries 15
328 Index

static mapping regions of the kernel 223 thread 103

statically mapped virtual addresses 224 unintentional 157
Storage Device Block Driver Benchmark Test 180 synchronous memory access 294
storage partitioning routines 187 syntax check for source code 63
stream driver. See also stream interface driver Sysgen capture tool 19
stream drivers 243 Sysgen phase 40
context management and 252 errors during the 65
CreateFile function and 257 SYSGEN variables 10
device names for 249 conditional statements based on 53
exporting stream functions 255 subprojects and 16
instance-specific resources 252 Sysgen.bat 37
kernel mode restrictions for 268 SYSINTR value 273, 276
legacy names for 248 SYSINTR_NOP value 274
load procedure for 261 SYSINTR_TIMING interrupt event 85
loading and unloading 247, 258 system applications 91
naming conventions for 248 system memory mapping 219
Plug and Play 247 system memory pool 84
Sources file directives for 257 system performance
XXX prefix and 252 monitoring 82–90
stream interface API 250 optimization 82–90
exporting stream functions 255 real-time operating systems and 82
stream interface driver 247 system power states 127
Strict Localization Checking In The Build option 8 system programming 81–144
structured exception handling (SEH) 119 system scheduler 83
__except keyword 120 system testing 145, 176
__finally keyword 121 system timer 83
__try keyword 120
frame–based 120
subprojects 3
T
configurations files 14 target control architecture 148
configuring 13, 16–17 target control commands 159
creating and adding 14 Target Control service 158
Dirs files and 57 target control shell. See CE target control shell (CESH)
dynamic-link libraries (DLLs) and 15 target device
excluding from a run-time image 17 attaching to 71
image settings 16 debugger options 70
Projsysgen.bat file 16 defining communication parameters for a 68
registry settings and 16 initialize the file system and the system registry 46
reusing customizations and 47 loading Windows Embedded CE on a 68
static libraries and 15 Target Device Connectivity Options dialog box 68, 169
Subproject Wizard 14 target device control 147
SYSGEN variables and 16 TARGETLIBS directive 60
TARGETTYPE=NOTARGET 16 TARGETNAME directive 60
types of 13 TARGETPATH directive 60
without source code 16 TARGETTYPE directive 60
Suspend state 229–230 TARGETTYPE=NOTARGET 16
suspending threads 108 TCP/IPv6 Support 29
SuspendThread function 108 template variants 4
Svcstart sample service 95 Terminal server 97
registry parameters for 95 TerminateThread function 106
symbols 162 terminating threads 105
synchronization termination handler 121
deadlocks 115
 Index 329

test access port and boundary-scanning technology 186 tools

test engine (Tux.exe) 177 advanced debugger tools 161
command-line parameters 182 Advanced Memory tool 162
Test Kit Suite (.tks) files 179 Application Verifier tool 162, 179
test results logger (Kato.exe) 177 Autos tool 161
test suite 179 Breakpoints 161
testing a system 145–196 Build.exe 57
automated 176 Call Stack tool 161
TFTP. See Trivial File Transfer Protocol (TFTP) CE Stress tool 179
Thin Client design template 4 CELogFlush tool 164
thin client shell 97 CETest.exe 177
thread 83 Cetkpar.exe 185
creating 105 Clientside.exe 177, 180
deadlocks 115 Control Panel 97
definition 103 CPU Monitor 179
exiting 105 debugging and testing 145
idle 87 Disassembly tool 162
main thread of a process 104 Dr. Watson 118
management functions 105 Filesys.exe 55
maximum number of 103 FMerge (FMerge.exe) 67
primary of execution 103 Heap Walker 147
priority 103, 107 ILTiming 85, 216
priority levels 107 Kato.exe 177
quantum 104 Kernel Tracker 147
resuming 108 List Nearest Symbols tool 162
sample code 138 Make Binary Image (Makeimg.exe) 37, 47
scheduler 136 Memory tool 162
scheduling 103 Modules tool 162
starvation 161 Nmake.exe 57
suspending 108 OSBench 85
synchronization 103, 110 PerfToCsv parser 185
terminating 105 Power Control Panel applet 129
time-slice algorithm 104 Process Viewer 147
troubleshooting synchronization 115 Processes tool 162
unintentional synchronization 157 Readlog tool 165
worker threads 104 real-time performance measurement 84
Thread Management API 104 Registers tool 162
thread priority 83 Remote Kernel Tracker 116, 164
thread synchronization Remote Performance Monitor 85, 88
interrupt handling and 272 Resource Consume tool 179
unintentional 157 ROM Image Builder (Romimage.exe) 47
Threads tool 162 Sysgen capture tool 19
tick timer 85 Sysgen.bat 37
timer events 272 Threads tool 162
timers Tux.exe 177
hardware timer 83 Watch window 161
OALTimerIntrHandler function 85 Windows Task Manager (TaskMan) 97
power management and 128 transaction–based storage mechanism 54
SleepTillTick function 108 TransBusAddrToVirtual function 290
SYSINTR_TIMING interrupt event 85 Transition Lookaside Buffer (TLB) 214
system timer 83 transport mechanisms 68, 70
time-slice algorithm 104 trap handler 272
TLB. See Transition Lookaside Buffer (TLB) Trivial File Transfer Protocol (TFTP) 187
330 Index

troubleshooting Virtual Memory Manager (VMM) 288

build issues 65 VirtualAlloc function 122, 224, 279, 296
thread synchronization 115 VirtualCopy function 224, 279
Trust only ROM modules 50 VirtualFree function 224
trusted images 212 virtual-to-physical address mappings 213
TryEnterCriticalSection function 110 Visual Studio 2005. See Microsoft Visual Studio 2005
TUX DLL template 183 VMM. See Virtual Memory Manager (VMM)
Tux.exe. See test engine (Tux.exe) vulnerabilities 293

U W
UART. See Universal Asynchronous Receiver/Transmitter WaitForMultipleObjects function 108, 276
(UART) WaitForSingleObject function 108, 274
Udevice.exe. See user mode driver host process (Udevice.exe) wakeup sources 232
UDP. See User Datagram Protocol (UDP) waking up from Suspend state 231
uninitialized variables 147 Watch window 155, 161
unintentional thread synchronization 157 waveform generator 90
Universal Asynchronous Receiver/Transmitter (UART) 186 WCE TUX DLL template 183
Universal Serial Bus (USB) 69 Win32 API 84
UNIX–based embedded operating systems 103 WINCE_OVERRIDE_CFLAGS directive 61
unrecoverable system lockup 284 WINCECPU directive 61
USB. See Universal Serial Bus (USB) WINCEDEBUG environment variable 150
Use Xcopy Instead Of Links To Populate Release Directory WINCETARGETFILE0 directive 61
option 10 WINCETARGETFILES directive 61
user applications 91 window drawing 84
Terminal server and 97 Windows directory 55
User Datagram Protocol (UDP) 187 Windows Embedded CE custom test components for the
user mode driver host process (Udevice.exe) 268 Microsoft Windows CE Test Kit (CETK) 14
application caller buffers and 291 Windows Embedded CE shells 96–97
registry entries for 269 Windows Embedded CE Standard Shell 97
user space 219 Windows Embedded CE Subproject Wizard 14, 254
User-Defined Test Wizard 183 Windows Embedded CE Test Kit (CETK) 176–185
user-mode drivers 268 analyzing test results 184
UserProcGroup registry entry 270 Application Verifier tool 162
architecture of 176
CETK parser (Cetkpar.exe) 185
V client-side application (Clientside.exe) 177
validate a system in its final configuration 145 command-line parameters for 180
video memory 232 custom tests based on 179–180, 182
virtual address space 103 managed code and 178
dynamically mapped addresses 224 overview of 176
frame buffers of peripheral devices and 224 PerfToCsv parser tool 185
input/output operations and 224 skeleton Tux module 183
kernel space 219 standalone mode 182
non-cached 224 test engine (Tux.exe) 177
noncontiguous physical memory and 225 Test Kit Suite (.tks) files 179
statically mapped addresses 224 test results logger (Kato.exe) 177
user space 219 Test Suite Editor 179
virtual memory User-Defined Test Wizard 183
initializing 213 workstation server application (CETest.exe) 178
mapping tables 213 zorch parameter 180
new system of 219 Windows Manager 232
 Index 331

Windows Network Projector 4 XIP chain 51

Windows Sockets (Winsock) 177 XIP. See execute in place (XIP)
Windows Task Manager (TaskMan) 97 XIPSCHAIN parameter 51
Windows Thin Client 4 XML. See Extensible Markup Language (XML)
Windows-based Terminal (WBT) shell 97 XRI. See Extensible Resource Identifier (XRI)
Winsock. See Windows Sockets (Winsock) XXX prefix 252
WMV/MPEG-4 Video Codec 4 XXX_Init function 266
WordPad 4 XXX_IOControl function 283, 292
worker threads 104 XXX_PowerDown function 283
workstation server application (CETest.exe) 177–178 XXX_PowerUp function 283
Write Run-Time Image To Flash Memory option 10
WriteDebugLED function 151
Z
zone definitions 154
X zones registration 152
x86–based platforms 223 zorch parameter 180
X86BOOT parameter 51 297
XDI. See Extensible Data Interchange (XDI)