Discussion :

[Hibou57]

Bijour,

Il existe sous Windows, une fonctionnalité standard, dont je me demande si elle existe sous Linux.

Sous Windows, on peut ouvrir un fichier en la mappant en mémoire. Vous avez toujours une handle de fichier, mais vous avez aussi un pointeur, qui vous permet d'accéder au contenu du fichier de manière transparente, à travers une plage mémoire.

Le principe est simple, il repose sur la mémoire virtuelle : comme on peut associer un espace mémoire à un espace disque, Windows permet d'affecter directement un espace mémoir à un fichier.

Au lieu de par exemple allouer 1M de RAM pour charger en mémoire un fichier de 1M, Windows ne nécéssite aucune allocation en pure perte, et associe directement l'espace mémoire au fichier.

Trés pratique pour les scan et toutes les opérations de lecture en général.... : rapidité + économie de resource.

Seulement, j'aimerais utiliser cette technique pour des applications sous Linux, mais je n'ai pas trouvé d'équivalent de cette fonction sous Linux, alors que cette fonction me parrait pourtant évidente pour tout sytème d'exploitation disposant de mémoire virtuelle.

Cette fonction existe t-elle sous Linux ? Et si oui, quel est le syscall associé à cette fonctionnalité ?

Merci, merci

[DaZumba]

mmap() ? C'est POSIX.1.

[gorgonite]

effectivement... lis ceci

http://mtodorovic.developpez.com/lin...ge=page_5#L5-3

[Hibou57]

Hello

mmap() ? C'est POSIX.1.

Oui, ça a l'air d'être ça

Merci pour la piste qui m'a permis de trouver la trace de la fonction syscall n°90 (ou 0x5A). Je ne l'aurais jamais trouvé sans ton aide, parce que je cherchais plutôt avec des noms du genre filemap, etc, etc. Je ne pensais pas à un nom comme mmap.

Alors pour apporter moi aussi ma contribution, et honnorer ta réponse, j'ajoute quelques infos que j'ai put trouver à la suite de ta piste :

Pour Linux i386 :

• mmap : syscall #90
• Rappel : les syscall sont appelés avec l'interruption 0x80 (128)
• paramètres en entrée :
  
  • eax = 90 (numéro de la fonction mmap)
  • ebx = adresse de la structure de donnée contenant les paramètres
    
    • structure pointée par ebx (6 dwords, 24 bytes)
      
      • start : dword = adresse à laquel on souhaite le chargement ou NULL pour que le système décide lui-même de l'adresse
      • length : size_t = taille de la zone de mémoire (le mieux est d'y donner la taille du fichier brut)
      • prot (protection) : int = PROT_READ ou PROT_WRITE ou PROT_EXEC
      • flags : int = MAP_SHARED ou MAP_PRIVATE ou MAP_ANONYMOUS ou MAP_FIXED
      • fd (file descriptor) : int = handle du fichier (qui doit être ouvert donc)
      • offset : off_t = adresse du premier octer à mapper
• Résultats en sortie :
  
  • eax : pointeur vers la zone de mémoire où est effectué le mapping
  • eax : code erreur = acces ou again ou badf ou inval ou nomem ou txtbusy

Note : Comme on peut donner la taille de la zone mémoire, ainsi que l'offset du premier octet du fichier à mapper, on peut mapper une section précise d'un fichier (tout comme avec l'API Windows).
Note : eax est données deux fois dans les résultat. Ce n'est pas une erreur, ou plutôt sa valeur dépend de l'echec ou du succes de l'appel. Il faut tester la valeur pour déterminer si une erreur s'est produite ou pas. Et c'est seulement si aucune erreur ne s'est produite que eax contient le pointeur vers la zone mémoire.

Je cite d'autres notes :

• MAP_ANONYMOUS maps a memory area without reference to a file.
• PROT-flags enable the rsp. mode (i.e. UN-protect!)
• PROT_NONE disables all!
• memory "protection" may not become effective as expected! re mprotect flags
• despite of manpages 'explanations', "mmap" access remains receiving it's args by ptr!
• a file cannot be extended by writing to mapped memory (SIGBUS exception).

Note: sous Windows, au contraire, on peut étendre la zone mémoire (mais je pense qu'on peut contourner cette limitation sous Linux, probablement)

Des flags sont données, mais comme toujours, si on ne connais pas la valeur numérique des flags, ça ne sert à rien. Les voici donc :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
// mmap and madvise syscalls groups flags
// --------------------------------------
 
   PROT_READ       0x1             // page can be read
   PROT_WRITE      0x2             // page can be written
   PROT_EXEC       0x4             // page can be executed
   PROT_SEM        0x8             // page may be used for atomic ops
   PROT_NONE       0x0             // page can not be accessed
   PROT_GROWSDOWN  0x01000000      // mprotect flag: extend change to start of growsdown vma
   PROT_GROWSUP    0x02000000      // mprotect flag: extend change to end of growsup vma
 
   MAP_SHARED      0x01            // Share changes
   MAP_PRIVATE     0x02            // Changes are private
   MAP_TYPE        0x0f            // Mask for type of mapping
   MAP_FIXED       0x10            // Interpret addr exactly
   MAP_ANONYMOUS   0x20            // don't use a file
 
   MAP_GROWSDOWN   0x0100          // stack-like segment
   MAP_DENYWRITE   0x0800          // ETXTBSY
   MAP_EXECUTABLE  0x1000          // mark it as an executable
   MAP_LOCKED      0x2000          // pages are locked
   MAP_NORESERVE   0x4000          // don't check for reservations
   MAP_POPULATE    0x8000          // populate (prefault) pagetables
   MAP_NONBLOCK    0x10000         // do not block on IO
 
   MS_ASYNC        1               // sync memory asynchronously
   MS_INVALIDATE   2               // invalidate the caches
   MS_SYNC         4               // synchronous memory sync
   MCL_CURRENT     1               // lock all current mappings
   MCL_FUTURE      2               // lock all future mappings
   MADV_NORMAL     0x0             // default page-in behavior
   MADV_RANDOM     0x1             // page-in minimum required
   MADV_SEQUENTIAL 0x2             // read-ahead aggressively
   MADV_WILLNEED   0x3             // pre-fault pages
   MADV_DONTNEED   0x4             // discard these pages
 
// compatibility flags
   MAP_ANON        MAP_ANONYMOUS
   MAP_FILE        0

Voilà

Note : il existe apparement un « mmap2 » (mais comme toujours, newer does not mean better)

Merci DaZumba