apt-pkg/contrib/mmap.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: mmap.cc,v 1.22 2001/05/27 05:19:30 jgg Exp $
   4 /* ######################################################################
   5
   6    MMap Class - Provides 'real' mmap or a faked mmap using read().
   7
   8    MMap cover class.
   9
  10    Some broken versions of glibc2 (libc6) have a broken definition
  11    of mmap that accepts a char * -- all other systems (and libc5) use
  12    void *. We can't safely do anything here that would be portable, so
  13    libc6 generates warnings -- which should be errors, g++ isn't properly
  14    strict.
  15
  16    ##################################################################### */
  17                                                                         /*}}}*/
  18 // Include Files                                                        /*{{{*/
  19 #define _BSD_SOURCE
  20 #include <apt-pkg/mmap.h>
  21 #include <apt-pkg/error.h>
  22
  23 #include <apti18n.h>
  24
  25 #include <sys/mman.h>
  26 #include <sys/stat.h>
  27 #include <unistd.h>
  28 #include <fcntl.h>
  29 #include <stdlib.h>
  30 #include <errno.h>
  31
  32 #include <cstring>
  33                                                                         /*}}}*/
  34
  35 // MMap::MMap - Constructor                                             /*{{{*/
  36 // ---------------------------------------------------------------------
  37 /* */
  38 MMap::MMap(FileFd &F,unsigned long Flags) : Flags(Flags), iSize(0),
  39                      Base(0), SyncToFd(NULL)
  40 {
  41    if ((Flags & NoImmMap) != NoImmMap)
  42       Map(F);
  43 }
  44                                                                         /*}}}*/
  45 // MMap::MMap - Constructor                                             /*{{{*/
  46 // ---------------------------------------------------------------------
  47 /* */
  48 MMap::MMap(unsigned long Flags) : Flags(Flags), iSize(0),
  49                      Base(0), SyncToFd(NULL)
  50 {
  51 }
  52                                                                         /*}}}*/
  53 // MMap::~MMap - Destructor                                             /*{{{*/
  54 // ---------------------------------------------------------------------
  55 /* */
  56 MMap::~MMap()
  57 {
  58    Close();
  59 }
  60                                                                         /*}}}*/
  61 // MMap::Map - Perform the mapping                                      /*{{{*/
  62 // ---------------------------------------------------------------------
  63 /* */
  64 bool MMap::Map(FileFd &Fd)
  65 {
  66    iSize = Fd.Size();
  67
  68    // Set the permissions.
  69    int Prot = PROT_READ;
  70    int Map = MAP_SHARED;
  71    if ((Flags & ReadOnly) != ReadOnly)
  72       Prot |= PROT_WRITE;
  73    if ((Flags & Public) != Public)
  74       Map = MAP_PRIVATE;
  75
  76    if (iSize == 0)
  77       return _error->Error(_("Can't mmap an empty file"));
  78
  79    // Map it.
  80    Base = mmap(0,iSize,Prot,Map,Fd.Fd(),0);
  81    if (Base == (void *)-1)
  82    {
  83       if (errno == ENODEV || errno == EINVAL)
  84       {
  85          // The filesystem doesn't support this particular kind of mmap.
  86          // So we allocate a buffer and read the whole file into it.
  87          int const dupped_fd = dup(Fd.Fd());
  88          if (dupped_fd == -1)
  89             return _error->Errno("mmap", _("Couldn't duplicate file descriptor %i"), Fd.Fd());
  90
  91          Base = new unsigned char[iSize];
  92          SyncToFd = new FileFd (dupped_fd);
  93          if (!SyncToFd->Seek(0L) || !SyncToFd->Read(Base, iSize))
  94             return false;
  95       }
  96       else
  97          return _error->Errno("mmap",_("Couldn't make mmap of %lu bytes"),
  98                               iSize);
  99      }
 100
 101    return true;
 102 }
 103                                                                         /*}}}*/
 104 // MMap::Close - Close the map                                          /*{{{*/
 105 // ---------------------------------------------------------------------
 106 /* */
 107 bool MMap::Close(bool DoSync)
 108 {
 109    if ((Flags & UnMapped) == UnMapped || Base == 0 || iSize == 0)
 110       return true;
 111
 112    if (DoSync == true)
 113       Sync();
 114
 115    if (SyncToFd != NULL)
 116    {
 117       delete[] (char *)Base;
 118       delete SyncToFd;
 119       SyncToFd = NULL;
 120    }
 121    else
 122    {
 123       if (munmap((char *)Base, iSize) != 0)
 124          _error->WarningE("mmap", _("Unable to close mmap"));
 125    }
 126
 127    iSize = 0;
 128    Base = 0;
 129    return true;
 130 }
 131                                                                         /*}}}*/
 132 // MMap::Sync - Syncronize the map with the disk                        /*{{{*/
 133 // ---------------------------------------------------------------------
 134 /* This is done in syncronous mode - the docs indicate that this will
 135    not return till all IO is complete */
 136 bool MMap::Sync()
 137 {
 138    if ((Flags & UnMapped) == UnMapped)
 139       return true;
 140
 141 #ifdef _POSIX_SYNCHRONIZED_IO
 142    if ((Flags & ReadOnly) != ReadOnly)
 143    {
 144       if (SyncToFd != NULL)
 145       {
 146          if (!SyncToFd->Seek(0) || !SyncToFd->Write(Base, iSize))
 147             return false;
 148       }
 149       else
 150       {
 151          if (msync((char *)Base, iSize, MS_SYNC) < 0)
 152             return _error->Errno("msync", _("Unable to synchronize mmap"));
 153       }
 154    }
 155 #endif
 156    return true;
 157 }
 158                                                                         /*}}}*/
 159 // MMap::Sync - Syncronize a section of the file to disk                /*{{{*/
 160 // ---------------------------------------------------------------------
 161 /* */
 162 bool MMap::Sync(unsigned long Start,unsigned long Stop)
 163 {
 164    if ((Flags & UnMapped) == UnMapped)
 165       return true;
 166
 167 #ifdef _POSIX_SYNCHRONIZED_IO
 168    unsigned long PSize = sysconf(_SC_PAGESIZE);
 169    if ((Flags & ReadOnly) != ReadOnly)
 170    {
 171       if (SyncToFd != 0)
 172       {
 173          if (!SyncToFd->Seek(0) ||
 174              !SyncToFd->Write (((char *)Base)+Start, Stop-Start))
 175             return false;
 176       }
 177       else
 178       {
 179          if (msync((char *)Base+(int)(Start/PSize)*PSize,Stop - Start,MS_SYNC) < 0)
 180             return _error->Errno("msync", _("Unable to synchronize mmap"));
 181       }
 182    }
 183 #endif
 184    return true;
 185 }
 186                                                                         /*}}}*/
 187
 188 // DynamicMMap::DynamicMMap - Constructor                               /*{{{*/
 189 // ---------------------------------------------------------------------
 190 /* */
 191 DynamicMMap::DynamicMMap(FileFd &F,unsigned long Flags,unsigned long const &Workspace,
 192                          unsigned long const &Grow, unsigned long const &Limit) :
 193                 MMap(F,Flags | NoImmMap), Fd(&F), WorkSpace(Workspace),
 194                 GrowFactor(Grow), Limit(Limit)
 195 {
 196    if (_error->PendingError() == true)
 197       return;
 198
 199    unsigned long EndOfFile = Fd->Size();
 200    if (EndOfFile > WorkSpace)
 201       WorkSpace = EndOfFile;
 202    else if(WorkSpace > 0)
 203    {
 204       Fd->Seek(WorkSpace - 1);
 205       char C = 0;
 206       Fd->Write(&C,sizeof(C));
 207    }
 208
 209    Map(F);
 210    iSize = EndOfFile;
 211 }
 212                                                                         /*}}}*/
 213 // DynamicMMap::DynamicMMap - Constructor for a non-file backed map     /*{{{*/
 214 // ---------------------------------------------------------------------
 215 /* We try here to use mmap to reserve some space - this is much more
 216    cooler than the fallback solution to simply allocate a char array
 217    and could come in handy later than we are able to grow such an mmap */
 218 DynamicMMap::DynamicMMap(unsigned long Flags,unsigned long const &WorkSpace,
 219                          unsigned long const &Grow, unsigned long const &Limit) :
 220                 MMap(Flags | NoImmMap | UnMapped), Fd(0), WorkSpace(WorkSpace),
 221                 GrowFactor(Grow), Limit(Limit)
 222 {
 223         if (_error->PendingError() == true)
 224                 return;
 225
 226         // disable Moveable if we don't grow
 227         if (Grow == 0)
 228                 this->Flags &= ~Moveable;
 229
 230 #ifndef __linux__
 231         // kfreebsd doesn't have mremap, so we use the fallback
 232         if ((this->Flags & Moveable) == Moveable)
 233                 this->Flags |= Fallback;
 234 #endif
 235
 236 #ifdef _POSIX_MAPPED_FILES
 237         if ((this->Flags & Fallback) != Fallback) {
 238                 // Set the permissions.
 239                 int Prot = PROT_READ;
 240                 int Map = MAP_PRIVATE | MAP_ANONYMOUS;
 241                 if ((this->Flags & ReadOnly) != ReadOnly)
 242                         Prot |= PROT_WRITE;
 243                 if ((this->Flags & Public) == Public)
 244                         Map = MAP_SHARED | MAP_ANONYMOUS;
 245
 246                 // use anonymous mmap() to get the memory
 247                 Base = (unsigned char*) mmap(0, WorkSpace, Prot, Map, -1, 0);
 248
 249                 if(Base == MAP_FAILED)
 250                         _error->Errno("DynamicMMap",_("Couldn't make mmap of %lu bytes"),WorkSpace);
 251
 252                 iSize = 0;
 253                 return;
 254         }
 255 #endif
 256         // fallback to a static allocated space
 257         Base = new unsigned char[WorkSpace];
 258         memset(Base,0,WorkSpace);
 259         iSize = 0;
 260 }
 261                                                                         /*}}}*/
 262 // DynamicMMap::~DynamicMMap - Destructor                               /*{{{*/
 263 // ---------------------------------------------------------------------
 264 /* We truncate the file to the size of the memory data set */
 265 DynamicMMap::~DynamicMMap()
 266 {
 267    if (Fd == 0)
 268    {
 269 #ifdef _POSIX_MAPPED_FILES
 270       munmap(Base, WorkSpace);
 271 #else
 272       delete [] (unsigned char *)Base;
 273 #endif
 274       return;
 275    }
 276
 277    unsigned long EndOfFile = iSize;
 278    iSize = WorkSpace;
 279    Close(false);
 280    if(ftruncate(Fd->Fd(),EndOfFile) < 0)
 281       _error->Errno("ftruncate", _("Failed to truncate file"));
 282 }
 283                                                                         /*}}}*/
 284 // DynamicMMap::RawAllocate - Allocate a raw chunk of unaligned space   /*{{{*/
 285 // ---------------------------------------------------------------------
 286 /* This allocates a block of memory aligned to the given size */
 287 unsigned long DynamicMMap::RawAllocate(unsigned long Size,unsigned long Aln)
 288 {
 289    unsigned long Result = iSize;
 290    if (Aln != 0)
 291       Result += Aln - (iSize%Aln);
 292
 293    iSize = Result + Size;
 294
 295    // try to grow the buffer
 296    while(Result + Size > WorkSpace)
 297    {
 298       if(!Grow())
 299       {
 300          _error->Fatal(_("Dynamic MMap ran out of room. Please increase the size "
 301                          "of APT::Cache-Limit. Current value: %lu. (man 5 apt.conf)"), WorkSpace);
 302          return 0;
 303       }
 304    }
 305    return Result;
 306 }
 307                                                                         /*}}}*/
 308 // DynamicMMap::Allocate - Pooled aligned allocation                    /*{{{*/
 309 // ---------------------------------------------------------------------
 310 /* This allocates an Item of size ItemSize so that it is aligned to its
 311    size in the file. */
 312 unsigned long DynamicMMap::Allocate(unsigned long ItemSize)
 313 {
 314    // Look for a matching pool entry
 315    Pool *I;
 316    Pool *Empty = 0;
 317    for (I = Pools; I != Pools + PoolCount; ++I)
 318    {
 319       if (I->ItemSize == 0)
 320          Empty = I;
 321       if (I->ItemSize == ItemSize)
 322          break;
 323    }
 324    // No pool is allocated, use an unallocated one
 325    if (I == Pools + PoolCount)
 326    {
 327       // Woops, we ran out, the calling code should allocate more.
 328       if (Empty == 0)
 329       {
 330          _error->Error("Ran out of allocation pools");
 331          return 0;
 332       }
 333
 334       I = Empty;
 335       I->ItemSize = ItemSize;
 336       I->Count = 0;
 337    }
 338
 339    unsigned long Result = 0;
 340    // Out of space, allocate some more
 341    if (I->Count == 0)
 342    {
 343       const unsigned long size = 20*1024;
 344       I->Count = size/ItemSize;
 345       Pool* oldPools = Pools;
 346       Result = RawAllocate(size,ItemSize);
 347       if (Pools != oldPools)
 348          I += Pools - oldPools;
 349
 350       // Does the allocation failed ?
 351       if (Result == 0 && _error->PendingError())
 352          return 0;
 353       I->Start = Result;
 354    }
 355    else
 356       Result = I->Start;
 357
 358    I->Count--;
 359    I->Start += ItemSize;
 360    return Result/ItemSize;
 361 }
 362                                                                         /*}}}*/
 363 // DynamicMMap::WriteString - Write a string to the file                /*{{{*/
 364 // ---------------------------------------------------------------------
 365 /* Strings are not aligned to anything */
 366 unsigned long DynamicMMap::WriteString(const char *String,
 367                                        unsigned long Len)
 368 {
 369    if (Len == (unsigned long)-1)
 370       Len = strlen(String);
 371
 372    unsigned long const Result = RawAllocate(Len+1,0);
 373
 374    if (Result == 0 && _error->PendingError())
 375       return 0;
 376
 377    memcpy((char *)Base + Result,String,Len);
 378    ((char *)Base)[Result + Len] = 0;
 379    return Result;
 380 }
 381                                                                         /*}}}*/
 382 // DynamicMMap::Grow - Grow the mmap                                    /*{{{*/
 383 // ---------------------------------------------------------------------
 384 /* This method is a wrapper around different methods to (try to) grow
 385    a mmap (or our char[]-fallback). Encounterable environments:
 386    1. Moveable + !Fallback + linux -> mremap with MREMAP_MAYMOVE
 387    2. Moveable + !Fallback + !linux -> not possible (forbidden by constructor)
 388    3. Moveable + Fallback -> realloc
 389    4. !Moveable + !Fallback + linux -> mremap alone - which will fail in 99,9%
 390    5. !Moveable + !Fallback + !linux -> not possible (forbidden by constructor)
 391    6. !Moveable + Fallback -> not possible
 392    [ While Moveable and Fallback stands for the equally named flags and
 393      "linux" indicates a linux kernel instead of a freebsd kernel. ]
 394    So what you can see here is, that a MMAP which want to be growable need
 395    to be moveable to have a real chance but that this method will at least try
 396    the nearly impossible 4 to grow it before it finally give up: Never say never. */
 397 bool DynamicMMap::Grow() {
 398         if (Limit != 0 && WorkSpace >= Limit)
 399                 return _error->Error(_("Unable to increase the size of the MMap as the "
 400                                        "limit of %lu bytes is already reached."), Limit);
 401
 402         unsigned long const newSize = WorkSpace + GrowFactor;
 403
 404         if(Fd != 0) {
 405                 Fd->Seek(newSize - 1);
 406                 char C = 0;
 407                 Fd->Write(&C,sizeof(C));
 408         }
 409
 410         unsigned long const poolOffset = Pools - ((Pool*) Base);
 411
 412         if ((Flags & Fallback) != Fallback) {
 413 #if defined(_POSIX_MAPPED_FILES) && defined(__linux__)
 414    #ifdef MREMAP_MAYMOVE
 415
 416                 if ((Flags & Moveable) == Moveable)
 417                         Base = mremap(Base, WorkSpace, newSize, MREMAP_MAYMOVE);
 418                 else
 419    #endif
 420                         Base = mremap(Base, WorkSpace, newSize, 0);
 421
 422                 if(Base == MAP_FAILED)
 423                         return false;
 424 #else
 425                 return false;
 426 #endif
 427         } else {
 428                 if ((Flags & Moveable) != Moveable)
 429                         return false;
 430
 431                 Base = realloc(Base, newSize);
 432                 if (Base == NULL)
 433                         return false;
 434         }
 435
 436         Pools =(Pool*) Base + poolOffset;
 437         WorkSpace = newSize;
 438         return true;
 439 }
 440                                                                         /*}}}*/