Windows internals http:// [email protected] http:// [email protected].
-
Upload
lino-pieri -
Category
Documents
-
view
234 -
download
2
Transcript of Windows internals http:// [email protected] http:// [email protected].
Windows Windows internalsinternals
http://http://www.microsoft.com/italy/www.microsoft.com/italy/msdn/studentimsdn/studenti
http://http://www.microsoft.com/italy/www.microsoft.com/italy/msdn/studentimsdn/studenti
BenvenutiBenvenuti
Un giorno di full immersion nel Un giorno di full immersion nel kernel di Windowskernel di Windows Architettura del kernelArchitettura del kernel Come funzionaCome funziona Come sfruttarlo al meglioCome sfruttarlo al meglio Come analizzare i problemiCome analizzare i problemi
AgendaAgenda Architettura kernel di WindowsArchitettura kernel di Windows Gestione della memoriaGestione della memoria ProcessiProcessi ThreadThread Thread poolThread pool JobsJobs Interprocess communicationInterprocess communication Overlapped I/OOverlapped I/O Domande & RisposteDomande & Risposte
Architettura Architettura kernel di kernel di WindowsWindows
MS Windows NT: obiettivi MS Windows NT: obiettivi del progettodel progetto
CompatibilitàCompatibilità applicazioni Win32, Win16, MS-DOS, OS/2, applicazioni Win32, Win16, MS-DOS, OS/2,
POSIXPOSIX PortabilitàPortabilità
Ieri: piattaforma Intel, RISCIeri: piattaforma Intel, RISC Oggi: IA-32 (Pentium), IA-64 (Itanium)Oggi: IA-32 (Pentium), IA-64 (Itanium) A breve: AMD-64 (Opteron)A breve: AMD-64 (Opteron)
RobustezzaRobustezza EstendibilitàEstendibilità PerformancePerformance CompatibilitàCompatibilità
binaria, sorgente, file systembinaria, sorgente, file system
PortabilitàPortabilità
LaptopComputer
PersonalComputer
Server
Symmetric Multiprocessors
Architettura di MS Architettura di MS Windows NTWindows NT
I/ODevices
DMA/BusController
TimersCaches,
Interrupts
CPUPrivileged
Architecture
Software
Hardware
Applications and Subsystems (User-Mode Instruction Set)
I/O Manager
SecurityMonitor
ObjectManager
LocalIPC
VirtualMemoryManager
ProcessManager
DeviceDrivers
Kernel
HAL
GDIUSER
Robustezza:Robustezza:Spazi di indirizzamento Spazi di indirizzamento
separatiseparatiSystemMemory
(2 GB)
Per-ProcessMemory
(2 GB)
Paged
Non-paged
Paged
PhysicalAddressing Range
Robustezza: User Mode eRobustezza: User Mode ePrivileged-Processor Privileged-Processor
ModeMode User ModeUser Mode applicazioni in esecuzioneapplicazioni in esecuzione Accesso esclusivamente allo spazio di indirizzamento Accesso esclusivamente allo spazio di indirizzamento
dei processi dei processi Divieto di accesso diretto all’hardwareDivieto di accesso diretto all’hardware
Privileged-Processor ModePrivileged-Processor Mode Contiene il codice di sistema: executive, drivers, kernel Contiene il codice di sistema: executive, drivers, kernel
e HALe HAL ““Trusted”Trusted” Può eseguire qualsiasi istruzionePuò eseguire qualsiasi istruzione Accesso all’intero spazio di indirizzamentoAccesso all’intero spazio di indirizzamento
Robustezza: SecurityRobustezza: Security
Per-User PermissionsPer-User Permissions Access Control List (ACL)Access Control List (ACL)
Auditing AccessAuditing Access Quotas (sempre presente, non Quotas (sempre presente, non
implementato fino a Windows 2000)implementato fino a Windows 2000)
Robustezza: i Robustezza: i sottosistemisottosistemiUser Mode
Win32-BasedApplication
Win32-BasedApplication POSIXPOSIX OS/2
Subsystem
OS/2Subsystem
Win32Subsystem
Win32Subsystem
ExecutiveExecutive
Send
Reply
Local Procedure CallLocal Procedure Call
Privileged-Processor Mode
I/ODevices
DMA/BusController
TimersCaches,
Interrupts
CPUPrivileged
Architecture
Software
Hardware
Applications and Subsystems (User-Mode Instruction Set)
I/O Manager
SecurityMonitor
ObjectManager
LocalIPC
VirtualMemoryManager
ProcessManager
DeviceDrivers
Kernel
HAL
GDIUSER
EstendibilitàEstendibilità
NTFS
FAT
Jobs
TimerQueue
Encryption
NTFS-5
Gli oggetti di NT (kernel Gli oggetti di NT (kernel objects)objects)
ProcessProcess
ThreadThread
SectionSection FileFile
Access TokenAccess Token
EventEvent SemaphoreSemaphore
MutexMutex
RegistryRegistry
Object modelObject model
L’object model consente di:L’object model consente di: monitorare le risorsemonitorare le risorse implementare la sicurezzaimplementare la sicurezza condividere le risorsecondividere le risorse
Object: struttura internaObject: struttura interna
Object NameObject DirectorySecurity DescriptorQuota ChargesOpen Handle CounterOpen Handle DatabasePermanent/TemporaryKernel/User ModeType Object Pointer
Object NameObject DirectorySecurity DescriptorQuota ChargesOpen Handle CounterOpen Handle DatabasePermanent/TemporaryKernel/User ModeType Object Pointer
Object BodyObject Body
TypeObject
TypeObject
ObjectHeader
Object Attributes
Object: interfaccia Object: interfaccia esternaesterna
FunzioniFunzioni Parametri comuniParametri comuni CreateCreatexxxxxx Security attributes, inheritance, nameSecurity attributes, inheritance, name OpenOpenxxxxxx Security attributes, inheritance, nameSecurity attributes, inheritance, name BOOL CloseHandle(BOOL CloseHandle(hObjecthObject)) BOOL DuplicateHandle(BOOL DuplicateHandle(hSourceProcesshSourceProcess,, hSource hSource,,
hTargetProcesshTargetProcess,, lphTarget lphTarget,, fdwAccess fdwAccess,, fInheritfInherit,, fdwOptions fdwOptions))
Lo scope di un Object Handle è relativo a ogni Lo scope di un Object Handle è relativo a ogni singolo processosingolo processo
Durata di un oggettoDurata di un oggetto
Struttura Struttura SECURITY_ATTRIBUTESSECURITY_ATTRIBUTES
typedef struct _SECURITY_ATTRIBUTEStypedef struct _SECURITY_ATTRIBUTES
{{DWORD nLength;DWORD nLength;
LPVOID lpSecurityDescriptor;LPVOID lpSecurityDescriptor;
BOOL bInheritHandle;BOOL bInheritHandle;
} SECURITY_ATTRIBUTES;} SECURITY_ATTRIBUTES;
typedef struct _SECURITY_ATTRIBUTEStypedef struct _SECURITY_ATTRIBUTES
{{DWORD nLength;DWORD nLength;
LPVOID lpSecurityDescriptor;LPVOID lpSecurityDescriptor;
BOOL bInheritHandle;BOOL bInheritHandle;
} SECURITY_ATTRIBUTES;} SECURITY_ATTRIBUTES;
Security DetailSecurity DetailSecurity ID: LEESGroup IDs: TEAM1
TEAM2LOCALINTERACTIVEWORLD
Privileges: None . . .
Security ID: LEESGroup IDs: TEAM1
TEAM2LOCALINTERACTIVEWORLD
Privileges: None . . .
SecurityDescriptor
SecurityDescriptor
AllowLEES
SynchronizeModify State
AllowLEES
SynchronizeModify State
AllowTEAM1
Synchronize
AllowTEAM1
Synchronize
AllowTEAM2
SynchronizeModify State
AllowTEAM2
SynchronizeModify State
Access Token
Event Object Access Control List..
..
Architettura Windows Architettura Windows NT/2000NT/2000
Radici nel passato (VMS)Radici nel passato (VMS) Disegno modulare ed estendibileDisegno modulare ed estendibile Pochi cambiamenti e molte Pochi cambiamenti e molte
ottimizzazioni dal kernel di Windows ottimizzazioni dal kernel di Windows NT 3.1 a quello di Windows 2000NT 3.1 a quello di Windows 2000
Modello ad oggetti, ma non object-Modello ad oggetti, ma non object-orientedoriented
Gestione della Gestione della memoriamemoria
(Memory Manager)(Memory Manager)
Gestione della memoriaGestione della memoria
I processori iAPX86I processori iAPX86 Indirizzamenti real-mode e Indirizzamenti real-mode e
protected-modeprotected-mode Funzioni APIFunzioni API Condivisione della memoriaCondivisione della memoria VLM – Very Large MemoryVLM – Very Large Memory AWE – Address Windowing AWE – Address Windowing
ExtensionExtension
I Processori Intel iAPX86I Processori Intel iAPX86
Tutti eseguono il boot in Real ModeTutti eseguono il boot in Real Mode Su 8088/8086 è l’unica possibilitàSu 8088/8086 è l’unica possibilità Su 286 e successivi è necessario per Su 286 e successivi è necessario per
compatibilitàcompatibilità Dopo il boot 286 e successivi possono Dopo il boot 286 e successivi possono
passare al protected modepassare al protected mode Tutti hanno un’architettura Tutti hanno un’architettura
segmentatasegmentata
Indirizzamento in real-Indirizzamento in real-modemode
segment offset:15 0 15 0
(shift leftby 4 bits)
segment’s base address19 4
0 0 0 03 0
effective address15 0
0 0 0 01619
++
linear address019
RAM
1 MB
0
220 = 1MB
Real-modeReal-mode Nessun meccanismo di protezione della Nessun meccanismo di protezione della
memoriamemoria Diverse combinazioni segment:offset Diverse combinazioni segment:offset
indirizzano la stessa locazione di memoria indirizzano la stessa locazione di memoria fisicafisica
Nessun supporto hardware nativo per una Nessun supporto hardware nativo per una efficacie implementazione del multitaskingefficacie implementazione del multitasking
Microsoft ha inventato una Microsoft ha inventato una implementazione software del multitasking implementazione software del multitasking per Windows 1.xper Windows 1.x
Protected-mode (32 bit)Protected-mode (32 bit)selector offset:
15 0 31 0
RPLTI
12
?1
0
GDT
LDTBABA+SS
SEGMENT
RAM0
16GB/64TB
TI = Table IndexRPL = Requestor Privilege LevelGDT = Global Descriptors Table (64KB)LDT = Local Descriptors Table (64KB)BASE = BA = Base Address (32 bit)LIMIT = Limit (20 bit) = 1 MBACC. = ACCESS = Access Byte (12 bit)SS = Segment Size
DPL TYPESPAVL
0DG Struttura Interna Access Byte
G = 0 SS = Limit x 1 Byte = 1 MBG = 1 SS = Limit x 1 Page = Limit x 4KB = 4GB(G = Granularity Bit)
15 0
x 819263 48
BASEACC.
LIMIT
BASE LIMITACCESS
BASE
15 0
x 819263 48
BASEACC.
LIMIT
BASE LIMITACCESS
BASE
Protected-mode (32 bit)Protected-mode (32 bit)
Se la granularità è una pagina (4KB), Se la granularità è una pagina (4KB), ciascun segmento è da 4GB e lo spazio ciascun segmento è da 4GB e lo spazio di indirizzamento virtuale è di 64TB!di indirizzamento virtuale è di 64TB!
Il descriptor è comunque compatibile Il descriptor è comunque compatibile con 16 bit PMcon 16 bit PM
L’architettura è comunque L’architettura è comunque segmentata e limita la portabilitàsegmentata e limita la portabilità Tipicamente le piattaforme RISC non Tipicamente le piattaforme RISC non
hanno architettura segmentata…hanno architettura segmentata…
Eliminare la Eliminare la SegmentazioneSegmentazione
In Win95 e WinNT, il sistema operativo In Win95 e WinNT, il sistema operativo utilizza utilizza un solo segmento da 4GBun solo segmento da 4GB In pratica, l’indirizzamento in Win32 è basato In pratica, l’indirizzamento in Win32 è basato
esclusivamente sull’offset (32 bit)esclusivamente sull’offset (32 bit) L’indirizzamento L’indirizzamento appareappare lineare (o flat) lineare (o flat) Questo assicura la portabilità ad architetture Questo assicura la portabilità ad architetture
non segmentate (es. RISC)non segmentate (es. RISC) Win32 indirizza fino a 4GB RAM fisicaWin32 indirizza fino a 4GB RAM fisica
Tuttavia la strategia di implementazione è Tuttavia la strategia di implementazione è basata sulle Paginebasata sulle Pagine La quantità minima di memoria allocabile è la La quantità minima di memoria allocabile è la
pagina = 4KBpagina = 4KB
Perchè Paginare la Perchè Paginare la MemoriaMemoria
Se l’offset fosse usato come un riferimento Se l’offset fosse usato come un riferimento diretto alla locazione di memoria, lo spazio di diretto alla locazione di memoria, lo spazio di indirizzamento virtuale coinciderebbe con la indirizzamento virtuale coinciderebbe con la RAM fisica installataRAM fisica installata Per indirizzare 4GB virtuali, sarebbe necessario Per indirizzare 4GB virtuali, sarebbe necessario
disporre di 4GB di RAM fisica in ogni sistema!disporre di 4GB di RAM fisica in ogni sistema! La paginazione consente di simulare uno spazio La paginazione consente di simulare uno spazio
di indirizzamento fisico da 4GB anche se la RAM di indirizzamento fisico da 4GB anche se la RAM fisica installata è <4GBfisica installata è <4GB Remapping della memoria fisica sulla memoria virtualeRemapping della memoria fisica sulla memoria virtuale Paginazione su discoPaginazione su disco Exceptions generate dal processore e gestite dal Exceptions generate dal processore e gestite dal
sistema operativosistema operativo
Win32ProcessContext
32 bit Offset in Win3232 bit Offset in Win32OFFSET (12 bit)
0
PDE (10 bit) PTE (10 bit)12212231 11
20 bits 12 bits 20 bits 12 bits
PAGE 4KB
RAM0
4GB
CR#3
PDE = Page Directory EntryPTE = Page Table EntryCR#3 = Control Register #3
i386
Page Directory Page Table
1023
0
1023
0
Spazio di indirizzamentoSpazio di indirizzamentoSystem
Memory(2 GB)
Per-ProcessMemory
(2 GB)
Paged
Non-paged
Paged
PhysicalAddressing Range
Memoria virtualeMemoria virtuale
Page Tables
Physical Memory
0
Invalid
ProcessAddress Space
2 GB
Committed
Pages
Committed
Pages
Reserved
Invalid
Page Directory, Page Page Directory, Page Table,Table,
Page FramePage Frame
4 MB
8 MB
12 MB
2 GBDirectory1024 Entries
Table1024 Entries
Paging File
Byte WithinPage
10 Bits10 Bits 10 Bits10 Bits 12 Bits12 Bits
Directory Index Table Index
0
ValidPaged
Invalid
VirtualAddressSpace
4K
4K
4K
Frame
PhysicalMemory
Invalid
Paging FilePaging File
Contiene Pagine scambiate dalla Contiene Pagine scambiate dalla Memoria RAM al DiscoMemoria RAM al Disco
Dimensione pagina: 4K o 8KDimensione pagina: 4K o 8K Paging PolicyPaging Policy
Page CommitmentPage CommitmentProcess
Address Space2 GB
Committed
Pages
Committed
Pages
Reserved
Copy-on-Write e Guard Copy-on-Write e Guard PagesPages
Page 1
Page 2
Page 1
Page 2 Copy
Page 1
Page 2
CommittedMemory
Process 2Virtual
Memory
Process 1Virtual
Memory
(Read-Write)Page 2 Copy
Section
Funzioni API: Funzioni API: VirtualAllocVirtualAlloc
Manipolazione pagine virtuali o spazi di Manipolazione pagine virtuali o spazi di indirizzamentoindirizzamento
Lettura stato pagine virtuali o spazi di indirizzamentoLettura stato pagine virtuali o spazi di indirizzamento LPVOID VirtualAlloc(LPVOID VirtualAlloc(lpvAddresslpvAddress,, cbSizecbSize, ,
fdwAllocationTypefdwAllocationType,, fdwProtectfdwProtect)) BOOL VirtualFree(BOOL VirtualFree(lpAddresslpAddress,, cbSizecbSize,, fdwFreeTypefdwFreeType)) BOOL VirtualProtect(BOOL VirtualProtect(lpvAddresslpvAddress,, cbSizecbSize, ,
fdwNewProtectfdwNewProtect, , pfdwOldProtectpfdwOldProtect)) DWORD VirtualQuery(DWORD VirtualQuery(lpAddresslpAddress,,
pmbiBufferpmbiBuffer,,cbLengthcbLength)) BOOL VirtualLock(BOOL VirtualLock(lpvAddresslpvAddress,, cbSizecbSize)) BOOL VirtualUnlock(BOOL VirtualUnlock(lpvAddresslpvAddress,, cbSizecbSize))
Esempio: Uso di Funzioni Esempio: Uso di Funzioni VirtualXXXVirtualXXX
......lpBase = VirtualAlloc (NULL, my_size,lpBase = VirtualAlloc (NULL, my_size, MEM_RESERVE,MEM_RESERVE,
PAGE_NOACCESS);PAGE_NOACCESS); ...... __try{__try{ // an EXCEPTION_ACCESS_VIOLATION here// an EXCEPTION_ACCESS_VIOLATION here // will be fixed by MyFilter if possible// will be fixed by MyFilter if possible }} __except (MyFilter (GetExceptionInformation()))__except (MyFilter (GetExceptionInformation())) {{ }} ......VirtualFree (lpBase, 0, MEM_RELEASE);VirtualFree (lpBase, 0, MEM_RELEASE); ......
......lpBase = VirtualAlloc (NULL, my_size,lpBase = VirtualAlloc (NULL, my_size, MEM_RESERVE,MEM_RESERVE,
PAGE_NOACCESS);PAGE_NOACCESS); ...... __try{__try{ // an EXCEPTION_ACCESS_VIOLATION here// an EXCEPTION_ACCESS_VIOLATION here // will be fixed by MyFilter if possible// will be fixed by MyFilter if possible }} __except (MyFilter (GetExceptionInformation()))__except (MyFilter (GetExceptionInformation())) {{ }} ......VirtualFree (lpBase, 0, MEM_RELEASE);VirtualFree (lpBase, 0, MEM_RELEASE); ......
Gestione HeapGestione Heap
Lo Heap è ottimizzato per allocare Lo Heap è ottimizzato per allocare blocchi di memoria più piccoli senza blocchi di memoria più piccoli senza l’overhead di pagina (4k o 8k)l’overhead di pagina (4k o 8k)
Ogni processo ha uno Heap di defaultOgni processo ha uno Heap di default E’ possibile allocare Heap privatiE’ possibile allocare Heap privati La memoria allocata in uno heap può La memoria allocata in uno heap può
portare a fenomeni di frammentazioneportare a fenomeni di frammentazione Sono Thread-Safe per defaultSono Thread-Safe per default
Funzioni API: HeapAllocFunzioni API: HeapAlloc Allocazione di un Heap privatoAllocazione di un Heap privato HANDLE HeapCreate(HANDLE HeapCreate(flOptionsflOptions,,
dwInitialSizedwInitialSize,, dwMaximumSizedwMaximumSize)) BOOL HeapDestroy(BOOL HeapDestroy(hHeaphHeap)) LPVOID HeapAlloc(LPVOID HeapAlloc(hHeaphHeap,, dwFlagsdwFlags,,
dwBytesdwBytes)) BOOL HeapFree(BOOL HeapFree(hHeaphHeap,, dwFlagsdwFlags,, lpMemlpMem)) DWORD HeapSize(DWORD HeapSize(hHeaphHeap,, dwFlagsdwFlags,,
lpMemlpMem)) LPVOID HeapReAlloc(LPVOID HeapReAlloc(hHeaphHeap,, dwFlagsdwFlags,,
lpMemlpMem,, dwBytesdwBytes)) Sono Thread-Safe per defaultSono Thread-Safe per default
Funzioni API: Funzioni API: LocalAlloc/GlobalAllocLocalAlloc/GlobalAlloc
Tutti i puntatori sono valori a 32 bitTutti i puntatori sono valori a 32 bit LocalAlloc e GlobalAlloc allocano LocalAlloc e GlobalAlloc allocano
memoria dallo stesso Heapmemoria dallo stesso Heap GlobalAlloc garantisce allocazioni con GlobalAlloc garantisce allocazioni con
allineamento a 16 bitallineamento a 16 bit HGLOBAL GlobalAlloc(HGLOBAL GlobalAlloc(fuFlagsfuFlags,, cbBytescbBytes)) HLOCAL LocalAlloc(HLOCAL LocalAlloc(fuFlagsfuFlags,, cbBytescbBytes)) Presenti solo per ragioni di compatibilità: Presenti solo per ragioni di compatibilità:
richiamano HeapAllocrichiamano HeapAlloc
Funzioni API: C Run-Funzioni API: C Run-Time LibraryTime Library
Le funzioni delle Standard C Run-Le funzioni delle Standard C Run-Time Libraries possono essere usate Time Libraries possono essere usate (malloc, calloc, free, realloc, ...)(malloc, calloc, free, realloc, ...)
Bilanciare chiamate malloc() con Bilanciare chiamate malloc() con free(), senza mischiare con free(), senza mischiare con GlobalFree(), HeapFree() o altroGlobalFree(), HeapFree() o altro
Memory-Mapped FileMemory-Mapped File
I Memory-Mapped Files consentono I Memory-Mapped Files consentono di condividere la memoria tra di condividere la memoria tra processi diversiprocessi diversi
Sono l’equivalente Win32 Sono l’equivalente Win32 dell’oggetto kernel Sectiondell’oggetto kernel Section
Viste di Memory-Mapped Viste di Memory-Mapped FileFile
PG.SYS
File
Physical Memory
ViewsSections
FileMapping: le cose FileMapping: le cose ovvieovvie
Il file è mappato in memoria come se Il file è mappato in memoria come se fosse effettivamente caricatofosse effettivamente caricato
Gli indirizzi di memoria necessari ad Gli indirizzi di memoria necessari ad effettuare il mapping devono essere effettuare il mapping devono essere riservatiriservati
Solo le pagine effettivamente utilizzate (a Solo le pagine effettivamente utilizzate (a cui si accede in lettura o in scrittura cui si accede in lettura o in scrittura attraverso puntatori di memoria) vengono attraverso puntatori di memoria) vengono effettivamente lette/scritte su discoeffettivamente lette/scritte su disco
Il Paging File usato come Memory Il Paging File usato come Memory Mapped File non rende persistenti le Mapped File non rende persistenti le operazioni effettuate in memoriaoperazioni effettuate in memoria
File Mapping: le cose File Mapping: le cose meno ovviemeno ovvie
TutteTutte le operazioni di I/O su file avvengono le operazioni di I/O su file avvengono come operazioni di file-mappingcome operazioni di file-mapping
La cache dell’I/O Manager è integrata con La cache dell’I/O Manager è integrata con il Memory Manageril Memory Manager
Tutte le volte che si apre un eseguibile Tutte le volte che si apre un eseguibile (.EXE, .DLL, .OCX), il codice e le risorse (.EXE, .DLL, .OCX), il codice e le risorse non vengono caricate in memoria fino a non vengono caricate in memoria fino a che non sono realmente utilizzate (anche che non sono realmente utilizzate (anche queste sono operazioni di file-mapping)queste sono operazioni di file-mapping)
Caricando più volte la stesso file EXE/DLL Caricando più volte la stesso file EXE/DLL da processi diversi, la memoria fisica da processi diversi, la memoria fisica impegnata è sempre la stessaimpegnata è sempre la stessa
CreateFileMapping e CreateFileMapping e OpenFileMappingOpenFileMapping
Crea un oggetto SectionCrea un oggetto Section HANDLE CreateFileMapping(HANDLE CreateFileMapping(hFilehFile,, lpsa lpsa,,
fdwProtectfdwProtect,, dwMaximumSizeHigh dwMaximumSizeHigh,, dwMaximumSizeLowdwMaximumSizeLow, , lpszMapNamelpszMapName))
Apre un oggetto SectionApre un oggetto Section HANDLE HANDLE
OpenFileMapping(OpenFileMapping(dwDesiredAccessdwDesiredAccess, , bInheritHandlebInheritHandle,, lpszMapName lpszMapName))
Assegnando a Assegnando a hFilehFile il valore –1 si usa il il valore –1 si usa il PagingFilePagingFile
MapViewOfFile e MapViewOfFile e UnmapViewOfFileUnmapViewOfFile
LPVOID MapViewOfFile(LPVOID MapViewOfFile(hMapObjecthMapObject,, fdwAccessfdwAccess,, dwOffsetHighdwOffsetHigh,, dwOffsetLowdwOffsetLow,, cbMapcbMap))
BOOL UnmapViewOfFile(BOOL UnmapViewOfFile(lpBaseAddresslpBaseAddress)) BOOL FlushViewOfFile(BOOL FlushViewOfFile(lpvBaselpvBase, , cbFlushcbFlush)) UnmapViewOfFile scrive tutti i cambiamenti UnmapViewOfFile scrive tutti i cambiamenti
su discosu disco Lazy Writes su disco delle scritture in Lazy Writes su disco delle scritture in
memoriamemoria E’ garantita la coerenza di viste differenti di E’ garantita la coerenza di viste differenti di
un singolo oggetto Sectionun singolo oggetto Section
Usare Memory-Mapped Usare Memory-Mapped File come Shared File come Shared
MemoryMemory
Process 2Virtual
Memory
Process 1Virtual
Memory CommittedMemory
Section
View
View
Gestione della memoriaGestione della memoria Superare il muro dei 4Gb con Win32Superare il muro dei 4Gb con Win32 Solo per i dati, non per il codiceSolo per i dati, non per il codice VLM – Very Large MemoryVLM – Very Large Memory
Solo su Windows 2000 Advanced ServerSolo su Windows 2000 Advanced Server Solo per processori a 64 bit, ad oggi solo Solo per processori a 64 bit, ad oggi solo
Alpha, che non supporta più Windows 2000Alpha, che non supporta più Windows 2000 AWE – Address Windowing ExtensionAWE – Address Windowing Extension
Su tutte le versioni di Windows 2000Su tutte le versioni di Windows 2000 Per tutti i processori a 32 e 64 bit (Win64)Per tutti i processori a 32 e 64 bit (Win64) Meno comodo da usare...Meno comodo da usare...
AWE – Address AWE – Address Windowing ExtensionWindowing Extension
Per tutti i processori e per tutte le Per tutti i processori e per tutte le versioni di Windows 2000versioni di Windows 2000
Memoria mappata nello spazio virtuale Memoria mappata nello spazio virtuale disponibile al processo (2Gb/3Gb)disponibile al processo (2Gb/3Gb)
Non funziona con funzioni grafiche/videoNon funziona con funzioni grafiche/video Granularità 4K/8KGranularità 4K/8K Il processo deve essere abilitato (diritto Il processo deve essere abilitato (diritto
Lock Pages in Memory)Lock Pages in Memory) Una zona allocata con AWE non può Una zona allocata con AWE non può
essere condivisa con altri processiessere condivisa con altri processi
AWE – FunzioniAWE – Funzioni
AllocateUserPhysicalPagesAllocateUserPhysicalPages VirtualAllocVirtualAlloc MapUserPhysicalPagesMapUserPhysicalPages FreeUserPhysicalPagesFreeUserPhysicalPages
Gestione della memoriaGestione della memoria
Introduzione architetturaleIntroduzione architetturale Funzioni APIFunzioni API Memory mapped fileMemory mapped file Condivisione della memoriaCondivisione della memoria VLM & AWEVLM & AWE
ProcessiProcessi
Cosa è un Processo?Cosa è un Processo?
Un istanza di un programma in esecuzioneUn istanza di un programma in esecuzione Un processo possiede degli OggettiUn processo possiede degli Oggetti
Gli oggetti sono rappresentati dagli HandleGli oggetti sono rappresentati dagli Handle Cosa distingue un processo da un altro?Cosa distingue un processo da un altro?
Handle tableHandle table Memoria privataMemoria privata WindowsWindows
Il processo è un insieme di thread, ed esiste Il processo è un insieme di thread, ed esiste fino a che contiene almeno un threadfino a che contiene almeno un thread
Win32-Based Process Win32-Based Process ModelModel
ProcessProcess . . .
AccessToken
AccessToken
Virtual Address Space Description
Object Table
Thread xThread x
File yFile y
Section zSection z
Available Objects
Handle 1
Handle 2
Handle 3
Object HandleObject Handle Ogni Object HandleOgni Object Handle
E’ valido solo nel contesto del proprio processoE’ valido solo nel contesto del proprio processo Può essere ereditatoPuò essere ereditato Mantiene un oggetto in vita nel sistema fino a che Mantiene un oggetto in vita nel sistema fino a che
tutti gli handle allo stesso oggetto non sono chiusitutti gli handle allo stesso oggetto non sono chiusi
Tipi di Object HandleTipi di Object Handle Private: Private: CreateMutex,CreateMutex, OpenSemaphore, ...OpenSemaphore, ... Duplicated: Duplicated: BOOL DuplicateHandle(BOOL DuplicateHandle(......)) Inherited: Inherited: fInheritHandlesfInheritHandles a TRUE in a TRUE in
CreateProcessCreateProcess Pseudo: Pseudo: GetCurrentProcess(), GetCurrentProcess(),
GetCurrentThread(), ...GetCurrentThread(), ...
Ciclo di vita di un Ciclo di vita di un ProcessoProcesso
Un processo viene creato associando Un processo viene creato associando sempre un file eseguibile (.EXE), che è sempre un file eseguibile (.EXE), che è mappato in memoria ed eseguitomappato in memoria ed eseguito
Creando un processo viene creato un Creando un processo viene creato un threadthread
Il primo thread di un processo può essere Il primo thread di un processo può essere chiamato thread principale, anche se la sua chiamato thread principale, anche se la sua chiusura non determina necessariamente chiusura non determina necessariamente la fine del processola fine del processo
La run-time library del C termina il La run-time library del C termina il processo corrente se si esce dalla funzione processo corrente se si esce dalla funzione main() con return, indipendentemente main() con return, indipendentemente dalla presenza di altri threaddalla presenza di altri thread
Creazione di un ProcessoCreazione di un Processo
BOOL CreateProcess(BOOL CreateProcess(lpszImageNamelpszImageName,, lpszCommandLinelpszCommandLine,, lpsaProcess lpsaProcess,, lpsaThread lpsaThread,, fInheritHandlesfInheritHandles,, fdwCreate fdwCreate,, lpvEnvironment lpvEnvironment,, lpszCurDirlpszCurDir,, lpsiStartInfo lpsiStartInfo,, lppiProcInfo lppiProcInfo))
HANDLE OpenProcess(HANDLE OpenProcess(fdwAccessfdwAccess,, fInheritfInherit,, IDProcessIDProcess))
Informazioni ritornate Informazioni ritornate dalla creazione di un dalla creazione di un
ProcessoProcessotypedef struct _PROCESS_INFORMATION {typedef struct _PROCESS_INFORMATION {
HANDLE hProcess;HANDLE hProcess;
HANDLE hThread;HANDLE hThread;
DWORD dwProcessId;DWORD dwProcessId;
DWORD dwThreadId;DWORD dwThreadId;
} PROCESS_INFORMATION;} PROCESS_INFORMATION;
typedef struct _PROCESS_INFORMATION {typedef struct _PROCESS_INFORMATION {
HANDLE hProcess;HANDLE hProcess;
HANDLE hThread;HANDLE hThread;
DWORD dwProcessId;DWORD dwProcessId;
DWORD dwThreadId;DWORD dwThreadId;
} PROCESS_INFORMATION;} PROCESS_INFORMATION;
Gli handle hProcess e hThread vanno sempre chiusi con CloseHandle(hObject) quando non sono più utilizzati
E’ un errore frequente dimenticare questa operazione su entrambi gli handle restituiti!
Chiudere un ProcessoChiudere un Processo
Chiusura normaleChiusura normale VOID ExitProcess(VOID ExitProcess(uExitCodeuExitCode))
Chiudere l’handle ad un processoChiudere l’handle ad un processo BOOL CloseHandle(BOOL CloseHandle(hObjecthObject))
Chiusura immediata (e anomala) di un Chiusura immediata (e anomala) di un processoprocesso BOOL TerminateProcess(BOOL TerminateProcess(hProcesshProcess,, uExitCode uExitCode))
La chiusura dell’ultimo thread di un La chiusura dell’ultimo thread di un processo implica una chiamata ad processo implica una chiamata ad ExitProcess()ExitProcess()
Funzioni APIFunzioni API
LPTSTR GetCommandLine(VOID)LPTSTR GetCommandLine(VOID) HANDLE GetCurrentProcess(VOID)HANDLE GetCurrentProcess(VOID) DWORD GetCurrentProcessId(VOID)DWORD GetCurrentProcessId(VOID) VOID GetStartupInfo(VOID GetStartupInfo(lpsilpsi)) HANDLE OpenProcess(HANDLE OpenProcess(fdwAccessfdwAccess,, fInheritfInherit,,
IDProcessIDProcess)) DWORD GetEnvironmentVariable(DWORD GetEnvironmentVariable(lpszNamelpszName,,
lpszValuelpszValue, , cchValuecchValue)) BOOL SetEnvironmentVariable(BOOL SetEnvironmentVariable(lpszNamelpszName, ,
lpszValuelpszValue)) LPVOID GetEnvironmentStrings(VOID)LPVOID GetEnvironmentStrings(VOID)
Interprocess Interprocess Communication (IPC)Communication (IPC)
IPC viene realizzata quando due o più IPC viene realizzata quando due o più processi condividono un oggettoprocessi condividono un oggetto
Gli oggetti usati per IPC includono:Gli oggetti usati per IPC includono:Shared memory (section object) Shared memory (section object) FilesFilesSemaphoresSemaphoresPipes / MailslotPipes / MailslotWindows socketsWindows sockets
I metodi di accesso condiviso sono gli stessi I metodi di accesso condiviso sono gli stessi per molti oggetti di tipo diversoper molti oggetti di tipo diverso
Condivisione di oggettiCondivisione di oggetti
Può avvenire in tre modi:Può avvenire in tre modi: BOOL BOOL
DuplicateHandle(DuplicateHandle(hSourceProcesshSourceProcess,, hSourcehSource,,
hTargetProcesshTargetProcess,, lphTargetlphTarget,, fdwAccessfdwAccess,, fInheritfInherit,,
fdwOptionsfdwOptions)) Creando o aprendo un “Named Object”Creando o aprendo un “Named Object” EreditarietàEreditarietà
Condivisione di oggettiCondivisione di oggetti
Gli oggetti condivisi sono handle diversi Gli oggetti condivisi sono handle diversi che puntano allo stesso oggetto kernelche puntano allo stesso oggetto kernel
Thread xThread x
Process A
Object Table
Thread yThread y
File kFile k
Section zSection z
Kernel Objects
Handle 1
Handle 2
Handle 3
Process B
Object Table
Handle 1
Handle 2
Handle 3
File wFile w
EreditarietàEreditarietà
Process AProcess A
AccessToken
AccessToken
Thread xThread x
File yFile y
Section zSection z
Available Objects
Handle 1
Handle 2
Handle 3
Object Table
Granted Access
Inheritance
Process B
Object Table
Handle 1
Handle 2
Handle 3
Thread xThread x
EreditarietàEreditarietà Gli oggetti condivisi attraverso ereditarietà Gli oggetti condivisi attraverso ereditarietà
assumono lo stesso valore di Handleassumono lo stesso valore di Handle
Process A
Object Table
Thread yThread y
File kFile k
Section zSection z
Kernel Objects
Handle 1
Handle 2
Handle 3
CreateProcess(…)
Controllare l’ereditarietàControllare l’ereditarietàtypedef struct _SECURITY_ATTRIBUTES {typedef struct _SECURITY_ATTRIBUTES {
DWORD nLength;DWORD nLength;
LPVOID lpSecurityDescriptor;LPVOID lpSecurityDescriptor;
BOOL bInheritHandle;BOOL bInheritHandle;
} SECURITY_ATTRIBUTES;} SECURITY_ATTRIBUTES;
BOOL bInheritHandle;BOOL bInheritHandle;
ProcessiProcessi
AchitetturaAchitettura Object HandleObject Handle Ciclo di vita di un processoCiclo di vita di un processo Condivisione di oggettiCondivisione di oggetti EreditarietàEreditarietà
ThreadThread
Cosa è un Thread?Cosa è un Thread? Un thread è un percorso di esecuzione Un thread è un percorso di esecuzione
all’interno di un processoall’interno di un processo Un thread accede a tutte le risorse del Un thread accede a tutte le risorse del
processo in cui è contenutoprocesso in cui è contenuto Il ThreadID contraddistingue un Il ThreadID contraddistingue un
thread nel sistema operativo, thread nel sistema operativo, indipendentemente dal processo indipendentemente dal processo ospitanteospitante
Un thread esiste fino a che:Un thread esiste fino a che: il percorso di esecuzione terminail percorso di esecuzione termina viene chiuso con ExitThreadviene chiuso con ExitThread viene chiuso/distrutto il processo ospitanteviene chiuso/distrutto il processo ospitante
Preemptive vs. Preemptive vs. CooperativeCooperative
Thread 2
Preemptive (Windows NT)
Thread 1
Processor Done
Task 2
Cooperative (Windows 3.1)
Task 1
Processor
Time
I/O or IdleExecuting
I/O or IdleExecuting
InvoluntaryVoluntary
InvoluntaryVoluntary
Win32 Preemptive Win32 Preemptive MultitaskingMultitasking
Thread 1 Thread 2
Process A
Thread 1
Process B
Thread 1
Process C
Thread 1 Thread 2
Process D
Thread 3 Thread 1
Process E
SystemScheduler i386
Perché usare thread Perché usare thread multipli?multipli?
I thread sono più economici dei I thread sono più economici dei processiprocessi
Per dividere task paralleliPer dividere task paralleli Per supportare la concorrenzaPer supportare la concorrenza Perché i thread comunicano più Perché i thread comunicano più
velocementevelocemente Per sfruttare Symmetric Per sfruttare Symmetric
MultiprocessingMultiprocessing
Thread OverheadThread Overhead
Ogni thread Win32 ha un “gemello” Ogni thread Win32 ha un “gemello” nel sottosistema Hostnel sottosistema Host
Ci sono due stack per ogni threadCi sono due stack per ogni thread C’è un Hardware Context per threadC’è un Hardware Context per thread C’è un insieme di variabili statiche C’è un insieme di variabili statiche
delle C Run-Time Library per threaddelle C Run-Time Library per thread
Schedulazione dei Schedulazione dei ThreadThread
Lo Scheduler Win32 : Lo Scheduler Win32 : Schedula soltanto threadSchedula soltanto thread E’ preemptiveE’ preemptive E’ basato sulle prioritàE’ basato sulle priorità
SchedulerScheduler Lo scheduler conosce solo i ThreadLo scheduler conosce solo i Thread Ogni Thread ha due livelli di prioritàOgni Thread ha due livelli di priorità
Priorità di basePriorità di base Priorità correntePriorità corrente
La priorità corrente è analizzata per decidere quale La priorità corrente è analizzata per decidere quale thread eseguirethread eseguire
SchedulerScheduler La priorità di base è funzione di due valori:La priorità di base è funzione di due valori:
Classe di priorità del processoClasse di priorità del processo Valore di priorità del threadValore di priorità del thread
La priorità corrente è dinamica (viene variata dallo La priorità corrente è dinamica (viene variata dallo scheduler), ma non scende mai al di sotto della scheduler), ma non scende mai al di sotto della priorità di basepriorità di base
Priorità di processi e Priorità di processi e threadthread
ProcessiProcessi
IDLEIDLE
BELOW_NORMBELOW_NORMALAL
NORMALNORMAL
ABOVE_NORMABOVE_NORMALAL
HIGHHIGH
REALTIMEREALTIME
ThreadThread
IDLEIDLE
LOWESTLOWEST
BELOW_NORMBELOW_NORMALAL
NORMALNORMAL
ABOVE_NORMABOVE_NORMALAL
HIGHESTHIGHEST
TIME_CRITICATIME_CRITICALL
Calcolo priorità di base Calcolo priorità di base dei threaddei thread
System IdleDynamic Idle
DynamicLivelli 1-15
RealtimeLivelli 16-31
Realtime Idle
Realtime Time Critical
Dynamic Time Critical
31
16
15
0
24
13
10
8
6
4
Realtime
High
Above Normal
Normal
Below Normal
Idle
SchedulerScheduler
Logica di funzionamento dello schedulerLogica di funzionamento dello scheduler Trova il thread attivo con priorità corrente più Trova il thread attivo con priorità corrente più
alta e lo esegue per un quantumalta e lo esegue per un quantum Solo il thread non sospeso con la priorità più Solo il thread non sospeso con la priorità più
alta viene eseguitoalta viene eseguito Se ci sono più thread con lo stesso livello, Se ci sono più thread con lo stesso livello,
effettua un round-robin tra questieffettua un round-robin tra questi L’unico modo per eseguire thread a priorità più L’unico modo per eseguire thread a priorità più
bassa è che i thread a priorità più alta vadano in bassa è che i thread a priorità più alta vadano in stato di Wait (ad es. per operazioni di I/O)stato di Wait (ad es. per operazioni di I/O)
SchedulerScheduler
Impatto dello scheduler sui tempi di rispostaImpatto dello scheduler sui tempi di risposta Appena un thread a priorità più alta non è più Appena un thread a priorità più alta non è più
sospeso, lo scheduler interrompe il thread in sospeso, lo scheduler interrompe il thread in esecuzione e passa il controllo al thread con la esecuzione e passa il controllo al thread con la priorità più altapriorità più alta
La priorità di un thread non agisce quindi La priorità di un thread non agisce quindi direttamente sulla percentuale di tempo di CPU direttamente sulla percentuale di tempo di CPU assegnataassegnata
Priorità di processi e Priorità di processi e threadthread
1 5 10 20 25 31
Idle Class
Normal Class
High Class
Real-Time Class
Variable Real-Time
1615
SchedulerScheduler
Come fa Windows a funzionare?Come fa Windows a funzionare? Il trucco è che la priorità corrente del thread Il trucco è che la priorità corrente del thread
è modificata continuamente dallo scheduler:è modificata continuamente dallo scheduler: I thread in attesa vengono premiatiI thread in attesa vengono premiati I thread che usano più CPU sono penalizzatiI thread che usano più CPU sono penalizzati L’applicazione in primo piano riceve un quantum L’applicazione in primo piano riceve un quantum
più lungopiù lungo
SchedulerScheduler Andamento del livello di priorità corrente Andamento del livello di priorità corrente
nel temponel tempo
Priorità
Tempo
Base
Round-Robinat Base
QuantumDecay
PriorityBoost
WaitRun PreemptRun Run
SchedulerScheduler
Non voglio che lo scheduler cambi il Non voglio che lo scheduler cambi il livello di priorità corrente di un thread. livello di priorità corrente di un thread. Come faccio?Come faccio?
Il livello di priorità corrente non scende Il livello di priorità corrente non scende mai al di sotto della priorità base.mai al di sotto della priorità base.
Un thread con priorità TIME_CRITICAL Un thread con priorità TIME_CRITICAL ha sempre il valore di priorità corrente 15ha sempre il valore di priorità corrente 15
Tutti i valori superiori a 15 non sono mai Tutti i valori superiori a 15 non sono mai modificati dinamicamente (processi in modificati dinamicamente (processi in classe di priorità REALTIME)classe di priorità REALTIME)
SchedulerScheduler
1 5 10 20 25 31
Real-Time Class
Priorità dinamiche Priorità statiche
1615
Idle Class
Normal Class
High Class
Non sono solo driver
Above Normal
Below Normal
Controllare le prioritàControllare le priorità
Un’applicazione può controllare la Un’applicazione può controllare la priorità dei suoi thread:priorità dei suoi thread: CreateProcessCreateProcess parametro parametro fdwCreatefdwCreate BOOLBOOL SetPriorityClass(SetPriorityClass(hProcesshProcess,,
fdwPriorityfdwPriority)) BOOLBOOL SetThreadPriority(SetThreadPriority(hThreadhThread,,
nPrioritynPriority))
Creazione di un ThreadCreazione di un Thread
La funzione Win32 per creare un thread è La funzione Win32 per creare un thread è CreateThreadCreateThread
Ogni libreria o ambiente di sviluppo ha Ogni libreria o ambiente di sviluppo ha delle funzioni specifiche per creare un delle funzioni specifiche per creare un thread:thread: C/C++ RTLC/C++ RTL _beginthread(...)_beginthread(...) MFCMFC AfxBeginThread(...)AfxBeginThread(...)
Se si usano le C-Run Time Libraries, Se si usano le C-Run Time Libraries, specificare la versione multi-thread delle specificare la versione multi-thread delle librerie nelle opzioni del progettolibrerie nelle opzioni del progetto
C Run-Time LibraryC Run-Time Library
Funzioni di creazione dei Funzioni di creazione dei ThreadThread Win32 APIWin32 API
HANDLE CreateThread(HANDLE CreateThread(lpsalpsa,, cbStackcbStack,,lpStartAddrlpStartAddr,, lpvThreadParmlpvThreadParm,, fdwCreatefdwCreate,, lpIDThreadlpIDThread))
C Run-Time APIC Run-Time APIunsigned long _beginthread(unsigned long _beginthread(
void (void (*start_address*start_address) (void *),) (void *),unsignedunsigned stack_sizestack_size,,voidvoid *arglist*arglist))
Esempio CreateThreadEsempio CreateThread
DWORD WINAPI CalculationThreadProc (LPVOID lpv)DWORD WINAPI CalculationThreadProc (LPVOID lpv){{printf(“CalculationThreadProc: Param=%d\n”, *((lpint)lpv);printf(“CalculationThreadProc: Param=%d\n”, *((lpint)lpv);return 0;return 0;}}
DWORD main (void)DWORD main (void){{DWORD dwThreadId, dwThrdParam = 1;DWORD dwThreadId, dwThrdParam = 1;HANDLE hThread;HANDLE hThread;hThread = CreateThread (NULL,hThread = CreateThread (NULL, //no security attributes//no security attributes
0,0, //default stack size//default stack sizeCalculationThreadProc,CalculationThreadProc, //thread function//thread function&dwThrdParam,&dwThrdParam, //thread function argument//thread function argument0,0, //default creation flags//default creation flags&dwThreadId);&dwThreadId); //returns thread ID//returns thread ID
if (hThread == INVALID_HANDLE_VALUE)if (hThread == INVALID_HANDLE_VALUE)return 1;return 1;
......}}
DWORD WINAPI CalculationThreadProc (LPVOID lpv)DWORD WINAPI CalculationThreadProc (LPVOID lpv){{printf(“CalculationThreadProc: Param=%d\n”, *((lpint)lpv);printf(“CalculationThreadProc: Param=%d\n”, *((lpint)lpv);return 0;return 0;}}
DWORD main (void)DWORD main (void){{DWORD dwThreadId, dwThrdParam = 1;DWORD dwThreadId, dwThrdParam = 1;HANDLE hThread;HANDLE hThread;hThread = CreateThread (NULL,hThread = CreateThread (NULL, //no security attributes//no security attributes
0,0, //default stack size//default stack sizeCalculationThreadProc,CalculationThreadProc, //thread function//thread function&dwThrdParam,&dwThrdParam, //thread function argument//thread function argument0,0, //default creation flags//default creation flags&dwThreadId);&dwThreadId); //returns thread ID//returns thread ID
if (hThread == INVALID_HANDLE_VALUE)if (hThread == INVALID_HANDLE_VALUE)return 1;return 1;
......}}
Esempio Esempio CalculationThreadProcCalculationThreadProc
typedef struct _threadargs typedef struct _threadargs {{
......} THREADARGS, * LPTHREADARGS;} THREADARGS, * LPTHREADARGS;
DWORD WINAPI CalculationThreadProc (DWORD WINAPI CalculationThreadProc (LPVOID lpv)LPVOID lpv)
{{LPTHREADARGS lpta = lpv;LPTHREADARGS lpta = lpv;BOOLBOOL bRet;bRet;/*Do Calculation*//*Do Calculation*/return bRet;return bRet;
}}
typedef struct _threadargs typedef struct _threadargs {{
......} THREADARGS, * LPTHREADARGS;} THREADARGS, * LPTHREADARGS;
DWORD WINAPI CalculationThreadProc (DWORD WINAPI CalculationThreadProc (LPVOID lpv)LPVOID lpv)
{{LPTHREADARGS lpta = lpv;LPTHREADARGS lpta = lpv;BOOLBOOL bRet;bRet;/*Do Calculation*//*Do Calculation*/return bRet;return bRet;
}}
Thread IDs e HandlesThread IDs e Handles DWORD GetCurrentThreadId(VOID)DWORD GetCurrentThreadId(VOID)
DWORD GetCurrentProcessId(VOID)DWORD GetCurrentProcessId(VOID) HANDLE CreateThread(HANDLE CreateThread(lpsalpsa,, cbStackcbStack,,
lpStartAddrlpStartAddr, , lpvThreadParmlpvThreadParm,,fdwCreatefdwCreate,, lpIDThreadlpIDThread))
HANDLE CreateRemoteThread(HANDLE CreateRemoteThread(hProcesshProcess,,lpsalpsa,, cbStackcbStack,, lpStartAddrlpStartAddr,, lpvThreadParmlpvThreadParm,, fdwCreatefdwCreate, ,
lpIDThreadlpIDThread)) HANDLE GetCurrentThread(VOID)HANDLE GetCurrentThread(VOID)
HANDLE GetCurrentProcess(VOID)HANDLE GetCurrentProcess(VOID)
Uscita da un ThreadUscita da un Thread
Funzioni API Win32Funzioni API Win32VOID ExitThread(VOID ExitThread(dwExitCodedwExitCode))
BOOL TerminateThread(BOOL TerminateThread(hThreadhThread,, dwExitCodedwExitCode))
Funzioni API C Run-Time LibrariesFunzioni API C Run-Time Librariesvoid _endthread(void)void _endthread(void)
Valori di uscita da un Valori di uscita da un threadthread
BOOL GetExitCodeProcess (BOOL GetExitCodeProcess (hProcesshProcess, , lpdwExitCodelpdwExitCode)) BOOL GetExitCodeThread (BOOL GetExitCodeThread (hThreadhThread, , lpdwExitCodelpdwExitCode)) DWORD WaitForSingleObject(DWORD WaitForSingleObject(hObjecthObject,, dwTimeoutdwTimeout)) DWORD WaitForMultipleObjects(DWORD WaitForMultipleObjects(cObjectscObjects,,
lphObjectslphObjects,, fWaitAllfWaitAll,, dwTimeoutdwTimeout))
SincronizzazioneSincronizzazione
Per scrivere codice efficiente è Per scrivere codice efficiente è indispensabile...indispensabile...
evitare evitare tecniche di tecniche di
pollingpolling
SincronizzazioneSincronizzazione
Un thread che non deve aspettare un Un thread che non deve aspettare un evento esterno deve andare in stato di Waitevento esterno deve andare in stato di Wait
Se un thread deve aspettare che un altro Se un thread deve aspettare che un altro thread abbia compiuto una certa thread abbia compiuto una certa operazione, si sfruttano gli oggetti kernel operazione, si sfruttano gli oggetti kernel per la Sincronizzazione:per la Sincronizzazione: MutexMutex SemaphoreSemaphore EventEvent Critical SectionCritical Section
Attesa su Oggetti kernelAttesa su Oggetti kernel
Per sospendere un thread fino a che uno o Per sospendere un thread fino a che uno o più oggetti kernel non diventano più oggetti kernel non diventano “segnalati”, usare le funzioni di Wait:“segnalati”, usare le funzioni di Wait: DWORD WaitForSingleObject(DWORD WaitForSingleObject(
hObjecthObject,, dwTimeoutdwTimeout)) DWORD WaitForMultipleObjects(DWORD WaitForMultipleObjects(
cObjectscObjects,, lphObjectslphObjects,, fWaitAllfWaitAll,, dwTimeoutdwTimeout))
DWORD MsgWaitForMultipleObjects( DWORD MsgWaitForMultipleObjects( cObjectscObjects, , lphObjectslphObjects,, fWaitAllfWaitAll,,
dwTimeoutdwTimeout,, fdwWakeMaskfdwWakeMask ) )
Scenario di Scenario di sincronizzazione 1sincronizzazione 1
Gestire in maniera efficiente l’input da Gestire in maniera efficiente l’input da una porta serialeuna porta seriale Attende il prossimo carattere o il riempimento Attende il prossimo carattere o il riempimento
del buffer di inputdel buffer di input Legge e processa i caratteriLegge e processa i caratteri Attende il prossimo carattere o il bufferAttende il prossimo carattere o il buffer
Si usa l’oggetto Event, che è Si usa l’oggetto Event, che è funzionalmente simile ad una variabile funzionalmente simile ad una variabile booleanabooleana
Event ObjectsEvent Objects
Interprocess or IntraprocessInterprocess or Intraprocess Named or UnnamedNamed or Unnamed HANDLE CreateEvent(HANDLE CreateEvent(lpsalpsa,, fManualResetfManualReset,,
fInitialStatefInitialState,, lpszEventNamelpszEventName))
HANDLE OpenEvent(HANDLE OpenEvent(fdwAccessfdwAccess,, fInheritfInherit,, lpszEventNamelpszEventName))
BOOL SetEvent(BOOL SetEvent(hEventhEvent)) BOOL ResetEvent(BOOL ResetEvent(hEventhEvent)) BOOL PulseEvent(BOOL PulseEvent(hEventhEvent))
Uso di EventUso di EventHANDLE hEvent = CreateEvent (HANDLE hEvent = CreateEvent (
NULL, // no security NULL, // no security TRUE, // event must be reset TRUE, // event must be reset
// manually // manually FALSE, // initially nonsignaled FALSE, // initially nonsignaled NULL); // anonymous event NULL); // anonymous event
StartTaskThatSignalsEventWhenDone (hEvent);StartTaskThatSignalsEventWhenDone (hEvent); // Do other processing.// Do other processing. // Wait for event to be signaled; then reset it.// Wait for event to be signaled; then reset it.WaitForSingleObject (hEvent, INFINITE);WaitForSingleObject (hEvent, INFINITE);ResetEvent(hEvent);ResetEvent(hEvent); ......CloseHandle (hEvent);CloseHandle (hEvent);
Scenario di Scenario di sincronizzazione 2sincronizzazione 2
Proteggere strutture dati condivise, come Proteggere strutture dati condivise, come code e liste in memoria condivisa, dal code e liste in memoria condivisa, dal danneggiamento dovuto ad accessi danneggiamento dovuto ad accessi concorrenticoncorrenti
Si usa l’oggetto Mutex, che è un flag che Si usa l’oggetto Mutex, che è un flag che coordina l’esecuzione di operazioni coordina l’esecuzione di operazioni mutualmente esclusivemutualmente esclusive
Solo un thread può detenere un Mutex, gli Solo un thread può detenere un Mutex, gli altri thread vengono sospesi sulla Wait altri thread vengono sospesi sulla Wait fino a che il Mutex non viene rilasciatofino a che il Mutex non viene rilasciato
Mutex ObjectsMutex Objects
Interprocess or Intraprocess Interprocess or Intraprocess Named or UnnamedNamed or Unnamed Noncounting Mutual ExclusionNoncounting Mutual Exclusion HANDLE CreateMutex(HANDLE CreateMutex(
lpsalpsa,, fInitialOwnerfInitialOwner,, lpszMutexNamelpszMutexName))
HANDLE OpenMutex(HANDLE OpenMutex(fdwAccessfdwAccess,, fInheritfInherit, ,
lpszMutexNamelpszMutexName)) BOOL ReleaseMutex(BOOL ReleaseMutex(hMutexhMutex))
Uso di MutexUso di Mutexif (!hMutex) // if we have not yet created the if (!hMutex) // if we have not yet created the
mutex...mutex... { { // create mutex with creator having initial // create mutex with creator having initial ownershipownership hMutex = CreateMutex (NULL, TRUE, "Bob"); hMutex = CreateMutex (NULL, TRUE, "Bob"); if (GetLastError() == if (GetLastError() == ERROR_ALREADY_EXISTS)ERROR_ALREADY_EXISTS) WaitForSingleObject (hMutex, INFINITE); WaitForSingleObject (hMutex, INFINITE); } }
elseelse WaitForSingleObject (hMutex, INFINITE); WaitForSingleObject (hMutex, INFINITE);
__try{ // use the resource protected by the mutex__try{ // use the resource protected by the mutex } }__finally__finally { ReleaseMutex (hMutex); } { ReleaseMutex (hMutex); } ... ...CloseHandle (hMutex);CloseHandle (hMutex);
Scenario di Scenario di sincronizzazione 3sincronizzazione 3
Porta per Porta per nn-way Mutex-way Mutex Acquisisce una delle Acquisisce una delle nn risorse identiche da un risorse identiche da un
pool di risorse disponibilipool di risorse disponibili
Si usa l’oggetto Si usa l’oggetto SemaphoreSemaphore, che è simile , che è simile ad un Mutex con un contatoread un Mutex con un contatore
Un Mutex è come un Semaphore che Un Mutex è come un Semaphore che assume solo i valori 0 e 1; quando il assume solo i valori 0 e 1; quando il Semaphore diventa 0, le chiamate a Semaphore diventa 0, le chiamate a WaitFor... diventano sospensive, fino a WaitFor... diventano sospensive, fino a che qualche thread non incrementa il che qualche thread non incrementa il valore del Semaphorevalore del Semaphore
Semaphore ObjectsSemaphore Objects Interprocess or IntraprocessInterprocess or Intraprocess Named or UnnamedNamed or Unnamed CountingCounting HANDLE CreateSemaphore(HANDLE CreateSemaphore(
lpsalpsa,, cSemInitialcSemInitial,, cSemMaxcSemMax, , lpszSemNamelpszSemName))
HANDLE OpenSemaphore(HANDLE OpenSemaphore(fdwAccessfdwAccess,, fInheritfInherit,,
lpszSemNamelpszSemName)) BOOL ReleaseSemaphore(BOOL ReleaseSemaphore(
hSemaphorehSemaphore,, cReleaseCountcReleaseCount, , lplPreviousCountlplPreviousCount))
Uso di SemaphoreUso di SemaphoreHANDLE hSem = CreateSemaphore (HANDLE hSem = CreateSemaphore ( NULL, // security NULL, // security 4, // initial count 4, // initial count 4, // maximum count 4, // maximum count "Sally"); // global object name "Sally"); // global object name ......// Wait for any 1 of 4 resources to be available.// Wait for any 1 of 4 resources to be available.WaitForSingleObject (hSem, INFINITE);WaitForSingleObject (hSem, INFINITE);
__try{ // Use the semaphore.__try{ // Use the semaphore. }}__finally__finally {{ ReleaseSemaphore (hSem, 1, &lPrevCount) }; ReleaseSemaphore (hSem, 1, &lPrevCount) }; ......CloseHandle (hSem);CloseHandle (hSem);
HANDLE hSem = CreateSemaphore (HANDLE hSem = CreateSemaphore ( NULL, // security NULL, // security 4, // initial count 4, // initial count 4, // maximum count 4, // maximum count "Sally"); // global object name "Sally"); // global object name ......// Wait for any 1 of 4 resources to be available.// Wait for any 1 of 4 resources to be available.WaitForSingleObject (hSem, INFINITE);WaitForSingleObject (hSem, INFINITE);
__try{ // Use the semaphore.__try{ // Use the semaphore. }}__finally__finally {{ ReleaseSemaphore (hSem, 1, &lPrevCount) }; ReleaseSemaphore (hSem, 1, &lPrevCount) }; ......CloseHandle (hSem);CloseHandle (hSem);
Scenario di Scenario di sincronizzazione 4sincronizzazione 4
Sincronizzazione di diversi thread Sincronizzazione di diversi thread nello stesso processo con un oggetto nello stesso processo con un oggetto Mutex il più velocemente possibile, Mutex il più velocemente possibile, con il minimo overhead (es. con il minimo overhead (es. inserimento di un oggetto in una coda)inserimento di un oggetto in una coda)
Si usa l’oggetto Critical Section, che è Si usa l’oggetto Critical Section, che è un Mutex utilizzabile solo da thread di un Mutex utilizzabile solo da thread di uno stesso processouno stesso processo
Critical SectionCritical Section Meccanismo veloce di condizione mutualmente Meccanismo veloce di condizione mutualmente
esclusivaesclusiva Memoria allocata dall’utenteMemoria allocata dall’utente VOID VOID
InitializeCriticalSection(InitializeCriticalSection(lpcsCriticalSectionlpcsCriticalSection)) VOID VOID
DeleteCriticalSection(DeleteCriticalSection(lpcsCriticalSectionlpcsCriticalSection)) VOID VOID
EnterCriticalSection(EnterCriticalSection(lpcsCriticalSectionlpcsCriticalSection)) VOID VOID
LeaveCriticalSection(LeaveCriticalSection(lpcsCriticalSectionlpcsCriticalSection)) Protegge l’accesso a dati condivisi da thread Protegge l’accesso a dati condivisi da thread
dello stesso processodello stesso processo
Uso di Critical SectionUso di Critical Section
CRITICAL_SECTION cs;CRITICAL_SECTION cs;InitializeCriticalSection (&cs);InitializeCriticalSection (&cs);
. . . .
EnterCriticalSection (&cs);EnterCriticalSection (&cs);__try__try
{ { // initialize the thread arguments. // initialize the thread arguments. ta.hWnd = hWnd; ta.hWnd = hWnd; ta.lpDIB = lpDIB; ta.lpDIB = lpDIB; ta.rc = *lprc; ta.rc = *lprc; ta.bFlags = bFlags; ta.bFlags = bFlags; ta.pMP = pMP; ta.pMP = pMP; } }
__finally__finally { { LeaveCriticalSection (&cs); LeaveCriticalSection (&cs); } }
DeleteCriticalSection (&cs);DeleteCriticalSection (&cs);
CRITICAL_SECTION cs;CRITICAL_SECTION cs;InitializeCriticalSection (&cs);InitializeCriticalSection (&cs);
. . . .
EnterCriticalSection (&cs);EnterCriticalSection (&cs);__try__try
{ { // initialize the thread arguments. // initialize the thread arguments. ta.hWnd = hWnd; ta.hWnd = hWnd; ta.lpDIB = lpDIB; ta.lpDIB = lpDIB; ta.rc = *lprc; ta.rc = *lprc; ta.bFlags = bFlags; ta.bFlags = bFlags; ta.pMP = pMP; ta.pMP = pMP; } }
__finally__finally { { LeaveCriticalSection (&cs); LeaveCriticalSection (&cs); } }
DeleteCriticalSection (&cs);DeleteCriticalSection (&cs);
Thread e code mesaggi:Thread e code mesaggi:Modello Win32Modello Win32
ApplicationApplicationApplicationApplication
RITRIT
MouseDevice Driver
MouseDevice Driver
KeyboardDevice Driver
KeyboardDevice Driver
ThreadThread ThreadThread ThreadThread
Raw InputThread
EventQueues
Funzioni API per Funzioni API per messaggi e threadmessaggi e thread
BOOL PostMessage(BOOL PostMessage(hWndhWnd,, uMsguMsg,, wParamwParam,, lParamlParam)) BOOL GetMessage(BOOL GetMessage(lpmsglpmsg,, hWndhWnd,, uMsgFilterMinuMsgFilterMin, ,
uMsgFilterMaxuMsgFilterMax)) BOOL PostThreadMessage(BOOL PostThreadMessage(
dwThreadIddwThreadId,, uMsguMsg,, wParamwParam,,lParamlParam)) BOOL PeekMessage(BOOL PeekMessage(lpmsglpmsg,, hWndhWnd,, uMsgFilterMinuMsgFilterMin,,
uMsgFilterMaxuMsgFilterMax,, fuRemoveMsgfuRemoveMsg)) LRESULT SendMessage(LRESULT SendMessage(hWndhWnd,, uMsguMsg,, wParamwParam,, lParamlParam)) BOOL SendNotifyMessage(BOOL SendNotifyMessage(hWndhWnd,, uMsguMsg,, wParamwParam,,
lParamlParam)) BOOL AttachThreadInput(BOOL AttachThreadInput(idAttachidAttach,, idAttachToidAttachTo,, fAttachfAttach)) DWORD MsgWaitForMultipleObjects(DWORD MsgWaitForMultipleObjects(cObjectscObjects,,
lphObjectslphObjects,,fWaitAllfWaitAll,, dwTimeoutdwTimeout,, fdwWakeMaskfdwWakeMask ) )
ThreadThread Definizione di threadDefinizione di thread Cooperative e preemptive multitaskingCooperative e preemptive multitasking Perchè usare thread multipli?Perchè usare thread multipli? Thread overheadThread overhead SchedulerScheduler Creazione di un thread Creazione di un thread C Run-Time LibraryC Run-Time Library Oggetti per la sincronizzazioneOggetti per la sincronizzazione Thread e code di messaggiThread e code di messaggi
Thread PoolThread Pool
Thread PoolThread Pool
Insieme di Thread gestiti dal sistemaInsieme di Thread gestiti dal sistema Disponibili solo da Windows 2000 in poiDisponibili solo da Windows 2000 in poi Scenari affrontati:Scenari affrontati:
1.1. Accodare l’esecuzione asincrona di diverse Accodare l’esecuzione asincrona di diverse funzionifunzioni
2.2. Chiamare diverse funzioni periodicamente Chiamare diverse funzioni periodicamente (senza WM_TIMER)(senza WM_TIMER)
3.3. Chiamare funzioni quando un oggetto kernel va Chiamare funzioni quando un oggetto kernel va in stato “segnalato”in stato “segnalato”
4.4. Chiamare una funzione quando una richiesta di Chiamare una funzione quando una richiesta di I/O asincrono viene completataI/O asincrono viene completata
Thread Pool – Scenario 1Thread Pool – Scenario 1 Scenario: accodare l’esecuzione asincrona Scenario: accodare l’esecuzione asincrona
di diverse funzioni (ad es. una scrittura di diverse funzioni (ad es. una scrittura “posticipata”)“posticipata”)
Senza Thread PoolSenza Thread Pool Creazione di un Thread, esecuzione della Creazione di un Thread, esecuzione della
funzione, distruzione del Threadfunzione, distruzione del Thread
Con Thread PoolCon Thread Pool Una chiamata a QueueUserWorkItemUna chiamata a QueueUserWorkItem
Thread Pool – Scenario 1Thread Pool – Scenario 1
BOOL QueueUserWorkItem(BOOL QueueUserWorkItem(LPTHREAD_START_ROUTINE pfnCallback,LPTHREAD_START_ROUTINE pfnCallback,PVOID pvContext,PVOID pvContext,ULONG Flags );ULONG Flags );
Valori di Flags:Valori di Flags:WT_EXECUTEDEFAULTWT_EXECUTEDEFAULTWT_EXECUTEINIOTHREADWT_EXECUTEINIOTHREADWT_EXECUTEINPERSISTENTIOTHREADWT_EXECUTEINPERSISTENTIOTHREADWT_EXECUTELONGFUNCTION WT_EXECUTELONGFUNCTION
Thread Pool – Scenario 2Thread Pool – Scenario 2 Scenario: chiamare diverse funzioni Scenario: chiamare diverse funzioni
periodicamenteperiodicamente
Senza Thread PoolSenza Thread Pool Un thread per ogni funzione, Sleep(x) tra Un thread per ogni funzione, Sleep(x) tra
una chiamata e l’altrauna chiamata e l’altra WM_TIMER per ogni funzioneWM_TIMER per ogni funzione
Con Thread PoolCon Thread Pool Una chiamata a CreateTimerQueueTimerUna chiamata a CreateTimerQueueTimer
Thread Pool – Scenario 2Thread Pool – Scenario 2
CreateTimerQueueCreateTimerQueue CreateTimerQueueTimerCreateTimerQueueTimer ChangeTimerQueueTimerChangeTimerQueueTimer DeleteTimerQueueTimerDeleteTimerQueueTimer DeleteTimerQueueExDeleteTimerQueueEx
Thread Pool – Scenario 2Thread Pool – Scenario 2
BOOL CreateTimerQueueTimer(BOOL CreateTimerQueueTimer(PHANDLE phNewTimer,PHANDLE phNewTimer,HANDLE TimerQueue,HANDLE TimerQueue,WAITORTIMERCALLBACK Callback,WAITORTIMERCALLBACK Callback,PVOID Parameter, WORD DueTime,PVOID Parameter, WORD DueTime,WORD Period, LONG Flags );WORD Period, LONG Flags );
Valori di Flags:Valori di Flags:WT_EXECUTEINTIMERTHREADWT_EXECUTEINTIMERTHREADWT_EXECUTEINIOTHREADWT_EXECUTEINIOTHREADWT_EXECUTEINPERSISTENTIOTHREADWT_EXECUTEINPERSISTENTIOTHREADWT_EXECUTELONGFUNCTIONWT_EXECUTELONGFUNCTION
Thread Pool – Scenario 3Thread Pool – Scenario 3 Scenario: eseguire una funzione quando Scenario: eseguire una funzione quando
un oggetto kernel diventa segnalatoun oggetto kernel diventa segnalato
Senza Thread PoolSenza Thread Pool Un thread per ogni funzione/oggetto, Un thread per ogni funzione/oggetto,
WaitForSingleObject prima della chiamataWaitForSingleObject prima della chiamata Un thread controlla più oggetti kernel con Un thread controlla più oggetti kernel con
WaitForMultipleObjects...WaitForMultipleObjects...Con Thread PoolCon Thread Pool
Chiamare RegisterWaitForSingleObjectChiamare RegisterWaitForSingleObject
Thread Pool – Scenario 3Thread Pool – Scenario 3
RegisterWaitForSingleObjectRegisterWaitForSingleObject UnregisterWaitExUnregisterWaitEx
Thread Pool – Scenario 3Thread Pool – Scenario 3
BOOL RegisterWaitForSingleObject(BOOL RegisterWaitForSingleObject(PHANDLE phNewObject,PHANDLE phNewObject,HANDLE hObject,HANDLE hObject,WAITORTIMERCALLBACK Callback,WAITORTIMERCALLBACK Callback,PVOID pvContext,PVOID pvContext,ULONG dwMillisecs, ULONG dwFlags );ULONG dwMillisecs, ULONG dwFlags );
Valori di Flags:Valori di Flags:WT_EXECUTEDEFAULTWT_EXECUTEDEFAULTWT_EXECUTEINWAITTHREADWT_EXECUTEINWAITTHREADWT_EXECUTEINIOTHREADWT_EXECUTEINIOTHREADWT_EXECUTEINPERSISTENTIOTHREADWT_EXECUTEINPERSISTENTIOTHREADWT_EXECUTELONGFUNCTIONWT_EXECUTELONGFUNCTIONWT_EXECUTEONLYONCEWT_EXECUTEONLYONCE
Thread Pool – Scenario 4Thread Pool – Scenario 4
Scenario: chiamare una funzione quando Scenario: chiamare una funzione quando termina un’operazione di I/O asincronotermina un’operazione di I/O asincrono
Senza Thread PoolSenza Thread Pool Creazione di un I/O completion port e Creazione di un I/O completion port e
gestione manuale di un thread poolgestione manuale di un thread pool
Con Thread PoolCon Thread Pool Una chiamata a BindIoCompletionCallbackUna chiamata a BindIoCompletionCallback
Thread Pool – Scenario 4Thread Pool – Scenario 4
BOOL BindIoCompletionCallback(BOOL BindIoCompletionCallback(HANDLE FileHandle,HANDLE FileHandle,LPOVERLAPPED_COMPLETION_ROUTINE Function,LPOVERLAPPED_COMPLETION_ROUTINE Function,ULONG Flags );ULONG Flags );
FlagsFlags è riservato, deve valere sempre 0 è riservato, deve valere sempre 0
Prototipo Prototipo LPOVERLAPPED_COMPLETION_ROUTINE:LPOVERLAPPED_COMPLETION_ROUTINE:VOID WINAPI OverlappedCompletionRoutine(VOID WINAPI OverlappedCompletionRoutine(DWORD dwErrorCode,DWORD dwErrorCode,DWORD dwNumberOfBytesTransfered,DWORD dwNumberOfBytesTransfered,LPOVERLAPPED lpOverlapped );LPOVERLAPPED lpOverlapped );
Thread PoolThread Pool
Esecuzione di funzioni asincroneEsecuzione di funzioni asincrone Esecuzione periodica di funzioniEsecuzione periodica di funzioni Operazioni da eseguire quando un Operazioni da eseguire quando un
oggetto kernel diventa “segnalato”oggetto kernel diventa “segnalato” Operazioni da eseguire al termine di Operazioni da eseguire al termine di
operazioni di I/Ooperazioni di I/O
JobsJobs
JobJob
Gruppo di processiGruppo di processi E’ un oggetto kernelE’ un oggetto kernel Disponibile solo da Windows 2000 in poiDisponibile solo da Windows 2000 in poi Crea delle regole per i processi che Crea delle regole per i processi che
contienecontiene Può definire dei limiti su:Può definire dei limiti su:
Risorse del sistemaRisorse del sistema Interfaccia utenteInterfaccia utente SicurezzaSicurezza
Può monitorare l’attività dei processiPuò monitorare l’attività dei processi
Job – Ciclo di vitaJob – Ciclo di vita Il Job viene creato “vuoto”Il Job viene creato “vuoto” Impostare proprietà del JobImpostare proprietà del Job Un processo viene assegnato ad un JobUn processo viene assegnato ad un Job La relazione Processo-Job è irreversibileLa relazione Processo-Job è irreversibile Un processo figlio può nascere fuori dal Un processo figlio può nascere fuori dal
Job del processo padreJob del processo padre Se un Job viene terminato, tutti i suoi Se un Job viene terminato, tutti i suoi
processi vengono terminatiprocessi vengono terminati Il Job comunica con l’esterno con le I/O Il Job comunica con l’esterno con le I/O
completion port (non segnala su Handle)completion port (non segnala su Handle)
Job – Ciclo di vitaJob – Ciclo di vita
Il nome associato al Job è accessibile Il nome associato al Job è accessibile fino a che ci sono handle aperti al fino a che ci sono handle aperti al JobJob
Se tutti gli handle al Job vengono Se tutti gli handle al Job vengono chiusi, il Job resta in vita ma non è chiusi, il Job resta in vita ma non è più accessibile (verrà distrutto più accessibile (verrà distrutto quando tutti i processi all’interno si quando tutti i processi all’interno si saranno chiusi)saranno chiusi)
Job - LimitiJob - Limiti
Limiti sulle risorse di sistema:Limiti sulle risorse di sistema: Process PriorityProcess Priority Consumo CPUConsumo CPU Working Set SizeWorking Set Size Consumo memoriaConsumo memoria Processor AffinityProcessor Affinity
Job - LimitiJob - Limiti
Limiti su interfaccia utenteLimiti su interfaccia utente Accesso USER Handle (HWND, Accesso USER Handle (HWND,
HMENU, ...)HMENU, ...) Creazione/Switch DesktopCreazione/Switch Desktop Modifica impostazioni videoModifica impostazioni video Modifica parametri di sistemaModifica parametri di sistema ClipboardClipboard ExitWindowsExitWindows
Job - LimitiJob - Limiti
Limiti sulla security – Token Limiti sulla security – Token utilizzabili:utilizzabili: No AdministratorNo Administrator Tutti i processi con un token ugualeTutti i processi con un token uguale Solo token ristretti rispetto a quello del Solo token ristretti rispetto a quello del
processoprocesso Filtro sui token (disabilitazione di alcuni Filtro sui token (disabilitazione di alcuni
diritti indipendentemente dall’utente diritti indipendentemente dall’utente impersonato)impersonato)
Job - MonitoraggioJob - Monitoraggio
Tempo CPU (kernel/user)Tempo CPU (kernel/user) Page FaultPage Fault Numero processi (attivi/terminati)Numero processi (attivi/terminati) Attività di I/O (operazioni/byte)Attività di I/O (operazioni/byte) Elenco processiElenco processi
Job - FunzioniJob - Funzioni
CreateJobObjectCreateJobObject OpenJobObjectOpenJobObject AssignProcessToJobObjectAssignProcessToJobObject TerminateJobObjectTerminateJobObject QueryInformationJobObjectQueryInformationJobObject SetInformationJobObjectSetInformationJobObject UserHandleGrantAccessUserHandleGrantAccess
JobsJobs
Definizione di JobDefinizione di Job
Ciclo di vitaCiclo di vita
Limiti definibiliLimiti definibili
MonitoraggioMonitoraggio
Comunicazione tra Comunicazione tra
processiprocessi
(IPC – Interprocess (IPC – Interprocess Communication)Communication)
Comunicazione tra Comunicazione tra processiprocessi
Per comunicare tra loro, due Per comunicare tra loro, due processi devono richiedere dei processi devono richiedere dei servizi al sistema operativo:servizi al sistema operativo: Memory Mapped File (Shared Memory)Memory Mapped File (Shared Memory) Object HandlesObject Handles File su discoFile su disco Socket, Named Pipe e MailslotSocket, Named Pipe e Mailslot RPC (Remote Procedure Call)RPC (Remote Procedure Call)
Memory Mapped FileMemory Mapped File Consente di condividere memoria tra Consente di condividere memoria tra
processi diversiprocessi diversi E’ una scelta adeguata quando più processi E’ una scelta adeguata quando più processi
devono accedere contemporaneamente ad devono accedere contemporaneamente ad informazioni contenute in strutture dati di informazioni contenute in strutture dati di vaste dimensionivaste dimensioni
L’accesso simultaneo (almeno in scrittura) L’accesso simultaneo (almeno in scrittura) va protetto tramite meccanismi di va protetto tramite meccanismi di sincronizzazione tra threadsincronizzazione tra thread
Non vi è una notifica istantanea della Non vi è una notifica istantanea della variazione di un dato da parte di un variazione di un dato da parte di un processoprocesso
Object HandleObject Handle
Più processi possono accedere ad Più processi possono accedere ad uno stesso oggetto kerneluno stesso oggetto kernel
E’ una tecnica indispensabile per E’ una tecnica indispensabile per condividere oggetti di condividere oggetti di sincronizzazione tra processi diversisincronizzazione tra processi diversi
File su discoFile su disco
E’ un meccanismo che consente la E’ un meccanismo che consente la condivisione di informazioni tra condivisione di informazioni tra programmi in esecuzione anche su programmi in esecuzione anche su macchine diverse e con sistemi macchine diverse e con sistemi operativi diversioperativi diversi
Le prestazioni e la scalabilità sono le Le prestazioni e la scalabilità sono le più basse rispetto alle tecniche più basse rispetto alle tecniche esaminateesaminate
Socket, Named Pipe, Socket, Named Pipe, MailslotMailslot
Sono dei “canali” di comunicazione tra Sono dei “canali” di comunicazione tra processiprocessi
Si possono usare anche tra processi Si possono usare anche tra processi residenti su elaboratori diversiresidenti su elaboratori diversi
La trasmissione delle informazioni è La trasmissione delle informazioni è sequenzialesequenziale
I dati inviati generano delle notifiche ai I dati inviati generano delle notifiche ai processi in ascolto: questo consente di processi in ascolto: questo consente di evitare tecniche di polling anche su evitare tecniche di polling anche su comunicazioni in retecomunicazioni in rete
SocketSocket Windows Sockets 2 è l’implementazione Windows Sockets 2 è l’implementazione
Microsoft dell’interfaccia di Microsoft dell’interfaccia di programmazione definita in “Berkely programmazione definita in “Berkely Sockets”Sockets”
Conosciuta come interfaccia di Conosciuta come interfaccia di programmazione per TCP/IP, è programmazione per TCP/IP, è utilizzabile anche per altri protocolliutilizzabile anche per altri protocolli
E’ il sistema ideale per implementare E’ il sistema ideale per implementare meccanismi di comunicazione su rete tra meccanismi di comunicazione su rete tra sistemi operativi diversisistemi operativi diversi
Supporta una comunicazione Supporta una comunicazione bidirezionalebidirezionale
E’ un meccanismo client/serverE’ un meccanismo client/server
SocketSocket Il client può risiedere sulla stessa macchina Il client può risiedere sulla stessa macchina
del server, o su una macchina diversadel server, o su una macchina diversa
Processo S1
Processo C1
Processo C2
Port 80
Port 80
Port 1219
Port 1198
socket
socket
Computer AComputer B
S1: Processo serverC1, C2: Processi client
Named PipeNamed Pipe Meccanismo di comunicazione client-serverMeccanismo di comunicazione client-server Simile ad un socket, ma indipendente dal Simile ad un socket, ma indipendente dal
protocollo fisicoprotocollo fisico Pipe Server: processo che crea una named pipePipe Server: processo che crea una named pipe Pipe Client: processo che si connette ad una Pipe Client: processo che si connette ad una
istanza di named pipeistanza di named pipe La named pipe ha un nome univoco per la La named pipe ha un nome univoco per la
macchina in cui è definita, ma possono esistere macchina in cui è definita, ma possono esistere più istanze della stessa named-pipepiù istanze della stessa named-pipe
Integra la “security”Integra la “security” Modalità di funzionamento “message-mode”Modalità di funzionamento “message-mode” Server solo su NT/2000, Client su Server solo su NT/2000, Client su
Win9x/NT/2000Win9x/NT/2000
Named PipeNamed Pipe
Il client può risiedere sulla stessa macchina Il client può risiedere sulla stessa macchina del server, o su una macchina diversadel server, o su una macchina diversa
Processo S1
Processo C1
Processo C2
\\S1\pipe\Test
\\S1\pipe\Test
named pipe
named pipe
Computer AComputer B
S1: Processo serverC1, C2: Processi client
Pipe ServerPipe Server
Sequenza di funzioni API da Sequenza di funzioni API da chiamare:chiamare: CreateNamedPipeCreateNamedPipe ConnectNamedPipeConnectNamedPipe ReadFile / WriteFileReadFile / WriteFile DisconnectNamedPipeDisconnectNamedPipe CloseHandleCloseHandle
Pipe ClientPipe Client
Sequenza di funzioni API da Sequenza di funzioni API da chiamare:chiamare: CreateFileCreateFile WriteNamedPipeWriteNamedPipe SetNamedPipeHandleStateSetNamedPipeHandleState ReadFile / WriteFileReadFile / WriteFile CloseHandleCloseHandle
Named Pipe: API specialiNamed Pipe: API speciali BOOL TransactNamedPipe(…)BOOL TransactNamedPipe(…)
Esegue sequenzialmente WriteFile seguita da Esegue sequenzialmente WriteFile seguita da ReadFileReadFile
Si usa sul client per semplificare il codice di Si usa sul client per semplificare il codice di esecuzione di transazioni sincroneesecuzione di transazioni sincrone
BOOL CallNamedPipe(…)BOOL CallNamedPipe(…) Esegue sequenzialmente WaitNamedPipe, Esegue sequenzialmente WaitNamedPipe,
CreateFile, TransactNamedPipe e CreateFile, TransactNamedPipe e CloseHandleCloseHandle
Si usa sul client per semplificare il codice nel Si usa sul client per semplificare il codice nel caso in cui per ogni transazione si vuole aprire caso in cui per ogni transazione si vuole aprire e chiudere una connessionee chiudere una connessione
MailslotMailslot Meccanismo di comunicazione broadcast Meccanismo di comunicazione broadcast
senza connessionesenza connessione Mailslot Server: processo che crea una Mailslot Server: processo che crea una
mailslot e legge i dati ad essa inviatimailslot e legge i dati ad essa inviati Mailslot Client: processo che scrive un Mailslot Client: processo che scrive un
messaggio su una mailslotmessaggio su una mailslot Il nome di una mailslot è univoco per una Il nome di una mailslot è univoco per una
macchinamacchina Nessuna gestione di “security”Nessuna gestione di “security” Modalità di funzionamento “message-Modalità di funzionamento “message-
mode”mode” Server e Client su Win9x / NT / 2000Server e Client su Win9x / NT / 2000
MailslotMailslot
Una macchina può ospitare solo una mailslot Una macchina può ospitare solo una mailslot con lo stesso nomecon lo stesso nome
Processo C1
Processo S1
Processo S2mailslot
mailslot
Computer AComputer B
S1, S2: Processi serverC1: Processo client
\\.\mailslot\Test
\\.\mailslot\Test
Nomi delle MailslotNomi delle Mailslot
Creazione mailslot (server):Creazione mailslot (server): \\.\mailslot\\\.\mailslot\mailslotnamemailslotname
Apertura mailslot per scrittura Apertura mailslot per scrittura (client):(client): \\\\..\mailslot\\mailslot\mailslotnamemailslotname \\\\ComputerNameComputerName\mailslot\\mailslot\mailslotnamemailslotname \\\\DomainNameDomainName\mailslot\\mailslot\mailslotnamemailslotname \\\\**\mailslot\\mailslot\mailslotnamemailslotname
Mailslot localiMailslot locali Il Il Mailslot serverMailslot server deve esistere quando il deve esistere quando il
Mailslot client Mailslot client viene creatoviene creato Un messaggio può essere lungo fino a 64KUn messaggio può essere lungo fino a 64K I messaggi inviati al server vengono I messaggi inviati al server vengono
ricevuti una voltaricevuti una volta I messaggi inviati vengono sicuramente I messaggi inviati vengono sicuramente
ricevuti, ma non si sa se e quando ricevuti, ma non si sa se e quando vengono lettivengono letti
Possono esistere più client che scrivono Possono esistere più client che scrivono sullo stesso server, se i client usano gli sullo stesso server, se i client usano gli attributi FILE_SHARE_WRITE | attributi FILE_SHARE_WRITE | FILE_SHARE_READ nella CreateFile()FILE_SHARE_READ nella CreateFile()
Mailslot remoteMailslot remote Deve esserci almeno un protocollo di rete attivoDeve esserci almeno un protocollo di rete attivo Il Il Mailslot client Mailslot client può essere creato in qualsiasi può essere creato in qualsiasi
momento (anche se non esiste un momento (anche se non esiste un Mailslot Mailslot serverserver))
La scrittura da parte del La scrittura da parte del Mailslot client Mailslot client non non genera mai errorigenera mai errori
Un messaggio inviato ad un dominio può essere Un messaggio inviato ad un dominio può essere letto da più serverletto da più server
Compatibilità garantita per messaggi fino a 425 Compatibilità garantita per messaggi fino a 425 bytebyte
Viene inviata una copia del messaggio per ogni Viene inviata una copia del messaggio per ogni protocollo di rete installato (il protocollo di rete installato (il Mailslot server Mailslot server può ricevere più copie dello stesso messaggio)può ricevere più copie dello stesso messaggio)
Mailslot ServerMailslot Server
Sequenza di funzioni API da Sequenza di funzioni API da chiamare:chiamare: CreateMailslotCreateMailslot ReadFileReadFile CloseHandleCloseHandle
Mailslot ClientMailslot Client
Sequenza di funzioni API da Sequenza di funzioni API da chiamare:chiamare: CreateFileCreateFile WriteFileWriteFile CloseHandleCloseHandle
Remote Procedure CallRemote Procedure Call
Consente di eseguire chiamate a Consente di eseguire chiamate a funzioni presenti in processi diversi, funzioni presenti in processi diversi, anche su elaboratori diversianche su elaboratori diversi
E’ basato sugli standard definiti da E’ basato sugli standard definiti da OSF (Open Software Foundation) OSF (Open Software Foundation) DCE (Distributed Computing DCE (Distributed Computing Environment)Environment)
E’ indipendente dal protocollo di reteE’ indipendente dal protocollo di rete E’ la base di DCOME’ la base di DCOM
Remote Procedure CallRemote Procedure Call Per ogni chiamata, avviene una transazione coordinata Per ogni chiamata, avviene una transazione coordinata dal sistema operativo, per trasferire al “server” i dal sistema operativo, per trasferire al “server” i parametri della funzione, e ricevere da esso i risultatiparametri della funzione, e ricevere da esso i risultati
Application
Transport
Client Stub
Client Run-Time Library
Application
Transport
Client Stub
Client Run-Time Library
1
2
3
4
5
6
78
9
10
11
12
13
14
Client Server
Comunicazione tra Comunicazione tra processiprocessi
Shared MemoryShared Memory SocketsSockets Named PipeNamed Pipe MailslotMailslot Remote Procedure CallRemote Procedure Call
Operazioni di Operazioni di I/OI/O
(I/O Manager)(I/O Manager)
Windows NT I/O System ArchitectureWindows NT I/O System Architecture
I/ODevices
DMA/BusController
TimersCaches,
Interrupts
CPUPrivileged
Architecture
Software
Hardware
Applications and Subsystems (User-Mode Instruction Set)
I/O Manager
SecurityMonitor
ObjectManager
LocalIPC
VirtualMemoryManager
ProcessManager
DeviceDrivers
Kernel
HAL
GDIUSER
Name Space unico per Name Space unico per tutti i Devicetutti i Device
CD-ROMDrive
EnvironmentSubsystem
or DLL
EnvironmentSubsystem
or DLL
I/O ManagerI/O Manager
File System and Network Drivers
Device Drivers
Video Monitorand Keyboard
Mouse
Printer DiskDrive
Network Device
Tape
User Mode Kernel Mode
I/O System Services
Link simboliciLink simbolici
Usati per mappare nomi di Device MS-DOS al Usati per mappare nomi di Device MS-DOS al Name Space di Windows NTName Space di Windows NT
DWORD QueryDosDevice(DWORD QueryDosDevice(lpDeviceNamelpDeviceName,, lpTargetPathlpTargetPath, ,
ucchMaxucchMax)) BOOL DefineDosDevice(BOOL DefineDosDevice(
dwFlagsdwFlags,, lpDeviceNamelpDeviceName, , lpTargetPathlpTargetPath))
EsempioEsempioD: -> \DEVICE\HARDDISC0\PARTITION2D: -> \DEVICE\HARDDISC0\PARTITION2
Cache ManagerCache Manager Cache di tutto l’I/O per defaultCache di tutto l’I/O per default Incrementa le performance dei Incrementa le performance dei
programmi che effettuano molte programmi che effettuano molte operazioni di I/Ooperazioni di I/O
La dimensione della Cache è dinamicaLa dimensione della Cache è dinamica E’ un insieme di oggetti SectionE’ un insieme di oggetti Section Ha il proprio spazio di indirizzamento (di Ha il proprio spazio di indirizzamento (di
sistema) sistema) Usa il Virtual Memory Manager per Usa il Virtual Memory Manager per
effettuare la paginazioneeffettuare la paginazione
API per File I/OAPI per File I/O
Si possono usare le seguenti API per Si possono usare le seguenti API per accedere ai file:accedere ai file: C Run-Time LibraryC Run-Time Library Windows 3.1 API Windows 3.1 API (solo per compatibilità)(solo per compatibilità)
Win32 APIWin32 API
Win95-Based Win95-Based Synchronous I/O Synchronous I/O
ProcessingProcessingWriteFile(file_handledata, ...)
WriteFile(file_handledata, ...)
Returns
User Mode
Kernel Mode
Application
Win32Subsystem
I/O Manager
Device Driver
Device
Call Windows NT Write File Service
Check ParametersCreate IRPCall Device Driver
Queue I/Oto Device
Perform I/O Transfer Wait for Completion
Complete IRPReturn
Return Data
Time
Windows NT–Based Windows NT–Based Synchronous ProcessingSynchronous Processing
User Mode
Kernel Mode
Application
Win32Subsystem
I/O Manager
Device Driver
Device
WriteFile(file_handledata, ...,overlapped)
Call Windows NT Write File Service
Check ParametersCreate IRPCall Device Driver
Queue I/Oto Device
Return
Wait(...)
. . .
<Wait ends>Return I/O Status
Perform I/O TransferInterrupt for Service
Handle Interrupt
Set File Handleto Signaled State
. . .
Time
Asynchronous Asynchronous (Overlapped) I/O (Overlapped) I/O
ProcessingProcessing
User Mode
Kernel Mode
Application
Win32Subsystem
I/O Manager
Device Driver
Device
WriteFile(file_handledata, ...,overlapped)
Call Windows NT Write File Service
Check ParametersCreate IRPCall Device Driver
Queue I/Oto Device
Return
Return
. . .
<Wait ends>
Perform I/O TransferInterrupt for Service
Handle Interrupt
Set File Handleto Signaled State
Return I/OPending Status
<Perform other work>Wait(file_handle)
. . .
Time
Effettuare Overlapped Effettuare Overlapped I/O con Win32I/O con Win32
Usare il flag Usare il flag FILE_FLAG_OVERLAPPED quando si FILE_FLAG_OVERLAPPED quando si apre un file con CreateFile()apre un file con CreateFile()
Effettuare un’operazione di I/O, e Effettuare un’operazione di I/O, e mettersi in Wait su:mettersi in Wait su: File handle, oppureFile handle, oppure Event object, oppure Event object, oppure Una I/O completion callbackUna I/O completion callback
Esempio: Overlapped I/O Esempio: Overlapped I/O usando Event Object usando Event Object HANDLE hFile;HANDLE hFile;
LPOVERLAPPED lpo;LPOVERLAPPED lpo;// create and initialize an OVERLAPPED structure// create and initialize an OVERLAPPED structurelpo = calloc (sizeof(OVERLAPPED), 1);lpo = calloc (sizeof(OVERLAPPED), 1);lpo->Offset = 0;lpo->Offset = 0;lpo->hEvent = CreateEvent (NULL, TRUE, FALSE, NULL);lpo->hEvent = CreateEvent (NULL, TRUE, FALSE, NULL);hFile = CreateFile ("filename", GENERIC_WRITE, 0, hFile = CreateFile ("filename", GENERIC_WRITE, 0, NULL, NULL, CREATE_NEW, CREATE_NEW, FILE_ATTRIBUTE_NORMAL | FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL);FILE_FLAG_OVERLAPPED, NULL);// begin async io// begin async ioWriteFile(hFile, pBuffer, cbBuffer, &nBytesWritten, lpo);WriteFile(hFile, pBuffer, cbBuffer, &nBytesWritten, lpo);// wait for io to complete and get result// wait for io to complete and get resultGetOverlappedResult (hFile, lpo, &nBytesWritten, TRUE);GetOverlappedResult (hFile, lpo, &nBytesWritten, TRUE);// cleanup// cleanupCloseHandle (lpo->hEvent);CloseHandle (lpo->hEvent);free (lpo);free (lpo);
I/O Completion RoutineI/O Completion Routine
User-Mode Asynchronous CallbackUser-Mode Asynchronous Callback Non è veramente asincrona, perché può Non è veramente asincrona, perché può
essere eseguita solo in corrispondenza essere eseguita solo in corrispondenza di punti di controllo definiti (Control di punti di controllo definiti (Control Points)Points)
Control PointsControl Points ReadFileEx, WriteFileEx, ReadFileEx, WriteFileEx,
WaitForSingleObjectEx, WaitForSingleObjectEx, WaitForMultipleObjectsEx, SleepExWaitForMultipleObjectsEx, SleepEx
Esempio: I/O Completion Esempio: I/O Completion RoutineRoutineVOID WINAPI lpfnIOCompletion (VOID WINAPI lpfnIOCompletion (
DWORD dwError, DWORD dwError, DWORD cbWritten, DWORD cbWritten, LPOVERLAPPED lpo) LPOVERLAPPED lpo){{if (!dwError)if (!dwError) lpo->Offset += cbWritten; lpo->Offset += cbWritten;}}
......hFile = CreateFile ("filename", GENERIC_WRITE, 0, NULL, hFile = CreateFile ("filename", GENERIC_WRITE, 0, NULL, CREATE_NEW,CREATE_NEW, FILE_ATTRIBUTE_NORMAL | FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,FILE_FLAG_OVERLAPPED, NULL);NULL);// create and initialize an OVERLAPPED structure// create and initialize an OVERLAPPED structurelpo = calloc (sizeof(OVERLAPPED), 1);lpo = calloc (sizeof(OVERLAPPED), 1);lpo->Offset = GetFileSize (hFile, NULL);lpo->Offset = GetFileSize (hFile, NULL);// begin async io with callback// begin async io with callbackWriteFileEx (hFile, pBuffer, cbBuffer, lpo, lpfnIOCompletion);WriteFileEx (hFile, pBuffer, cbBuffer, lpo, lpfnIOCompletion); ......// wait for callback to be called on i/o completion// wait for callback to be called on i/o completionSleepEx (INFINITE, TRUE);SleepEx (INFINITE, TRUE); ......
VOID WINAPI lpfnIOCompletion (VOID WINAPI lpfnIOCompletion ( DWORD dwError, DWORD dwError, DWORD cbWritten, DWORD cbWritten, LPOVERLAPPED lpo) LPOVERLAPPED lpo){{if (!dwError)if (!dwError) lpo->Offset += cbWritten; lpo->Offset += cbWritten;}}
......hFile = CreateFile ("filename", GENERIC_WRITE, 0, NULL, hFile = CreateFile ("filename", GENERIC_WRITE, 0, NULL, CREATE_NEW,CREATE_NEW, FILE_ATTRIBUTE_NORMAL | FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,FILE_FLAG_OVERLAPPED, NULL);NULL);// create and initialize an OVERLAPPED structure// create and initialize an OVERLAPPED structurelpo = calloc (sizeof(OVERLAPPED), 1);lpo = calloc (sizeof(OVERLAPPED), 1);lpo->Offset = GetFileSize (hFile, NULL);lpo->Offset = GetFileSize (hFile, NULL);// begin async io with callback// begin async io with callbackWriteFileEx (hFile, pBuffer, cbBuffer, lpo, lpfnIOCompletion);WriteFileEx (hFile, pBuffer, cbBuffer, lpo, lpfnIOCompletion); ......// wait for callback to be called on i/o completion// wait for callback to be called on i/o completionSleepEx (INFINITE, TRUE);SleepEx (INFINITE, TRUE); ......
I/O Completion PortI/O Completion Port Basato su una coda (I/O Completion Port) di Basato su una coda (I/O Completion Port) di
messaggi relativi alle operazioni di I/O messaggi relativi alle operazioni di I/O asincrone completate (I/O Completion Packet)asincrone completate (I/O Completion Packet)
Uno o più thread (generalmente worker Uno o più thread (generalmente worker thread) possono prelevare messaggi dalla thread) possono prelevare messaggi dalla coda ed eseguire operazioni appropriatecoda ed eseguire operazioni appropriate
Si può controllare il numero massimo di Si può controllare il numero massimo di thread attivi che possono processare I/O thread attivi che possono processare I/O Completion Packet (eventuali altre richieste Completion Packet (eventuali altre richieste concorrenti sospendono il thread richiedente concorrenti sospendono il thread richiedente fino a che uno dei thread in esecuzione non fino a che uno dei thread in esecuzione non completa l’elaborazione del Completion completa l’elaborazione del Completion Packet prelevato)Packet prelevato)
Scatter-Gather I/OScatter-Gather I/O Meccanismo ad alte prestazioni per Meccanismo ad alte prestazioni per
lettura/scrittura dati su filelettura/scrittura dati su file Disponibile su NT4.0 SP2 e successiviDisponibile su NT4.0 SP2 e successivi Usato da SQL ServerUsato da SQL Server Legge/scrive dati presenti in zone non Legge/scrive dati presenti in zone non
contigue di memoria su zone di file contigue di memoria su zone di file contigue, sfruttando il DMAcontigue, sfruttando il DMA
Granularità di pagina (4K / 8K)Granularità di pagina (4K / 8K) Funzioni API:Funzioni API:
ReadFileScatter(…)ReadFileScatter(…) WriteFileGather(…)WriteFileGather(…)
Change NotificationChange Notification
Oggetto kernel utilizzabile in funzioni Oggetto kernel utilizzabile in funzioni di Wait per monitorare il cambiamento di Wait per monitorare il cambiamento del contenuto di una directorydel contenuto di una directory FindFirstChangeNotification(…)FindFirstChangeNotification(…) FindNextChangeNotification(…)FindNextChangeNotification(…) FindCloseChangeNotification(…)FindCloseChangeNotification(…)
Nota bene: non si usa CloseHandle(…) Nota bene: non si usa CloseHandle(…) per la chiusura dell’handle ottenuto per la chiusura dell’handle ottenuto con FindFirstChangeNotification(…)con FindFirstChangeNotification(…)
I/O ManagerI/O Manager
Architettura I/O ManagerArchitettura I/O Manager Elaborazione sincrona dell’I/OElaborazione sincrona dell’I/O Elaborazione asincrona dell’I/OElaborazione asincrona dell’I/O I/O Completion RoutineI/O Completion Routine I/O Completion PortI/O Completion Port Change NotificationChange Notification
RiferimentiRiferimenti
http://msdn.microsoft.comhttp://msdn.microsoft.com
http://www.sysinternals.comhttp://www.sysinternals.com
Altre InformazioniAltre Informazioni
Dove posso ottenere maggiori Dove posso ottenere maggiori informazioniinformazioni www.sysinternals.comwww.sysinternals.com www.microsoft.com/msdn/italy/studentiwww.microsoft.com/msdn/italy/studenti www.ugidotnet.orgwww.ugidotnet.org
Developer resourcesDeveloper resources Microsoft Developer NetworkMicrosoft Developer Network
Windows internals Windows internals
I vostri feedback sono importantiI vostri feedback sono importantiCompilate il modulo di valutazioneCompilate il modulo di valutazione
Grazie della partecipazione– [email protected]