Programmazione di Sistema

Transcript

1 Programmazione di Sistema Massimo Bernaschi Istituto per le Applicazioni del Calcolo Mauro Picone Consiglio Nazionale delle Ricerche Viale Manzoni, Rome - Italy m.bernaschi@iac.cnr.it

2 Libreria C: Allocazione dinamica della memoria #include <stdlib.h> void *calloc(size_t nmemb, size_t size); /* heap */ void *malloc(size_t size); /* heap */ void *realloc(void *ptr, size_t size); /* heap */ void *alloca(size_t size); /* stack */ void free(void *ptr); Unix: char *strdup(const char *s); /* call malloc */ void *sbrk(ptrdiff_t increment); /* incremento */ 2

3 Errori comuni Non controllare il valore di ritorno delle funzioni di allocazione; non allocare spazio per il carattere di terminazione (NULL) di una stringa; char *p; int len=strlen("abcd"); p=malloc(len); strcpy(p,"abcd"); chiamare la malloc passando come argomento zero; chiamare free più di una volta sullo stesso puntatore; chiamare free su un area di memoria che non era stata allocata da malloc, calloc, realloc, strdup; accedere un area di memoria dopo che è stata liberata; non liberare la memoria non più utilizzata (memory leak); 3

4 Informazioni Aggiuntive Quando è invocata con un NULL pointer realloc si comporta come malloc; il secondo argomento di realloc è il nuovo formato della regione, non la differenza tra il vecchio ed il nuovo formato; se viene inclusa stdlib.h, non è necessario applicare un cast esplicito al puntatore ritornato dalle funzioni XXalloc; 4

5 Risorse Variabili d ambiente speciali (come MALLOC CHECK); Può assumere i valori 0, 1, 2. Su alcuni sistemi (quelli derivati da SVR4) sono disponibili delle funzioni (i.e., mallinfo o mallopt) per ottenere informazioni statistiche o fare il tuning del meccanismo di gestione della memoria dinamica; Electric Fence (un debugger per la malloc). in una frase: usare nella fase di link dell applicazione la libefence.a; man libefence per ottenere informazioni aggiuntive. 5

6 Gestione della memoria dinamica La maggior parte delle implementazioni allocano dello spazio aggiuntivo oltre a quello richiesto per tenere informazioni come la dimensione del blocco allocato; un puntatore al successivo blocco allocato. Scrivere oltre la fine di un blocco allocato significa sovrascrivere queste informazioni. Le conseguenze (in genere nefaste...) diventano a volte visibili solo a grande distanza (in termini di tempo di esecuzione o di zona di programma) dal punto in cui è avvenuta la sovrascrittura. 6

7 Gestione della memoria in Win32 7

8 Gestione della memoria in Win32 Ogni processo in Win32 ha uno spazio di indirizzamento virtuale di 4GB. Win32 rende disponibile almeno uno spazio di 2GB per il processo; il resto dello spazio di indirizzamento virtuale è allocato per dati e codice condivisi, codici di sistema, drivers...; per esplorare la struttura della memoria: VOID GetSystemInfo(LPSYSTEM_INFO lpsysteminfo) La struttura LPSYSTEM INFO contiene informazioni quali la dimensione delle pagine di memoria ed i limiti di indirizzamento del processo. 8

9 typedef struct _SYSTEM_INFO { union { DWORD dwoemid; struct { WORD wprocessorarchitecture; WORD wreserved; }; }; DWORD dwpagesize; LPVOID lpminimumapplicationaddress; LPVOID lpmaximumapplicationaddress; DWORD_PTR dwactiveprocessormask; DWORD dwnumberofprocessors; DWORD dwprocessortype; DWORD dwallocationgranularity; WORD wprocessorlevel; WORD wprocessorrevision; } SYSTEM_INFO; 9

10 Gestione della memoria in Win32 Win32 mantiene pool di memoria negli heap. Un processo può utilizzare più heap ma, nella maggior parte dei casi, è sufficiente uno solo. se viene utilizzato un solo heap è possibile utilizzare direttamente le funzioni della libreria C (malloc, free,...); in questo caso non vengono però generate da parte di Win32 le eccezioni. Gli heap sono oggetti nel senso Win32. Sono quindi gestiti tramite handle. 10

11 Ogni processo ha un handle di default che può essere ottenuto tramite la HANDLE GetProcessHeap(VOID) Notare che il fallimento è indicato da un valore di ritorno NULL. 11

12 Heap multipli in Win32 Un nuovo heap viene creato con la primitiva: HANDLE HeapCreate( DWORD floptions, SIZE_T dwinitialsize, SIZE_T dwmaximumsize); SIZE T è definito come un unsigned int a 32 o 64 bit a seconda di quale flag di compilazione viene usato ( WIN32 o WIN64). Il campo floptions determina, ad esempio, se deve essere generata un eccezione nel caso di fallimento di un operazione di allocazione (HEAP GENERATE EXCEPTIONS) I due campi dwinitialsize e dwmaximumsize determinano rispettivamente la dimensione iniziale e quella massima che è 12

13 possibile allocare nel nuovo heap. Se il campo dwmaximumsize è messo a 0 non c è limitazione alla dimensione allocabile (a meno di limiti di sistema quali la dimensione totale dello spazio di indirizzamento). Un heap può essere rimosso dalla funzione: BOOL HeapDestroy(HANDLE hheap); Distruggere un heap è una maniera veloce di liberare strutture dati senza attraversarle (nel caso fossero, ad esempio, delle liste). 13

14 Gestione dell heap È possibile ottenere blocchi di memoria da un certo heap per mezzo della funzione: LPVOID HeapAlloc{HANDLE hheap, DWORD dwflags, SIZE_T dwbytes)} Oltre ai flag visti in precedenza è possibile utilizzare il flag HAVE ZERO MEMORY per inizializzare la memoria allocata a zero. La dimensione del blocco per heap nongrowable è limitata a 0x7FFF8 bytes. Per liberare un blocco: BOOL HeapFree(HANDLE hheap, DWORD dwflags, LPVOID lpmem) Per cambiare la dimensione di un blocco: LPVOID HeapReAlloc(HANDLE hheap, DWORD dwflags, LPVOID lpmem, SIZE_T dwbytes) 14

15 Il flag aggiuntivo interessante è: HAVE REALLOC IT PLACE ONLY. È possibile conoscere la dimensione di un blocco allocato con: DWORD HeapSize (HANDLE hheap, DWORD dwflags, LPCVOID lpmem) Le eccezioni generate dal sistema di gestione della memoria sono STATUS NO MEMORY e STATUS ACCESS VIOLATION. Altre funzioni di gestione dell heap: HeapCompact, HeapValidate, HeapWalk. Quest ultima, in particolare, enumera i blocchi in un heap. esempio: programma sortbt 15

16 File mappati in memoria in Win32 Il primo passo è creare un file mapping object: HANDLE CreateFileMapping( HANDLE hfile, LPSECURITY_ATTRIBUTES lpsa, DWORD fdwprotect, DWORD dwmaximumsizehigh, DWORD dwmaximumsizelow, LPCTSTR lpszmapname) l handle INVALID HANDLE VALUE (0xFFFFFFFF) è utilizzato per far riferimento allo spazio di paginazione, soprattutto per la comunicazione tra processi senza creare un file separato. L oggetto mappato non può crescere, ma può essere specificata una dimensione più grande di quella del file che in questo modo cresce automaticamente. 16

17 Il nome lpszmapname è case-sensitive (è possibile usare NULL se non si vuole condividere memoria) un flag importante è PAGE_WRITECOPY. Il valore di ritorno in caso di errore è NULL. È possibile ottenere un handle su un file mapping esistente con la funzione: HANDLE OpenFileMapping( DWORD dwdesideredaccess, BOOL binherithandle, LPCTSTR lpszmapname) Nel caso in cui si voglia condividere memoria utilizzando il file mapping: Il primo processo crea il mapping con un certo nome 17

18 I successivi processi aprono il mapping con lo stesso nome (la OpenFileMapping fallisce se l oggetto con il nome dato non esiste). La CloseHandle distrugge gli handle creati in entrambi i casi Il passo successivo per l utilizzo dei file mappati in memoria è allocare una porzione dello spazio di indirizzamento del processo. Dal punto di vista del programmatore questa allocazione è simile a HeapAlloc: LPVOID MapViewOfFile ( HANDLE hmapobject, DWORD fdwaccess, DWORD dwoffsethigh, DWORD dwoffsetlow, SIZE_T cbmap) 18

19 Viene ritornato un puntatore al blocco (o file view) l offset può essere 0 ma, in caso contrario, deve essere un multiplo di 64K. cbmap è la dimensione, in byte, della regione mappata. Il valore 0 indica l intero file al momento della chiamata. La funzione MapViewOfFileEx è simile ma è necessario specificare l indirizzo di memoria iniziale della porzione di spazio di indirizzamento da utilizzare. La funzione BOOL UnMapViewOfFile(LPVOID lpbaseaddress) rilascia la porzione di spazio di indirizzamento allocata. La funzione FlushViewOfFile forza il sistema a scrivere le pagine modificate (dirty) a disco. Normalmente non è una buona idea accedere un file attraverso il 19

20 mapping in memoria e le primitive di I/O tradizionale (ReadFile, WriteFile). esempio: programma Asc2UnMM.c (chaptr06). La sequenza standard richiesta dal file mapping può essere riassunta come segue: 1. Si apre il file (è necessario avere accesso almeno GENERIC READ) 2. Se il file è nuovo si definisce la lunghezza (ad esempio con la SetFilePointer) 3. Si mappa il file con la CreateFileMapping o OpenFileMapping 4. Si crea una view con MapViewOfFile 5. Si accede il file attraverso dei riferimenti in memoria. 20

21 Condivisione di memoria 21

22 Memory Mapped I/O in UNIX #include <unistd.h> #include <sys/mman.h> void *mmap(void *start, size_t length, int prot, int flags, int fd, off_t offset); int munmap(void *start, size_t length); int msync(const void *start, size_t length, int flags); Una regione mappata in memoria è ereditata dal processo figlio dopo una fork Una regione mappata in memoria NON è ereditata dal nuovo programma dopo un exec 22

23 Memory Mapped I/O Lo pseudo file /dev/zero è una sorgente infinita in lettura di bytes a 0. Più processi possono condividere questa regione se un comune antenato specifica il flag MAP SHARED nella chiamata alla funzione mmap. Il flag MAP PRIVATE rende invece le modifiche private al processo (in qualche modo equivalente al PAGE WRITECOPY sotto Windows). Sui sistemi BSD esiste invece il concetto di anonymous memory mapping che permette di specificare -1 come file descriptor se viene utilizzato (ed è supportato) il flag MAP ANON. 23

24 Spazio di indirizzamento in Unix/Linux 24

25 Dynamic Link Libraries (DLL) in Win32 Un esempio di utilizzo del file mapping in Win32 è dato dalle Dynamic Link Libraries (DLL). Le librerie di funzioni usate da un programma possono essere statiche o dinamiche Nel caso di librerie statiche, la dimensione del programma eseguibile cresce considerevolmente maggiore occupazione di spazio disco; maggiore occupazione di memoria durante l esecuzione. Le librerie dinamiche evitano questo problema: le funzioni della libreria non sono incluse nel programma durante la fase di link. Sono invece incluse al caricamento per l esecuzione (implicit linking) o direttamente in esecuzione 25

26 (explicit linking). Le librerie dinamiche possono essere utilizzate in forma condivisa (shared libraries): più programmi condividono una singola DLL e solo una copia è caricata in memoria; tutti i programmi includono il codice della DLL nel proprio spazio di indirizzamento; nuove versioni/implementazioni possono essere utilizzate semplicemente modificando la DLL senza richiedere modifiche/compilazioni ai singoli programmi. La DLL in esecuzione utilizza lo stack del thread chiamante. L intera Win32 API è supportata tramite una DLL. Il concetto di shared library è presente anche in Unix/Linux. Le DLL dovrebbero sempre essere scritte in modo da essere thread-safe. 26

27 Implicit linking in Win32: La procedura di costruzione dipende dal compilatore. Una funzione che è parte di una DLL deve essere dichiarata esportabile. Ad esempio con il Microsoft C o MinGW si utilizza la speciale keyword declspec (dllexport) _declspec (dllexport) DWORD MyFunction(...); Viene quindi creato un file.dll ed uno.lib. Quest ultimo è quello da utilizzare nella fase di linking. Il programma chiamante dichiara che la funzione deve essere importata usando declspec (dllimport). Queste dichiarazioni non sono necessarie sotto Unix/Linux. In fase di esecuzione il file.dll deve essere disponibile al programma chiamante. È possibile esportare/importare sia funzioni che variabili. 27

28 Explicit linking in Win32: Un programma può richiedere che una specifica DLL venga caricata con la funzione HINSTANCE LoadLibrary(LPCTSTR lpfilename); In caso di fallimento viene ritornato NULL. Possono essere caricati sia DLL che file eseguibili.exe. Per rimuovere la libreria: BOOL FreeLibrary(HINSTANCE hinstlib); questa funziona libera le risorse allocate dal chiamante ma la DLL rimane caricata se altri processi la stanno utilizzando (reference count > 0). 28

29 Per ottenere l indirizzo di un qualsiasi entry point: FARPROC GetProcAddress( HMODULE hinstlib LPCSTR lpprocname); i tipi HMODULE e HINSTANCE coincidono. Notare l anacronistico tipo del valore di ritorno (FARPROC) esempio: programma atouel.c in chaptr06. In una DLL può essere specificato un entry point speciale che viene invocato ogni volta che un processo carica o rimuove (implicitamente o esplicitamente) la DLL: BOOL WINAPI DllMain( HINSTANCE hinstdll, DWORD fdwreason, LPVOID lpvreserved); Il sistema serializza l accesso alla funzione definita da DllMain. 29

30 Librerie dinamiche in Unix/Linux #include <dlfcn.h> void* dlopen(const char* path, int mode); Ritorna un handle da utilizzare nelle successive chiamate a: #include <dlfcn.h> void *dlsym(void *handle, const char *symbol); mode può assumere vari valori (in OR tra di loro): RLTD_LAZY, RTLD_NOW, RTLD_GLOBAL, RTLD_LOCAL, etc.. 30