apt-pkg/contrib/mmap.cc

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