apt-pkg/contrib/mmap.cc

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