Windows internals http:// [email protected] http:// [email protected].

Windows Windows internalsinternals

http://http://www.microsoft.com/italy/www.microsoft.com/italy/msdn/studentimsdn/studenti

[email protected]

http://http://www.microsoft.com/italy/www.microsoft.com/italy/msdn/studentimsdn/studenti

[email protected]

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


I/O Manager

SecurityMonitor

ObjectManager

LocalIPC


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;




Security DetailSecurity DetailSecurity ID: LEESGroup IDs: TEAM1

TEAM2LOCALINTERACTIVEWORLD

Privileges: None . . .

Security ID: LEESGroup IDs: TEAM1

TEAM2LOCALINTERACTIVEWORLD

Privileges: None . . .

SecurityDescriptor

SecurityDescriptor

AllowLEES

SynchronizeModify State

AllowLEES


AllowTEAM1

Synchronize

AllowTEAM1

Synchronize

AllowTEAM2


AllowTEAM2


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;





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);


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);


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);


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


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


CreateTimerQueueCreateTimerQueue CreateTimerQueueTimerCreateTimerQueueTimer ChangeTimerQueueTimerChangeTimerQueueTimer DeleteTimerQueueTimerDeleteTimerQueueTimer DeleteTimerQueueExDeleteTimerQueueEx


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


RegisterWaitForSingleObjectRegisterWaitForSingleObject UnregisterWaitExUnregisterWaitEx


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


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


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 );


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


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


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


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


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


I/O Manager

SecurityMonitor

ObjectManager

LocalIPC


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)



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)



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]

Date post:	03-May-2015
Category:	Documents
Upload:	lino-pieri
View:	228 times
Download:	2 times

Windows internals http:// [email protected] http:// [email protected].

Documents