apt-pkg/contrib/mmap.cc

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