Programmation Systèmes Cours 9 Memory Mapping - PDF

Description
Programmation Systèmes Cours 9 Memory Mapping Stefano Zacchiroli Laboratoire PPS, Université Paris Diderot - Paris 7 24 novembre 2011 URL

Please download to get full document.

View again

of 62
All materials on our website are shared by users. If you have any questions about copyright issues, please report us to resolve them. We are always happy to assist you.
Information
Category:

Reviews

Publish on:

Views: 44 | Pages: 62

Extension: PDF | Download: 0

Share
Transcript
Programmation Systèmes Cours 9 Memory Mapping Stefano Zacchiroli Laboratoire PPS, Université Paris Diderot - Paris 7 24 novembre 2011 URL Copyright 2011 Stefano Zacchiroli License Creative Commons Attribution-ShareAlike 3.0 Unported License Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 Outline 1 Memory mapping 2 File mapping 3 mmap memory management 4 Anonymous mapping Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 Outline 1 Memory mapping 2 File mapping 3 mmap memory management 4 Anonymous mapping Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 Virtual memory again With virtual memory management (VMM) the OS adds an indirection layer between virtual memory pages and physical memory frames. The address space of a process is made of virtual memory pages, decoupling it from direct access to physical memory. We have seen the main ingredients of VMM: 1 virtual pages, that form processes virtual address space 2 physical frames 3 the page table maps pages of the resident set to frames when a page p resident set is accessed, VMM swap it in from disk. Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 Virtual memory again (cont.) TLPI, Figure 6-2 Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 Backing store Definition (datum, backing store) In memory cache arrangements: a datum is an entry of the memory we want to access, passing through the cache the backing store is the (usually slower) memory where a datum can be retrieved from, when it cannot be found in the (usually faster) cache, i.e. when a cache miss happens On UNIX, the ultimate backing store of virtual memory pages is usually the set of non-resident pages available on disk, that have been swapped out in the past. Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 Memory mapping A UNIX memory mapping is a virtual memory area that has an extra backing store layer, which points to an external page store. Processes can manipulate their memory mappings request new mappings, resize or delete existing mappings, flush them to their backing store, etc. Alternative intuition: a memory mapping is dynamically allocated memory with peculiar read/write rules. Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 Memory mapping types Memory mappings can be of two different types, depending on the ultimate page backing store. 1 a file mapping maps a memory region to a region of a file backing store = file as long as the mapping is established, the content of the file can be read from or written to using direct memory access ( as if they were variables ) 2 an anonymous mappings maps a memory region to a fresh virtual memory area filled with 0 backing store = zero-ed memory area Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 Having memory mapped pages in common Thanks to virtual memory management, different processes can have mapped pages in common. More precisely, mapped pages in different processes can refer to physical memory pages that have the same backing store. That can happen in two ways: 1 through fork, as memory mappings are inherited by children 2 when multiple processes map the same region of a file Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 Shared vs private mappings With mapped pages in common, the involved processes might see changes performed by others to mapped pages in common, depending on whether the mapping is: private mapping in this case modifications are not visible to other processes. pages are initially the same, but modification are not shared, as it happens with copy-on-write memory after fork private mappings are also known as copy-on-write mappings shared mapping in this case modifications to mapped pages in common are visible to all involved processes i.e. pages are not copied-on-write Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 Memory mapping zoo Summarizing: memory mappings can have files or zero as backing store memory mappings can be private or shared A total of 4 different flavors of memory mappings: visibility / file mapping anon. mapping backing store private private file mapping private anon. mapping shared shared file mapping shared anon. mapping Each of them is useful for a range of different use cases. Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 mmap The mmap syscall is used to request the creation of memory mappings in the address space of the calling process: #include sys/mman.h void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset); Returns: starting address of the mapping if OK, MAP_FAILED on error The mapping specification is given by: length, that specifies the length of the desired mapping flags, that is a bit mask of flags that include MAP_PRIVATE request a private mapping MAP_SHARED request a shared mapping MAP_ANONYMOUS request an anonymous mapping MAP_ANONYMOUS anonymous mapping fd must be -1 for anonymous mappings one of MAP_PRIVATE, MAP_SHARED must be specified Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 mmap (cont.) #include sys/mman.h void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset); addr gives an address hint about where, in the process address space, the new mapping should be placed. It is just a hint and it is very seldomly used. To not provide one, pass NULL. For file mappings, the mapped file region is given by: fd: file descriptor pointing to the desired backing file offset: absolute offset pointing to the beginning of the file region that should be mapped the end is given implicitly by length to map the entire file, use offset == 0 Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 mmap (cont.) #include sys/mman.h void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset); The desired memory protection for the requested mapping must be given via prot, which is a bitwise OR of: PROT_READ PROT_WRITE PROT_EXEC PROT_NONE pages may be read pages may be write pages may be executed pages may not be accessed at all either PROT_NONE or a combination of the others must be given. Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 mmap (cont.) #include sys/mman.h void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset); The desired memory protection for the requested mapping must be given via prot, which is a bitwise OR of: PROT_READ PROT_WRITE PROT_EXEC PROT_NONE pages may be read pages may be write pages may be executed pages may not be accessed at all either PROT_NONE or a combination of the others must be given. What can PROT_NONE be used for? Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 mmap (cont.) #include sys/mman.h void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset); The desired memory protection for the requested mapping must be given via prot, which is a bitwise OR of: PROT_READ PROT_WRITE PROT_EXEC PROT_NONE pages may be read pages may be write pages may be executed pages may not be accessed at all either PROT_NONE or a combination of the others must be given. PROT_NONE use case: put memory fences around memory areas that we do not want to be trespassed inadvertently Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 mmap example #include f c n t l. h #include sys/mman. h #include sys/ stat. h #include unistd. h #include apue. h int main ( int argc, char ** argv ) { int fd ; struct stat finfo ; void *fmap ; i f ( argc!= 2) err_ quit ( Usage : mmap cat FILE ) ; i f ( ( fd = open ( argv [ 1 ], O_RDONLY) ) 0) err_sys ( open error ) ; i f ( f s t a t ( fd, &finfo ) 0) err_sys ( f s t a t error ) ; fmap = mmap( NULL, finfo. st_size, PROT_READ, MAP_PRIVATE, fd, 0 ) ; i f ( fmap == MAP_FAILED ) err_sys ( mmap error ) ; i f ( write ( STDOUT_FILENO, fmap, finfo. st_size )!= finfo. st_size ) err_sys ( write error ) ; exit ( EXIT_SUCCESS ) ; } /* end of mmap cat. c */ Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 mmap example (cont.) Demo Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 munmap The converse action of mmap unmapping is performed by munmap: #include sys/mman.h int munmap(void *addr, size_t length); Returns: 0 if OK, -1 otherwise The memory area between the addresses addr and addr+length will be unmapped as a result of munmap. Accessing it after a successful munmap will (very likely) result in a segmentation fault. Usually, an entire mapping is unmapped, e.g.: i f ( ( addr = mmap(null, length, /*... */ ) ) 0) err_sys ( mmap error ) ; /* access memory mapped region via addr */ i f (munmap( addr, length ) 0) err_sys ( munmap error ) ; Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 munmap on region (sub-)multiples munmap does not force to unmap entire regions, one by one 1 unmapping a region that contains no mapped page will have no effect and return success 2 unmapping a region that spans several mappings will unmap all contained mappings and ignore non mapped areas, as per previous point 3 unmapping only part of an existing mapping will either reduce mapping size, if the unmapped part is close to one edge of the existing mapping; or split it in two, if the unmapped part is in the middle of the existing mapping Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 Outline 1 Memory mapping 2 File mapping 3 mmap memory management 4 Anonymous mapping Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 File mappings File mapping recipe 1 fd = open(/*.. */); 2 addr = mmap(/*.. */, fd, /*.. */); Once the file mapping is established, access to the (mapped region of the) underlying file does not need to pass through fd anymore. However, the FD might still be useful for other actions that can still be performed only via FDs: changing file size file locking fsync / fdatasync... Thanks to file pervasiveness, we can use file mapping on device files e.g.: disk device files, /dev/mem,... (not all devices support it) Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 File mapping and memory layout All kinds of memory mappings are placed in the large memory area in between the heap and stack segments. The return value of mmap points to the start of the created memory mapping (i.e. its lowest address) and the mapping grows above it (i.e. towards higher addresses). For file mappings, the mapped file region starts at offset and is length bytes long. The mapped region in memory will have the same size (modulo alignment issues... ). Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 File mapping and memory layout (cont.) APUE, Figure Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 File mapping and memory protection The requested memory protection (prot, flags) must be compatible with the file descriptor permissions (O_RDONLY, etc.). FD must always be open for reading if PROT_WRITE and MAP_SHARED are given, the file must be open for writing Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 Private file mapping (#1) Effects: the content of the mapping is initialized from file by reading the corresponding file region subsequent modifications are handled via copy-on-write Use cases they are invisible to other processes they are not saved to the backing file 1 Initializing process segments from the corresponding sections of a binary executable initialization of the text segment from program instructions initialization of the data segment from binary data either way, we don t want runtime changes to be saved to disk This use case is implemented in the dynamic loader/linker and rarely needed in other programs. Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 Private file mapping (#1) Effects: the content of the mapping is initialized from file by reading the corresponding file region subsequent modifications are handled via copy-on-write they are invisible to other processes they are not saved to the backing file Use cases 2 Simplifying program input logic instead of a big loop at startup time to read input, one mmap call and you re done runtime changes won t be saved back, though Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 Private file mapping example (segment init.) A real life example can be found in: glibc s dynamic loading code. Demo Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 Private file mapping example (input logic) #include f c n t l. h #include stdio. h #include stdlib. h #include string. h #include sys/mman. h #include sys/ stat. h #include apue. h int main ( int argc, char ** argv ) { int fd ; struct stat finfo ; void *fmap ; char *match ; i f ( argc!= 3) err_ quit ( Usage : substring STRING FILE ) ; i f ( ( fd = open ( argv [ 2 ], O_RDONLY) ) 0) err_sys ( open error ) ; i f ( f s t a t ( fd, &finfo ) 0) err_sys ( f s t a t error ) ; /* input a l l f i l e at once */ fmap = mmap( NULL, finfo. st_size, PROT_READ, MAP_PRIVATE, fd, 0 ) ; match = s t r s t r ( ( char * ) fmap, argv [ 1 ] ) ; p r i n t f ( string%s found\n , match == NULL? NOT : ) ; exit ( match == NULL? EXIT_FAILURE : EXIT_SUCCESS ) ; } /* end of grep substring. c */ Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 Private file mapping example (input logic) (cont.) Demo Notes: example similar to mmap-cat.c, but here we put it into use thanks to the byte array abstraction we can easily look for a substring with strstr without risking that our target gets split in two different BUFSIZ chunks Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 Shared file mapping (#2) Effects: processes mapping the same region of a file share physical memory frames more precisely: they have virtual memory pages that map to the same physical memory frames additionally, the involved physical frames have the mapped file as ultimate backing store i.e. modifications to the (shared) physical frames are saved to the mapped file on disk Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 Shared file mapping (#2) (cont.) ProcessA pagetable Physical memory PT entries for mapped region Open file ProcessB pagetable Mapped pages I/ O managed bykernel Mapped region of file PT entries for mapped region TLPI, Figure 49-2 Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 Shared file mapping (#2) (cont.) Use cases 1 memory-mapped I/O, as an alternative to read/write as in the case of private file mapping, but here it works for both reading and writing data 2 interprocess communication, with the following characteristics: data-transfer (not byte stream) with filesystem persistence among unrelated processes Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 Memory-mapped I/O Given that: 1 memory content is initialized from file 2 changes to memory are reflected to file we can perform I/O by simply changing bytes of memory. Access to file mappings is less intuitive than sequential read/write operations the mental model is that of working on your data as a huge byte array (which is what memory is, after all) a best practice to follow is that of defining struct-s that correspond to elements stored in the mapping, and copy them around with memcpy & co Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 Memory-mapped I/O example We will redo the distributed scheme to assign global sequential unique identifiers to concurrent programs. we will use memory-mapped I/O we will do fcntl-based locking as before Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 Memory-mapped I/O example (protocol) #include f c n t l. h #include f c n t l. h #include string. h #include sys/mman. h #include sys/ stat. h #include time. h #include unistd. h #include apue. h #define DB_FILE counter. data #define MAGIC 42 #define MAGIC_SIZ sizeof (MAGIC) struct glob_id { char magic [ 3 ] ; /* magic string 42\0 */ time_t ts ; /* l a s t modification timestamp */ long val ; /* global counter value */ } ; Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 Memory-mapped I/O example (library) int glob_id_verify_magic ( int fd, struct glob_id * id ) { struct flock lock ; int rc ; lock. l_ type = F_RDLCK ; /* read lock */ lock. l_whence = SEEK_SET ; /* abs. position */ lock. l _ s t a r t = 0; /* from begin... */ lock. l_len = MAGIC_SIZ ; /*... to magic s end */ p r i n t f ( acquiring read lock... \ n ) ; i f ( f c n t l ( fd, F_SETLKW, &lock ) 0) err_sys ( f c n t l error ) ; rc = strncmp ( id magic, MAGIC, 3 ) ; lock. l_ type = F_UNLCK; p r i n t f ( releasing read lock... \ n ) ; i f ( f c n t l ( fd, F_SETLK, &lock ) 0) err_sys ( f c n t l error ) ; } return rc ; Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 Memory-mapped I/O example (library) (cont.) void glob_id_write ( struct glob_id * id, long val ) { memcpy( id magic, MAGIC, MAGIC_SIZ ) ; id ts = time (NULL ) ; id val = val ; } /* end of mmap uid common. h */ Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 Memory-mapped I/O example (DB init/reset) #include mmap uid common. h int main ( void ) { int fd ; struct stat finfo ; struct glob_id * id ; struct flock lock ; i f ( ( fd = open ( DB_FILE, O_RDWR O_CREAT O_TRUNC, S_IRUSR S_IWUSR ) ) 0) err_sys ( open error ) ; i f ( ftruncate ( fd, sizeof ( struct glob_id ) ) 0) err_sys ( ftruncate error ) ; i f ( f s t a t ( fd, &finfo ) 0) err_sys ( f s t a t error ) ; Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 Memory-mapped I/O example (DB init/reset) (cont.) id = ( struct glob_id * ) mmap(null, finfo. st_size, PROT_READ PROT_WRITE, MAP_SHARED, fd, 0 ) ; lock. l_ type = F_WRLCK; /* write lock */ lock. l_whence = SEEK_SET ; /* abs. position */ lock. l _ s t a r t = 0; /* from begin... */ lock. l_len = 0; /*... to EOF */ p r i n t f ( acquiring write lock... \ n ) ; i f ( f c n t l ( fd, F_SETLKW, &lock ) 0) err_sys ( f c n t l error ) ; glob_id_write ( id, ( long ) 0 ) ; exit ( EXIT_SUCCESS ) ; } /* end of mmap uid reset. c */ Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 Memory-mapped I/O example (client) #include mmap uid common. h int main ( void ) { int fd ; struct stat finfo ; struct glob_id * id ; struct flock lock ; i f ( ( fd = open ( DB_FILE, O_RDWR) ) 0) err_sys ( open error ) ; i f ( f s t a t ( fd, &finfo ) 0) err_sys ( f s t a t error ) ; id = ( struct glob_id * ) mmap(null, finfo. st_size, PROT_READ PROT_WRITE, MAP_SHARED, fd, 0 ) ; p r i n t f ( checking magic number... \ n ) ; i f ( glob_id_verify_magic ( fd, id ) 0) { p r i n t f ( i n v a l i d magic number: abort. \n ) ; exit ( EXIT_FAILURE ) ; } Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 Memory-mapped I/O example (client) (cont.) lock. l_ type = F_WRLCK; /* write lock */ lock. l_whence = SEEK_SET ; /* abs. position */ lock. l _ s t a r t = MAGIC_SIZ ; /* from magicno... */ lock. l_len = 0; /*... to EOF */ p r i n t f ( acquiring write lock... \ n ) ; i f ( f c n t l ( fd, F_SETLKW, &lock ) 0) err_sys ( f c n t l error ) ; p r i n t f ( got id : %ld \n , id val ) ; sleep ( 5 ) ; glob_id_write ( id, id val + 1 ) ; exit ( EXIT_SUCCESS ) ; } /* end of mmap uid get. c */ Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 Memory-mapped I/O example Notes: Demo the glob_id structure now includes the magic string TBH, there was no real reason for not having it before... as a consequence, file sizes increases a bit, due to padding for memory alignment reasons we keep the FD around to do file locking resize the file upon creation no, lseek is not enough to change file size the I/O logics is simpler Stefano Zacchiroli (Paris 7) Memory mapping 24 novembre / 56 Memory-mapped I/O example Notes: Demo the glob_id structure now includes the magic string TBH, there was no real reason for not having it before... as a consequence, file sizes incr
Related Search
We Need Your Support
Thank you for visiting our website and your interest in our free products and services. We are nonprofit website to share and download documents. To the running of this website, we need your help to support us.

Thanks to everyone for your continued support.

No, Thanks