Convert mmap()s to smart pointers #32532

Activity

1. gabrielschulhof

   self-assigned this

   on Mar 28, 2020
2. gabrielschulhof commented on Mar 29, 2020

   

   gabrielschulhof

   on Mar 29, 2020

   ContributorAuthor

   More actions

   @jasnell said

   Alternatively, it may be a bit cleaner to use a custom smart pointer with a deleter for these...

   e.g. bit more verbose...

     struct Mmap {
       void* mem = nullptr;
       size_t size = 0;
       Mmap(void* start, size_t size, int prot, int flags) {
         mem = mmap(start, size, prot, flags, -1, 0);
       }
     };
     struct MmapDeleter {
       void operator()(Mmap* ptr) const noexcept {
         if (ptr.mem != nullptr &&
             ptr.mem != MAP_FAILED &&
             munmap(ptr.mem, ptr.size) == -1)
           PrintSystemError(errno); 
       }
     };
     using MmapPointer = std::unique_ptr<Mmap, MmapDeleter>;

   then...

     MmapPointer nmem;
     MmapPointer tmem;
   
     // ...
     size_t size = r.to - r.from; 
   
     // ...
     nmem = std::make_unique(nullptr, size,
                             PROT_READ | PROT_WRITE,
                             MAP_PRIVATE | MAP_ANONYMOUS);
     if (nmem.mem == MAP_FAILED)
       goto fail;
   
     // ...
     tmem = std::make_unique(start, size,
                             PROT_READ | PROT_WRITE,
                             MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED);
     if (tmem.mem == MAP_FAILED)
       goto fail;
3. gabrielschulhof commented on Mar 29, 2020

   

   gabrielschulhof

   on Mar 29, 2020

   ContributorAuthor

   More actions

   @jasnell @addaleax IINM it would introduce an additional level of indirection to go with std::unique_ptr, because the structure Mmap would have to be heap-allocated and then the void* would be stored within that.

   👍React with 👍1Reacted by Anna Henningsen
4. gabrielschulhof commented on Mar 29, 2020

   

   gabrielschulhof

   on Mar 29, 2020

   ContributorAuthor

   More actions

   AFAICT std::unique_ptr is good for pointer types that can be freed with FreeThisPointerType(PointerType* ptr); If an additional argument needs to be given to the deleter then that argument, along with the pointer, must be stored in a structure, which becomes heap-allocated if we use std::unique_ptr.

   👍React with 👍1Reacted by Anna Henningsen
5. addaleax commented on Mar 29, 2020

   

   addaleax

   on Mar 29, 2020

   Member

   More actions

   @gabrielschulhof Right, I think this is sometime the Mmap (or let’s be verbose and call it MemoryMapping) class can take of itself in its constructor/destructor. std::unique_ptr or friends don’t really seem to make sense here to me either.

   👍React with 👍1Reacted by Gabriel Schulhof
6. gabrielschulhof commented on Mar 29, 2020

   

   gabrielschulhof

   on Mar 29, 2020

   ContributorAuthor

   More actions

   That's what I was thinking too. A simple class which, in its constructor performs mmap(2) and its destructor performs munmap(2).

   👍React with 👍1Reacted by Anna Henningsen
7. jasnell commented on Mar 30, 2020

   

   jasnell

   on Mar 30, 2020

   Member

   More actions

   That works for me
8. gabrielschulhof

   closed this as completedin a50745eon Apr 6, 2020
9. BethGriggs

   added a commit that references this issue on Apr 7, 2020

   src: munmap(2) upon class instance destructor

   ...

   af6cbf5
10. targos

    added a commit that references this issue on Apr 12, 2020

    src: munmap(2) upon class instance destructor

    ...

    d779980
11. targos

    added 2 commits that reference this issue on Apr 25, 2020

    src: munmap(2) upon class instance destructor

    ...

    4277375

    src: munmap(2) upon class instance destructor

    ...

    9a010a3
12. sjarmak

    added a commit that references this issue on Jul 27, 2026

    src: munmap(2) upon class instance destructor

    ...

    a50745e