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