s3: piddir creation fix part 2.
[ira/wip.git] / 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 3 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, see <http://www.gnu.org/licenses/>.
26 */
27
28
29 #include "tdb_private.h"
30
31 /* check for an out of bounds access - if it is out of bounds then
32    see if the database has been expanded by someone else and expand
33    if necessary 
34 */
35 static int tdb_oob(struct tdb_context *tdb, tdb_off_t off, tdb_len_t len,
36                    int probe)
37 {
38         struct stat st;
39         if (len + off < len) {
40                 if (!probe) {
41                         /* Ensure ecode is set for log fn. */
42                         tdb->ecode = TDB_ERR_IO;
43                         TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_oob off %d len %d wrap\n",
44                                  (int)off, (int)len));
45                 }
46                 return -1;
47         }
48
49         if (off + len <= tdb->map_size)
50                 return 0;
51         if (tdb->flags & TDB_INTERNAL) {
52                 if (!probe) {
53                         /* Ensure ecode is set for log fn. */
54                         tdb->ecode = TDB_ERR_IO;
55                         TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_oob len %u beyond internal malloc size %u\n",
56                                  (int)(off + len), (int)tdb->map_size));
57                 }
58                 return -1;
59         }
60
61         if (fstat(tdb->fd, &st) == -1) {
62                 tdb->ecode = TDB_ERR_IO;
63                 return -1;
64         }
65
66         if (st.st_size < (size_t)off + len) {
67                 if (!probe) {
68                         /* Ensure ecode is set for log fn. */
69                         tdb->ecode = TDB_ERR_IO;
70                         TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_oob len %u beyond eof at %u\n",
71                                  (int)(off + len), (int)st.st_size));
72                 }
73                 return -1;
74         }
75
76         /* Beware >4G files! */
77         if ((tdb_off_t)st.st_size != st.st_size) {
78                 /* Ensure ecode is set for log fn. */
79                 tdb->ecode = TDB_ERR_IO;
80                 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_oob len %llu too large!\n",
81                          (long long)st.st_size));
82                 return -1;
83         }
84
85         /* Unmap, update size, remap */
86         if (tdb_munmap(tdb) == -1) {
87                 tdb->ecode = TDB_ERR_IO;
88                 return -1;
89         }
90         tdb->map_size = st.st_size;
91         tdb_mmap(tdb);
92         return 0;
93 }
94
95 /* write a lump of data at a specified offset */
96 static int tdb_write(struct tdb_context *tdb, tdb_off_t off, 
97                      const void *buf, tdb_len_t len)
98 {
99         if (len == 0) {
100                 return 0;
101         }
102
103         if (tdb->read_only || tdb->traverse_read) {
104                 tdb->ecode = TDB_ERR_RDONLY;
105                 return -1;
106         }
107
108         if (tdb->methods->tdb_oob(tdb, off, len, 0) != 0)
109                 return -1;
110
111         if (tdb->map_ptr) {
112                 memcpy(off + (char *)tdb->map_ptr, buf, len);
113         } else {
114                 ssize_t written = pwrite(tdb->fd, buf, len, off);
115                 if ((written != (ssize_t)len) && (written != -1)) {
116                         /* try once more */
117                         tdb->ecode = TDB_ERR_IO;
118                         TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_write: wrote only "
119                                  "%d of %d bytes at %d, trying once more\n",
120                                  (int)written, len, off));
121                         written = pwrite(tdb->fd, (const char *)buf+written,
122                                          len-written,
123                                          off+written);
124                 }
125                 if (written == -1) {
126                         /* Ensure ecode is set for log fn. */
127                         tdb->ecode = TDB_ERR_IO;
128                         TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_write failed at %d "
129                                  "len=%d (%s)\n", off, len, strerror(errno)));
130                         return -1;
131                 } else if (written != (ssize_t)len) {
132                         tdb->ecode = TDB_ERR_IO;
133                         TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_write: failed to "
134                                  "write %d bytes at %d in two attempts\n",
135                                  len, off));
136                         return -1;
137                 }
138         }
139         return 0;
140 }
141
142 /* Endian conversion: we only ever deal with 4 byte quantities */
143 void *tdb_convert(void *buf, uint32_t size)
144 {
145         uint32_t i, *p = (uint32_t *)buf;
146         for (i = 0; i < size / 4; i++)
147                 p[i] = TDB_BYTEREV(p[i]);
148         return buf;
149 }
150
151
152 /* read a lump of data at a specified offset, maybe convert */
153 static int tdb_read(struct tdb_context *tdb, tdb_off_t off, void *buf, 
154                     tdb_len_t len, int cv)
155 {
156         if (tdb->methods->tdb_oob(tdb, off, len, 0) != 0) {
157                 return -1;
158         }
159
160         if (tdb->map_ptr) {
161                 memcpy(buf, off + (char *)tdb->map_ptr, len);
162         } else {
163                 ssize_t ret = pread(tdb->fd, buf, len, off);
164                 if (ret != (ssize_t)len) {
165                         /* Ensure ecode is set for log fn. */
166                         tdb->ecode = TDB_ERR_IO;
167                         TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_read failed at %d "
168                                  "len=%d ret=%d (%s) map_size=%d\n",
169                                  (int)off, (int)len, (int)ret, strerror(errno),
170                                  (int)tdb->map_size));
171                         return -1;
172                 }
173         }
174         if (cv) {
175                 tdb_convert(buf, len);
176         }
177         return 0;
178 }
179
180
181
182 /*
183   do an unlocked scan of the hash table heads to find the next non-zero head. The value
184   will then be confirmed with the lock held
185 */              
186 static void tdb_next_hash_chain(struct tdb_context *tdb, uint32_t *chain)
187 {
188         uint32_t h = *chain;
189         if (tdb->map_ptr) {
190                 for (;h < tdb->header.hash_size;h++) {
191                         if (0 != *(uint32_t *)(TDB_HASH_TOP(h) + (unsigned char *)tdb->map_ptr)) {
192                                 break;
193                         }
194                 }
195         } else {
196                 uint32_t off=0;
197                 for (;h < tdb->header.hash_size;h++) {
198                         if (tdb_ofs_read(tdb, TDB_HASH_TOP(h), &off) != 0 || off != 0) {
199                                 break;
200                         }
201                 }
202         }
203         (*chain) = h;
204 }
205
206
207 int tdb_munmap(struct tdb_context *tdb)
208 {
209         if (tdb->flags & TDB_INTERNAL)
210                 return 0;
211
212 #ifdef HAVE_MMAP
213         if (tdb->map_ptr) {
214                 int ret;
215
216                 ret = munmap(tdb->map_ptr, tdb->map_size);
217                 if (ret != 0)
218                         return ret;
219         }
220 #endif
221         tdb->map_ptr = NULL;
222         return 0;
223 }
224
225 void tdb_mmap(struct tdb_context *tdb)
226 {
227         if (tdb->flags & TDB_INTERNAL)
228                 return;
229
230 #ifdef HAVE_MMAP
231         if (!(tdb->flags & TDB_NOMMAP)) {
232                 tdb->map_ptr = mmap(NULL, tdb->map_size, 
233                                     PROT_READ|(tdb->read_only? 0:PROT_WRITE), 
234                                     MAP_SHARED|MAP_FILE, tdb->fd, 0);
235
236                 /*
237                  * NB. When mmap fails it returns MAP_FAILED *NOT* NULL !!!!
238                  */
239
240                 if (tdb->map_ptr == MAP_FAILED) {
241                         tdb->map_ptr = NULL;
242                         TDB_LOG((tdb, TDB_DEBUG_WARNING, "tdb_mmap failed for size %d (%s)\n", 
243                                  tdb->map_size, strerror(errno)));
244                 }
245         } else {
246                 tdb->map_ptr = NULL;
247         }
248 #else
249         tdb->map_ptr = NULL;
250 #endif
251 }
252
253 /* expand a file.  we prefer to use ftruncate, as that is what posix
254   says to use for mmap expansion */
255 static int tdb_expand_file(struct tdb_context *tdb, tdb_off_t size, tdb_off_t addition)
256 {
257         char buf[8192];
258
259         if (tdb->read_only || tdb->traverse_read) {
260                 tdb->ecode = TDB_ERR_RDONLY;
261                 return -1;
262         }
263
264         if (ftruncate(tdb->fd, size+addition) == -1) {
265                 char b = 0;
266                 ssize_t written = pwrite(tdb->fd,  &b, 1, (size+addition) - 1);
267                 if (written == 0) {
268                         /* try once more, potentially revealing errno */
269                         written = pwrite(tdb->fd,  &b, 1, (size+addition) - 1);
270                 }
271                 if (written == 0) {
272                         /* again - give up, guessing errno */
273                         errno = ENOSPC;
274                 }
275                 if (written != 1) {
276                         TDB_LOG((tdb, TDB_DEBUG_FATAL, "expand_file to %d failed (%s)\n", 
277                                  size+addition, strerror(errno)));
278                         return -1;
279                 }
280         }
281
282         /* now fill the file with something. This ensures that the
283            file isn't sparse, which would be very bad if we ran out of
284            disk. This must be done with write, not via mmap */
285         memset(buf, TDB_PAD_BYTE, sizeof(buf));
286         while (addition) {
287                 size_t n = addition>sizeof(buf)?sizeof(buf):addition;
288                 ssize_t written = pwrite(tdb->fd, buf, n, size);
289                 if (written == 0) {
290                         /* prevent infinite loops: try _once_ more */
291                         written = pwrite(tdb->fd, buf, n, size);
292                 }
293                 if (written == 0) {
294                         /* give up, trying to provide a useful errno */
295                         TDB_LOG((tdb, TDB_DEBUG_FATAL, "expand_file write "
296                                 "returned 0 twice: giving up!\n"));
297                         errno = ENOSPC;
298                         return -1;
299                 } else if (written == -1) {
300                         TDB_LOG((tdb, TDB_DEBUG_FATAL, "expand_file write of "
301                                  "%d bytes failed (%s)\n", (int)n,
302                                  strerror(errno)));
303                         return -1;
304                 } else if (written != n) {
305                         TDB_LOG((tdb, TDB_DEBUG_WARNING, "expand_file: wrote "
306                                  "only %d of %d bytes - retrying\n", (int)written,
307                                  (int)n));
308                 }
309                 addition -= written;
310                 size += written;
311         }
312         return 0;
313 }
314
315
316 /* You need 'size', this tells you how much you should expand by. */
317 tdb_off_t tdb_expand_adjust(tdb_off_t map_size, tdb_off_t size, int page_size)
318 {
319         tdb_off_t new_size, top_size;
320
321         /* limit size in order to avoid using up huge amounts of memory for
322          * in memory tdbs if an oddball huge record creeps in */
323         if (size > 100 * 1024) {
324                 top_size = map_size + size * 2;
325         } else {
326                 top_size = map_size + size * 100;
327         }
328
329         /* always make room for at least top_size more records, and at
330            least 25% more space. if the DB is smaller than 100MiB,
331            otherwise grow it by 10% only. */
332         if (map_size > 100 * 1024 * 1024) {
333                 new_size = map_size * 1.10;
334         } else {
335                 new_size = map_size * 1.25;
336         }
337
338         /* Round the database up to a multiple of the page size */
339         new_size = MAX(top_size, new_size);
340         return TDB_ALIGN(new_size, page_size) - map_size;
341 }
342
343 /* expand the database at least size bytes by expanding the underlying
344    file and doing the mmap again if necessary */
345 int tdb_expand(struct tdb_context *tdb, tdb_off_t size)
346 {
347         struct tdb_record rec;
348         tdb_off_t offset;
349
350         if (tdb_lock(tdb, -1, F_WRLCK) == -1) {
351                 TDB_LOG((tdb, TDB_DEBUG_ERROR, "lock failed in tdb_expand\n"));
352                 return -1;
353         }
354
355         /* must know about any previous expansions by another process */
356         tdb->methods->tdb_oob(tdb, tdb->map_size, 1, 1);
357
358         size = tdb_expand_adjust(tdb->map_size, size, tdb->page_size);
359
360         if (!(tdb->flags & TDB_INTERNAL))
361                 tdb_munmap(tdb);
362
363         /*
364          * We must ensure the file is unmapped before doing this
365          * to ensure consistency with systems like OpenBSD where
366          * writes and mmaps are not consistent.
367          */
368
369         /* expand the file itself */
370         if (!(tdb->flags & TDB_INTERNAL)) {
371                 if (tdb->methods->tdb_expand_file(tdb, tdb->map_size, size) != 0)
372                         goto fail;
373         }
374
375         tdb->map_size += size;
376
377         if (tdb->flags & TDB_INTERNAL) {
378                 char *new_map_ptr = (char *)realloc(tdb->map_ptr,
379                                                     tdb->map_size);
380                 if (!new_map_ptr) {
381                         tdb->map_size -= size;
382                         goto fail;
383                 }
384                 tdb->map_ptr = new_map_ptr;
385         } else {
386                 /*
387                  * We must ensure the file is remapped before adding the space
388                  * to ensure consistency with systems like OpenBSD where
389                  * writes and mmaps are not consistent.
390                  */
391
392                 /* We're ok if the mmap fails as we'll fallback to read/write */
393                 tdb_mmap(tdb);
394         }
395
396         /* form a new freelist record */
397         memset(&rec,'\0',sizeof(rec));
398         rec.rec_len = size - sizeof(rec);
399
400         /* link it into the free list */
401         offset = tdb->map_size - size;
402         if (tdb_free(tdb, offset, &rec) == -1)
403                 goto fail;
404
405         tdb_unlock(tdb, -1, F_WRLCK);
406         return 0;
407  fail:
408         tdb_unlock(tdb, -1, F_WRLCK);
409         return -1;
410 }
411
412 /* read/write a tdb_off_t */
413 int tdb_ofs_read(struct tdb_context *tdb, tdb_off_t offset, tdb_off_t *d)
414 {
415         return tdb->methods->tdb_read(tdb, offset, (char*)d, sizeof(*d), DOCONV());
416 }
417
418 int tdb_ofs_write(struct tdb_context *tdb, tdb_off_t offset, tdb_off_t *d)
419 {
420         tdb_off_t off = *d;
421         return tdb->methods->tdb_write(tdb, offset, CONVERT(off), sizeof(*d));
422 }
423
424
425 /* read a lump of data, allocating the space for it */
426 unsigned char *tdb_alloc_read(struct tdb_context *tdb, tdb_off_t offset, tdb_len_t len)
427 {
428         unsigned char *buf;
429
430         /* some systems don't like zero length malloc */
431
432         if (!(buf = (unsigned char *)malloc(len ? len : 1))) {
433                 /* Ensure ecode is set for log fn. */
434                 tdb->ecode = TDB_ERR_OOM;
435                 TDB_LOG((tdb, TDB_DEBUG_ERROR,"tdb_alloc_read malloc failed len=%d (%s)\n",
436                            len, strerror(errno)));
437                 return NULL;
438         }
439         if (tdb->methods->tdb_read(tdb, offset, buf, len, 0) == -1) {
440                 SAFE_FREE(buf);
441                 return NULL;
442         }
443         return buf;
444 }
445
446 /* Give a piece of tdb data to a parser */
447
448 int tdb_parse_data(struct tdb_context *tdb, TDB_DATA key,
449                    tdb_off_t offset, tdb_len_t len,
450                    int (*parser)(TDB_DATA key, TDB_DATA data,
451                                  void *private_data),
452                    void *private_data)
453 {
454         TDB_DATA data;
455         int result;
456
457         data.dsize = len;
458
459         if ((tdb->transaction == NULL) && (tdb->map_ptr != NULL)) {
460                 /*
461                  * Optimize by avoiding the malloc/memcpy/free, point the
462                  * parser directly at the mmap area.
463                  */
464                 if (tdb->methods->tdb_oob(tdb, offset, len, 0) != 0) {
465                         return -1;
466                 }
467                 data.dptr = offset + (unsigned char *)tdb->map_ptr;
468                 return parser(key, data, private_data);
469         }
470
471         if (!(data.dptr = tdb_alloc_read(tdb, offset, len))) {
472                 return -1;
473         }
474
475         result = parser(key, data, private_data);
476         free(data.dptr);
477         return result;
478 }
479
480 /* read/write a record */
481 int tdb_rec_read(struct tdb_context *tdb, tdb_off_t offset, struct tdb_record *rec)
482 {
483         if (tdb->methods->tdb_read(tdb, offset, rec, sizeof(*rec),DOCONV()) == -1)
484                 return -1;
485         if (TDB_BAD_MAGIC(rec)) {
486                 /* Ensure ecode is set for log fn. */
487                 tdb->ecode = TDB_ERR_CORRUPT;
488                 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_rec_read bad magic 0x%x at offset=%d\n", rec->magic, offset));
489                 return -1;
490         }
491         return tdb->methods->tdb_oob(tdb, rec->next, sizeof(*rec), 0);
492 }
493
494 int tdb_rec_write(struct tdb_context *tdb, tdb_off_t offset, struct tdb_record *rec)
495 {
496         struct tdb_record r = *rec;
497         return tdb->methods->tdb_write(tdb, offset, CONVERT(r), sizeof(r));
498 }
499
500 static const struct tdb_methods io_methods = {
501         tdb_read,
502         tdb_write,
503         tdb_next_hash_chain,
504         tdb_oob,
505         tdb_expand_file,
506 };
507
508 /*
509   initialise the default methods table
510 */
511 void tdb_io_init(struct tdb_context *tdb)
512 {
513         tdb->methods = &io_methods;
514 }