apt-pkg/contrib/mmap.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: mmap.cc,v 1.15 1999/04/18 06:36:36 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    The configure test notes that some OS's have broken private mmap's
  17    so on those OS's we can't use mmap. This means we have to use
  18    configure to test mmap and can't rely on the POSIX
  19    _POSIX_MAPPED_FILES test.
  20
  21    ##################################################################### */
  22                                                                         /*}}}*/
  23 // Include Files                                                        /*{{{*/
  24 #ifdef __GNUG__
  25 #pragma implementation "apt-pkg/mmap.h"
  26 #endif
  27
  28 #define _BSD_SOURCE
  29 #include <apt-pkg/mmap.h>
  30 #include <apt-pkg/error.h>
  31
  32 #include <sys/mman.h>
  33 #include <sys/stat.h>
  34 #include <unistd.h>
  35 #include <fcntl.h>
  36                                                                         /*}}}*/
  37
  38 // MMap::MMap - Constructor                                             /*{{{*/
  39 // ---------------------------------------------------------------------
  40 /* */
  41 MMap::MMap(FileFd &F,unsigned long Flags) : Flags(Flags), iSize(0),
  42                      Base(0)
  43 {
  44    if ((Flags & NoImmMap) != NoImmMap)
  45       Map(F);
  46 }
  47                                                                         /*}}}*/
  48 // MMap::MMap - Constructor                                             /*{{{*/
  49 // ---------------------------------------------------------------------
  50 /* */
  51 MMap::MMap(unsigned long Flags) : Flags(Flags), iSize(0),
  52                      Base(0)
  53 {
  54 }
  55                                                                         /*}}}*/
  56 // MMap::~MMap - Destructor                                             /*{{{*/
  57 // ---------------------------------------------------------------------
  58 /* */
  59 MMap::~MMap()
  60 {
  61    Close();
  62 }
  63                                                                         /*}}}*/
  64 // MMap::Map - Perform the mapping                                      /*{{{*/
  65 // ---------------------------------------------------------------------
  66 /* */
  67 bool MMap::Map(FileFd &Fd)
  68 {
  69    iSize = Fd.Size();
  70
  71    // Set the permissions.
  72    int Prot = PROT_READ;
  73    int Map = MAP_SHARED;
  74    if ((Flags & ReadOnly) != ReadOnly)
  75       Prot |= PROT_WRITE;
  76    if ((Flags & Public) != Public)
  77       Map = MAP_PRIVATE;
  78
  79    if (iSize == 0)
  80       return _error->Error("Can't mmap an empty file");
  81
  82    // Map it.
  83    Base = mmap(0,iSize,Prot,Map,Fd.Fd(),0);
  84    if (Base == (void *)-1)
  85       return _error->Errno("mmap","Couldn't make mmap of %u bytes",iSize);
  86
  87    return true;
  88 }
  89                                                                         /*}}}*/
  90 // MMap::Close - Close the map                                          /*{{{*/
  91 // ---------------------------------------------------------------------
  92 /* */
  93 bool MMap::Close(bool DoSync)
  94 {
  95    if ((Flags & UnMapped) == UnMapped || Base == 0 || iSize == 0)
  96       return true;
  97
  98    if (DoSync == true)
  99       Sync();
 100
 101    if (munmap((char *)Base,iSize) != 0)
 102       _error->Warning("Unable to munmap");
 103
 104    iSize = 0;
 105    return true;
 106 }
 107                                                                         /*}}}*/
 108 // MMap::Sync - Syncronize the map with the disk                        /*{{{*/
 109 // ---------------------------------------------------------------------
 110 /* This is done in syncronous mode - the docs indicate that this will
 111    not return till all IO is complete */
 112 bool MMap::Sync()
 113 {
 114    if ((Flags & UnMapped) == UnMapped)
 115       return true;
 116
 117 #ifdef _POSIX_SYNCHRONIZED_IO
 118    if ((Flags & ReadOnly) != ReadOnly)
 119       if (msync((char *)Base,iSize,MS_SYNC) != 0)
 120          return _error->Error("msync","Unable to write mmap");
 121 #endif
 122    return true;
 123 }
 124                                                                         /*}}}*/
 125 // MMap::Sync - Syncronize a section of the file to disk                /*{{{*/
 126 // ---------------------------------------------------------------------
 127 /* */
 128 bool MMap::Sync(unsigned long Start,unsigned long Stop)
 129 {
 130    if ((Flags & UnMapped) == UnMapped)
 131       return true;
 132
 133 #ifdef _POSIX_SYNCHRONIZED_IO
 134    unsigned long PSize = sysconf(_SC_PAGESIZE);
 135    if ((Flags & ReadOnly) != ReadOnly)
 136       if (msync((char *)Base+(int)(Start/PSize)*PSize,Stop - Start,MS_SYNC) != 0)
 137          return _error->Error("msync","Unable to write mmap");
 138 #endif
 139    return true;
 140 }
 141                                                                         /*}}}*/
 142
 143 // DynamicMMap::DynamicMMap - Constructor                               /*{{{*/
 144 // ---------------------------------------------------------------------
 145 /* */
 146 DynamicMMap::DynamicMMap(FileFd &F,unsigned long Flags,unsigned long WorkSpace) :
 147              MMap(F,Flags | NoImmMap), Fd(&F), WorkSpace(WorkSpace)
 148 {
 149    if (_error->PendingError() == true)
 150       return;
 151
 152    unsigned long EndOfFile = Fd->Size();
 153    Fd->Seek(WorkSpace);
 154    char C = 0;
 155    Fd->Write(&C,sizeof(C));
 156    Map(F);
 157    iSize = EndOfFile;
 158 }
 159                                                                         /*}}}*/
 160 // DynamicMMap::DynamicMMap - Constructor for a non-file backed map     /*{{{*/
 161 // ---------------------------------------------------------------------
 162 /* This is just a fancy malloc really.. */
 163 DynamicMMap::DynamicMMap(unsigned long Flags,unsigned long WorkSpace) :
 164              MMap(Flags | NoImmMap | UnMapped), Fd(0), WorkSpace(WorkSpace)
 165 {
 166    if (_error->PendingError() == true)
 167       return;
 168
 169    Base = new unsigned char[WorkSpace];
 170    iSize = 0;
 171 }
 172                                                                         /*}}}*/
 173 // DynamicMMap::~DynamicMMap - Destructor                               /*{{{*/
 174 // ---------------------------------------------------------------------
 175 /* We truncate the file to the size of the memory data set */
 176 DynamicMMap::~DynamicMMap()
 177 {
 178    if (Fd == 0)
 179    {
 180       delete [] (unsigned char *)Base;
 181       return;
 182    }
 183
 184    unsigned long EndOfFile = iSize;
 185    Sync();
 186    iSize = WorkSpace;
 187    Close(false);
 188    ftruncate(Fd->Fd(),EndOfFile);
 189    Fd->Close();
 190 }
 191                                                                         /*}}}*/
 192 // DynamicMMap::RawAllocate - Allocate a raw chunk of unaligned space   /*{{{*/
 193 // ---------------------------------------------------------------------
 194 /* This allocates a block of memory aligned to the given size */
 195 unsigned long DynamicMMap::RawAllocate(unsigned long Size,unsigned long Aln)
 196 {
 197    unsigned long Result = iSize;
 198    if (Aln != 0)
 199       Result += Aln - (iSize%Aln);
 200
 201    iSize = Result + Size;
 202
 203    // Just in case error check
 204    if (Result + Size > WorkSpace)
 205    {
 206       _error->Error("Dynamic MMap ran out of room");
 207       return 0;
 208    }
 209    return Result;
 210 }
 211                                                                         /*}}}*/
 212 // DynamicMMap::Allocate - Pooled aligned allocation                    /*{{{*/
 213 // ---------------------------------------------------------------------
 214 /* This allocates an Item of size ItemSize so that it is aligned to its
 215    size in the file. */
 216 unsigned long DynamicMMap::Allocate(unsigned long ItemSize)
 217 {
 218    // Look for a matching pool entry
 219    Pool *I;
 220    Pool *Empty = 0;
 221    for (I = Pools; I != Pools + PoolCount; I++)
 222    {
 223       if (I->ItemSize == 0)
 224          Empty = I;
 225       if (I->ItemSize == ItemSize)
 226          break;
 227    }
 228
 229    // No pool is allocated, use an unallocated one
 230    if (I == Pools + PoolCount)
 231    {
 232       // Woops, we ran out, the calling code should allocate more.
 233       if (Empty == 0)
 234       {
 235          _error->Error("Ran out of allocation pools");
 236          return 0;
 237       }
 238
 239       I = Empty;
 240       I->ItemSize = ItemSize;
 241       I->Count = 0;
 242    }
 243
 244    // Out of space, allocate some more
 245    if (I->Count == 0)
 246    {
 247       I->Count = 20*1024/ItemSize;
 248       I->Start = RawAllocate(I->Count*ItemSize,ItemSize);
 249    }
 250
 251    I->Count--;
 252    unsigned long Result = I->Start;
 253    I->Start += ItemSize;
 254    return Result/ItemSize;
 255 }
 256                                                                         /*}}}*/
 257 // DynamicMMap::WriteString - Write a string to the file                /*{{{*/
 258 // ---------------------------------------------------------------------
 259 /* Strings are not aligned to anything */
 260 unsigned long DynamicMMap::WriteString(const char *String,
 261                                        unsigned long Len)
 262 {
 263    unsigned long Result = iSize;
 264    // Just in case error check
 265    if (Result > WorkSpace)
 266    {
 267       _error->Error("Dynamic MMap ran out of room");
 268       return 0;
 269    }
 270
 271    if (Len == 0)
 272       Len = strlen(String);
 273    iSize += Len + 1;
 274    memcpy((char *)Base + Result,String,Len);
 275    ((char *)Base)[Result + Len] = 0;
 276    return Result;
 277 }
 278                                                                         /*}}}*/