b3d1c56dc4db85816ec647420332b867095782a2
[ira/wip.git] / source / lib / tdb / common / io.c
1  /* 
2    Unix SMB/CIFS implementation.
3
4    trivial database library
5
6    Copyright (C) Andrew Tridgell              1999-2005
7    Copyright (C) Paul `Rusty' Russell              2000
8    Copyright (C) Jeremy Allison                    2000-2003
9    
10      ** NOTE! The following LGPL license applies to the tdb
11      ** library. This does NOT imply that all of Samba is released
12      ** under the LGPL
13    
14    This library is free software; you can redistribute it and/or
15    modify it under the terms of the GNU Lesser General Public
16    License as published by the Free Software Foundation; either
17    version 2 of the License, or (at your option) any later version.
18
19    This library is distributed in the hope that it will be useful,
20    but WITHOUT ANY WARRANTY; without even the implied warranty of
21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
22    Lesser General Public License for more details.
23
24    You should have received a copy of the GNU Lesser General Public
25    License along with this library; if not, write to the Free Software
26    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
27 */
28
29
30 #include "tdb_private.h"
31
32 /* check for an out of bounds access - if it is out of bounds then
33    see if the database has been expanded by someone else and expand
34    if necessary 
35    note that "len" is the minimum length needed for the db
36 */
37 static int tdb_oob(struct tdb_context *tdb, tdb_off_t len, int probe)
38 {
39         struct stat st;
40         if (len <= tdb->map_size)
41                 return 0;
42         if (tdb->flags & TDB_INTERNAL) {
43                 if (!probe) {
44                         /* Ensure ecode is set for log fn. */
45                         tdb->ecode = TDB_ERR_IO;
46                         TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_oob len %d beyond internal malloc size %d\n",
47                                  (int)len, (int)tdb->map_size));
48                 }
49                 return TDB_ERRCODE(TDB_ERR_IO, -1);
50         }
51
52         if (fstat(tdb->fd, &st) == -1) {
53                 return TDB_ERRCODE(TDB_ERR_IO, -1);
54         }
55
56         if (st.st_size < (size_t)len) {
57                 if (!probe) {
58                         /* Ensure ecode is set for log fn. */
59                         tdb->ecode = TDB_ERR_IO;
60                         TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_oob len %d beyond eof at %d\n",
61                                  (int)len, (int)st.st_size));
62                 }
63                 return TDB_ERRCODE(TDB_ERR_IO, -1);
64         }
65
66         /* Unmap, update size, remap */
67         if (tdb_munmap(tdb) == -1)
68                 return TDB_ERRCODE(TDB_ERR_IO, -1);
69         tdb->map_size = st.st_size;
70         tdb_mmap(tdb);
71         return 0;
72 }
73
74 /* write a lump of data at a specified offset */
75 static int tdb_write(struct tdb_context *tdb, tdb_off_t off, 
76                      const void *buf, tdb_len_t len)
77 {
78         if (len == 0) {
79                 return 0;
80         }
81
82         if (tdb->read_only || tdb->traverse_read) {
83                 tdb->ecode = TDB_ERR_RDONLY;
84                 return -1;
85         }
86
87         if (tdb->methods->tdb_oob(tdb, off + len, 0) != 0)
88                 return -1;
89
90         if (tdb->map_ptr) {
91                 memcpy(off + (char *)tdb->map_ptr, buf, len);
92         } else if (pwrite(tdb->fd, buf, len, off) != (ssize_t)len) {
93                 /* Ensure ecode is set for log fn. */
94                 tdb->ecode = TDB_ERR_IO;
95                 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_write failed at %d len=%d (%s)\n",
96                            off, len, strerror(errno)));
97                 return TDB_ERRCODE(TDB_ERR_IO, -1);
98         }
99         return 0;
100 }
101
102 /* Endian conversion: we only ever deal with 4 byte quantities */
103 void *tdb_convert(void *buf, u32 size)
104 {
105         u32 i, *p = (u32 *)buf;
106         for (i = 0; i < size / 4; i++)
107                 p[i] = TDB_BYTEREV(p[i]);
108         return buf;
109 }
110
111
112 /* read a lump of data at a specified offset, maybe convert */
113 static int tdb_read(struct tdb_context *tdb, tdb_off_t off, void *buf, 
114                     tdb_len_t len, int cv)
115 {
116         if (tdb->methods->tdb_oob(tdb, off + len, 0) != 0) {
117                 return -1;
118         }
119
120         if (tdb->map_ptr) {
121                 memcpy(buf, off + (char *)tdb->map_ptr, len);
122         } else {
123                 ssize_t ret = pread(tdb->fd, buf, len, off);
124                 if (ret != (ssize_t)len) {
125                         /* Ensure ecode is set for log fn. */
126                         tdb->ecode = TDB_ERR_IO;
127                         TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_read failed at %d len=%d ret=%d (%s) map_size=%d\n",
128                                  off, len, ret, strerror(errno), (int)tdb->map_size));
129                         return TDB_ERRCODE(TDB_ERR_IO, -1);
130                 }
131         }
132         if (cv) {
133                 tdb_convert(buf, len);
134         }
135         return 0;
136 }
137
138
139
140 /*
141   do an unlocked scan of the hash table heads to find the next non-zero head. The value
142   will then be confirmed with the lock held
143 */              
144 static void tdb_next_hash_chain(struct tdb_context *tdb, u32 *chain)
145 {
146         u32 h = *chain;
147         if (tdb->map_ptr) {
148                 for (;h < tdb->header.hash_size;h++) {
149                         if (0 != *(u32 *)(TDB_HASH_TOP(h) + (unsigned char *)tdb->map_ptr)) {
150                                 break;
151                         }
152                 }
153         } else {
154                 u32 off=0;
155                 for (;h < tdb->header.hash_size;h++) {
156                         if (tdb_ofs_read(tdb, TDB_HASH_TOP(h), &off) != 0 || off != 0) {
157                                 break;
158                         }
159                 }
160         }
161         (*chain) = h;
162 }
163
164
165 int tdb_munmap(struct tdb_context *tdb)
166 {
167         if (tdb->flags & TDB_INTERNAL)
168                 return 0;
169
170 #ifdef HAVE_MMAP
171         if (tdb->map_ptr) {
172                 int ret = munmap(tdb->map_ptr, tdb->map_size);
173                 if (ret != 0)
174                         return ret;
175         }
176 #endif
177         tdb->map_ptr = NULL;
178         return 0;
179 }
180
181 void tdb_mmap(struct tdb_context *tdb)
182 {
183         if (tdb->flags & TDB_INTERNAL)
184                 return;
185
186 #ifdef HAVE_MMAP
187         if (!(tdb->flags & TDB_NOMMAP)) {
188                 tdb->map_ptr = mmap(NULL, tdb->map_size, 
189                                     PROT_READ|(tdb->read_only? 0:PROT_WRITE), 
190                                     MAP_SHARED|MAP_FILE, tdb->fd, 0);
191
192                 /*
193                  * NB. When mmap fails it returns MAP_FAILED *NOT* NULL !!!!
194                  */
195
196                 if (tdb->map_ptr == MAP_FAILED) {
197                         tdb->map_ptr = NULL;
198                         TDB_LOG((tdb, TDB_DEBUG_WARNING, "tdb_mmap failed for size %d (%s)\n", 
199                                  tdb->map_size, strerror(errno)));
200                 }
201         } else {
202                 tdb->map_ptr = NULL;
203         }
204 #else
205         tdb->map_ptr = NULL;
206 #endif
207 }
208
209 /* expand a file.  we prefer to use ftruncate, as that is what posix
210   says to use for mmap expansion */
211 static int tdb_expand_file(struct tdb_context *tdb, tdb_off_t size, tdb_off_t addition)
212 {
213         char buf[1024];
214
215         if (tdb->read_only || tdb->traverse_read) {
216                 tdb->ecode = TDB_ERR_RDONLY;
217                 return -1;
218         }
219
220         if (ftruncate(tdb->fd, size+addition) == -1) {
221                 char b = 0;
222                 if (pwrite(tdb->fd,  &b, 1, (size+addition) - 1) != 1) {
223                         TDB_LOG((tdb, TDB_DEBUG_FATAL, "expand_file to %d failed (%s)\n", 
224                                  size+addition, strerror(errno)));
225                         return -1;
226                 }
227         }
228
229         /* now fill the file with something. This ensures that the
230            file isn't sparse, which would be very bad if we ran out of
231            disk. This must be done with write, not via mmap */
232         memset(buf, TDB_PAD_BYTE, sizeof(buf));
233         while (addition) {
234                 int n = addition>sizeof(buf)?sizeof(buf):addition;
235                 int ret = pwrite(tdb->fd, buf, n, size);
236                 if (ret != n) {
237                         TDB_LOG((tdb, TDB_DEBUG_FATAL, "expand_file write of %d failed (%s)\n", 
238                                    n, strerror(errno)));
239                         return -1;
240                 }
241                 addition -= n;
242                 size += n;
243         }
244         return 0;
245 }
246
247
248 /* expand the database at least size bytes by expanding the underlying
249    file and doing the mmap again if necessary */
250 int tdb_expand(struct tdb_context *tdb, tdb_off_t size)
251 {
252         struct list_struct rec;
253         tdb_off_t offset;
254
255         if (tdb_lock(tdb, -1, F_WRLCK) == -1) {
256                 TDB_LOG((tdb, TDB_DEBUG_ERROR, "lock failed in tdb_expand\n"));
257                 return -1;
258         }
259
260         /* must know about any previous expansions by another process */
261         tdb->methods->tdb_oob(tdb, tdb->map_size + 1, 1);
262
263         /* always make room for at least 10 more records, and round
264            the database up to a multiple of the page size */
265         size = TDB_ALIGN(tdb->map_size + size*10, tdb->page_size) - tdb->map_size;
266
267         if (!(tdb->flags & TDB_INTERNAL))
268                 tdb_munmap(tdb);
269
270         /*
271          * We must ensure the file is unmapped before doing this
272          * to ensure consistency with systems like OpenBSD where
273          * writes and mmaps are not consistent.
274          */
275
276         /* expand the file itself */
277         if (!(tdb->flags & TDB_INTERNAL)) {
278                 if (tdb->methods->tdb_expand_file(tdb, tdb->map_size, size) != 0)
279                         goto fail;
280         }
281
282         tdb->map_size += size;
283
284         if (tdb->flags & TDB_INTERNAL) {
285                 char *new_map_ptr = (char *)realloc(tdb->map_ptr,
286                                                     tdb->map_size);
287                 if (!new_map_ptr) {
288                         tdb->map_size -= size;
289                         goto fail;
290                 }
291                 tdb->map_ptr = new_map_ptr;
292         } else {
293                 /*
294                  * We must ensure the file is remapped before adding the space
295                  * to ensure consistency with systems like OpenBSD where
296                  * writes and mmaps are not consistent.
297                  */
298
299                 /* We're ok if the mmap fails as we'll fallback to read/write */
300                 tdb_mmap(tdb);
301         }
302
303         /* form a new freelist record */
304         memset(&rec,'\0',sizeof(rec));
305         rec.rec_len = size - sizeof(rec);
306
307         /* link it into the free list */
308         offset = tdb->map_size - size;
309         if (tdb_free(tdb, offset, &rec) == -1)
310                 goto fail;
311
312         tdb_unlock(tdb, -1, F_WRLCK);
313         return 0;
314  fail:
315         tdb_unlock(tdb, -1, F_WRLCK);
316         return -1;
317 }
318
319 /* read/write a tdb_off_t */
320 int tdb_ofs_read(struct tdb_context *tdb, tdb_off_t offset, tdb_off_t *d)
321 {
322         return tdb->methods->tdb_read(tdb, offset, (char*)d, sizeof(*d), DOCONV());
323 }
324
325 int tdb_ofs_write(struct tdb_context *tdb, tdb_off_t offset, tdb_off_t *d)
326 {
327         tdb_off_t off = *d;
328         return tdb->methods->tdb_write(tdb, offset, CONVERT(off), sizeof(*d));
329 }
330
331
332 /* read a lump of data, allocating the space for it */
333 unsigned char *tdb_alloc_read(struct tdb_context *tdb, tdb_off_t offset, tdb_len_t len)
334 {
335         unsigned char *buf;
336
337         /* some systems don't like zero length malloc */
338         if (len == 0) {
339                 len = 1;
340         }
341
342         if (!(buf = malloc(len))) {
343                 /* Ensure ecode is set for log fn. */
344                 tdb->ecode = TDB_ERR_OOM;
345                 TDB_LOG((tdb, TDB_DEBUG_ERROR,"tdb_alloc_read malloc failed len=%d (%s)\n",
346                            len, strerror(errno)));
347                 return TDB_ERRCODE(TDB_ERR_OOM, buf);
348         }
349         if (tdb->methods->tdb_read(tdb, offset, buf, len, 0) == -1) {
350                 SAFE_FREE(buf);
351                 return NULL;
352         }
353         return buf;
354 }
355
356 /* Give a piece of tdb data to a parser */
357
358 int tdb_parse_data(struct tdb_context *tdb, TDB_DATA key,
359                    tdb_off_t offset, tdb_len_t len,
360                    int (*parser)(TDB_DATA key, TDB_DATA data,
361                                  void *private_data),
362                    void *private_data)
363 {
364         TDB_DATA data;
365         int result;
366
367         data.dsize = len;
368
369         if ((tdb->transaction == NULL) && (tdb->map_ptr != NULL)) {
370                 /*
371                  * Optimize by avoiding the malloc/memcpy/free, point the
372                  * parser directly at the mmap area.
373                  */
374                 if (tdb->methods->tdb_oob(tdb, offset+len, 0) != 0) {
375                         return -1;
376                 }
377                 data.dptr = offset + (unsigned char *)tdb->map_ptr;
378                 return parser(key, data, private_data);
379         }
380
381         if (!(data.dptr = tdb_alloc_read(tdb, offset, len))) {
382                 return -1;
383         }
384
385         result = parser(key, data, private_data);
386         free(data.dptr);
387         return result;
388 }
389
390 /* read/write a record */
391 int tdb_rec_read(struct tdb_context *tdb, tdb_off_t offset, struct list_struct *rec)
392 {
393         if (tdb->methods->tdb_read(tdb, offset, rec, sizeof(*rec),DOCONV()) == -1)
394                 return -1;
395         if (TDB_BAD_MAGIC(rec)) {
396                 /* Ensure ecode is set for log fn. */
397                 tdb->ecode = TDB_ERR_CORRUPT;
398                 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_rec_read bad magic 0x%x at offset=%d\n", rec->magic, offset));
399                 return TDB_ERRCODE(TDB_ERR_CORRUPT, -1);
400         }
401         return tdb->methods->tdb_oob(tdb, rec->next+sizeof(*rec), 0);
402 }
403
404 int tdb_rec_write(struct tdb_context *tdb, tdb_off_t offset, struct list_struct *rec)
405 {
406         struct list_struct r = *rec;
407         return tdb->methods->tdb_write(tdb, offset, CONVERT(r), sizeof(r));
408 }
409
410 static const struct tdb_methods io_methods = {
411         tdb_read,
412         tdb_write,
413         tdb_next_hash_chain,
414         tdb_oob,
415         tdb_expand_file,
416         tdb_brlock
417 };
418
419 /*
420   initialise the default methods table
421 */
422 void tdb_io_init(struct tdb_context *tdb)
423 {
424         tdb->methods = &io_methods;
425 }