diff options
Diffstat (limited to 'src')
-rw-r--r-- | src/bucket.c | 17 | ||||
-rw-r--r-- | src/debug.c | 137 | ||||
-rw-r--r-- | src/falloc.c | 18 | ||||
-rw-r--r-- | src/findkey.c | 12 | ||||
-rw-r--r-- | src/gdbmdefs.h | 14 | ||||
-rw-r--r-- | src/gdbmopen.c | 8 | ||||
-rw-r--r-- | src/gdbmstore.c | 10 | ||||
-rw-r--r-- | src/lex.l | 2 | ||||
-rw-r--r-- | src/update.c | 12 |
9 files changed, 26 insertions, 204 deletions
diff --git a/src/bucket.c b/src/bucket.c index c75db42..2289594 100644 --- a/src/bucket.c +++ b/src/bucket.c @@ -103,46 +103,44 @@ _gdbm_get_bucket (GDBM_FILE dbf, int dir_index) { if (dbf->bucket_cache[index].ca_adr == bucket_adr) { dbf->bucket = dbf->bucket_cache[index].ca_bucket; dbf->cache_entry = &dbf->bucket_cache[index]; return 0; } } /* It is not in the cache, read it from the disk. */ /* Position the file pointer */ - file_pos = GDBM_DEBUG_OVERRIDE ("_gdbm_get_bucket:seek-failure", - __lseek (dbf, bucket_adr, SEEK_SET)); + file_pos = __lseek (dbf, bucket_adr, SEEK_SET); if (file_pos != bucket_adr) { GDBM_SET_ERRNO (dbf, GDBM_FILE_SEEK_ERROR, TRUE); _gdbm_fatal (dbf, _("lseek error")); return -1; } /* Flush and drop the last recently used cache entry */ lru = (dbf->last_read + 1) % dbf->cache_size; if (dbf->bucket_cache[lru].ca_changed) { if (_gdbm_write_bucket (dbf, &dbf->bucket_cache[lru])) return -1; } _gdbm_cache_entry_invalidate (dbf, lru); /* Read the bucket. */ - rc = GDBM_DEBUG_OVERRIDE ("_gdbm_get_bucket:read-failure", - _gdbm_full_read (dbf, dbf->bucket_cache[lru].ca_bucket, - dbf->header->bucket_size)); + rc = _gdbm_full_read (dbf, dbf->bucket_cache[lru].ca_bucket, + dbf->header->bucket_size); if (rc) { GDBM_DEBUG (GDBM_DEBUG_ERR, "%s: error reading bucket: %s", dbf->name, gdbm_db_strerror (dbf)); dbf->need_recovery = TRUE; _gdbm_fatal (dbf, gdbm_db_strerror (dbf)); return -1; } /* Validate the bucket */ bucket = dbf->bucket_cache[lru].ca_bucket; if (!(bucket->count >= 0 && bucket->count <= dbf->header->bucket_elems)) @@ -293,26 +291,25 @@ _gdbm_split_bucket (GDBM_FILE dbf, int next_insert) if (dbf->header->dir_bits == dbf->bucket->bucket_bits) { if (dbf->header->dir_size >= GDBM_MAX_DIR_HALF) { GDBM_SET_ERRNO (dbf, GDBM_DIR_OVERFLOW, TRUE); _gdbm_fatal (dbf, _("directory overflow")); return -1; } dir_size = dbf->header->dir_size * 2; dir_adr = _gdbm_alloc (dbf, dir_size); if (dir_adr == 0) return -1; - new_dir = GDBM_DEBUG_ALLOC ("_gdbm_split_bucket:malloc-failure", - malloc (dir_size)); + new_dir = malloc (dir_size); if (new_dir == NULL) { GDBM_SET_ERRNO (dbf, GDBM_MALLOC_ERROR, TRUE); _gdbm_fatal (dbf, _("malloc error")); return -1; } for (index = 0; index < GDBM_DIR_COUNT (dbf); index++) { new_dir[2*index] = dbf->dir[index]; new_dir[2*index+1] = dbf->dir[index]; } @@ -426,34 +423,32 @@ _gdbm_split_bucket (GDBM_FILE dbf, int next_insert) } /* The only place where a bucket is written. CA_ENTRY is the cache entry containing the bucket to be written. */ int _gdbm_write_bucket (GDBM_FILE dbf, cache_elem *ca_entry) { int rc; off_t file_pos; /* The return value for lseek. */ - file_pos = GDBM_DEBUG_OVERRIDE ("_gdbm_write_bucket:seek-failure", - __lseek (dbf, ca_entry->ca_adr, SEEK_SET)); + file_pos = __lseek (dbf, ca_entry->ca_adr, SEEK_SET); if (file_pos != ca_entry->ca_adr) { GDBM_SET_ERRNO (dbf, GDBM_FILE_SEEK_ERROR, TRUE); _gdbm_fatal (dbf, _("lseek error")); return -1; } - rc = GDBM_DEBUG_OVERRIDE ("_gdbm_write_bucket:write-failure", - _gdbm_full_write (dbf, ca_entry->ca_bucket, dbf->header->bucket_size)); + rc = _gdbm_full_write (dbf, ca_entry->ca_bucket, dbf->header->bucket_size); if (rc) { GDBM_DEBUG (GDBM_DEBUG_STORE|GDBM_DEBUG_ERR, "%s: error writing bucket: %s", dbf->name, gdbm_db_strerror (dbf)); _gdbm_fatal (dbf, gdbm_strerror (rc)); return -1; } ca_entry->ca_changed = FALSE; ca_entry->ca_data.hash_val = -1; ca_entry->ca_data.elem_loc = -1; diff --git a/src/debug.c b/src/debug.c index 00f568c..08957ed 100644 --- a/src/debug.c +++ b/src/debug.c @@ -127,149 +127,12 @@ gdbm_debug_datum (datum dat, char const *pfx) gdbm_debug_printer ("size=%d\n", size); off = 0; while (size) { size_t rd = datbuf_format (vbuf, buf, size); gdbm_debug_printer ("%s%04x: %s\n", pfx, off, vbuf); size -= rd; buf += rd; off += rd; } } - -struct hook_list -{ - struct hook_list *next; - struct hook_list *prev; - char *id; - gdbm_debug_hook hook; - void *data; - int retval; -}; - -static struct hook_list *hook_head, *hook_tail; -static struct hook_list *hook_recent; - -static struct hook_list * -hook_lookup_or_install (char const *id, int install) -{ - struct hook_list *p; - - for (p = hook_head; p; p = p->next) - { - int res = strcmp (p->id, id); - if (res == 0) - return p; - if (res > 0) - break; - } - - if (install) - { - struct hook_list *elt = malloc (sizeof *elt); - if (!elt) - return NULL; - elt->id = strdup (id); - if (!elt->id) - { - SAVE_ERRNO (free (elt)); - return NULL; - } - elt->hook = NULL; - elt->next = p; - if (p) - { - if (p->prev) - p->prev->next = elt; - else - hook_head = elt; - elt->prev = p->prev; - } - else - { - elt->prev = hook_tail; - if (hook_tail) - hook_tail->next = elt; - else - hook_head = elt; - hook_tail = elt; - } - return elt; - } - - return NULL; -} - -static struct hook_list * -hook_lookup (char const *id) -{ - if (!(hook_recent && strcmp (hook_recent->id, id) == 0)) - hook_recent = hook_lookup_or_install (id, FALSE); - return hook_recent; -} - -static void -hook_remove (char const *id) -{ - struct hook_list *p; - - p = hook_lookup (id); - if (!p) - return; - - hook_recent = NULL; - - if (p->prev) - p->prev->next = p->next; - else - hook_head = p->next; - - if (p->next) - p->next->prev = p->prev; - else - hook_tail = p->prev; - - free (p->id); - free (p); -} - -static int -default_hook (char const *file, int line, char const *id, void *data) -{ - fprintf (stderr, "%s:%d: hit debug hook %s\n", file, line, id); - return 1; -} - -void -_gdbm_debug_hook_install (char const *id, gdbm_debug_hook hook, void *data) -{ - struct hook_list *p; - - p = hook_lookup_or_install (id, TRUE); - p->hook = hook ? hook : default_hook; - p->data = data; -} - -void -_gdbm_debug_hook_remove (char const *id) -{ - hook_remove (id); -} - -int -_gdbm_debug_hook_check (char const *file, int line, char const *id) -{ - struct hook_list *p = hook_lookup (id); - if (p) - return p->retval = p->hook (file, line, id, p->data); - return 0; -} - -int -_gdbm_debug_hook_val (char const *id) -{ - struct hook_list *p = hook_lookup (id); - if (p) - return p->retval; - return 0; -} diff --git a/src/falloc.c b/src/falloc.c index c3bd145..13ee0ed 100644 --- a/src/falloc.c +++ b/src/falloc.c @@ -173,46 +173,43 @@ pop_avail_block (GDBM_FILE dbf) /* We're kind of stuck here, so we re-split the header in order to avoid crashing. Sigh. */ if (push_avail_block (dbf)) return -1; } /* Set up variables. */ new_el.av_adr = dbf->header->avail.next_block; new_el.av_size = ( ( (dbf->header->avail.size * sizeof (avail_elem)) >> 1) + sizeof (avail_block)); /* Allocate space for the block. */ - new_blk = GDBM_DEBUG_ALLOC ("pop_avail_block:malloc-failure", - malloc (new_el.av_size)); + new_blk = malloc (new_el.av_size); if (new_blk == NULL) { GDBM_SET_ERRNO (dbf, GDBM_MALLOC_ERROR, TRUE); _gdbm_fatal (dbf, _("malloc failed")); return -1; } /* Read the block. */ - file_pos = GDBM_DEBUG_OVERRIDE ("pop_avail_block:lseek-failure", - __lseek (dbf, new_el.av_adr, SEEK_SET)); + file_pos = __lseek (dbf, new_el.av_adr, SEEK_SET); if (file_pos != new_el.av_adr) { GDBM_SET_ERRNO (dbf, GDBM_FILE_SEEK_ERROR, TRUE); free (new_blk); _gdbm_fatal (dbf, _("lseek error")); return -1; } - rc = GDBM_DEBUG_OVERRIDE ("pop_avail_block:read-failure", - _gdbm_full_read (dbf, new_blk, new_el.av_size)); + rc = _gdbm_full_read (dbf, new_blk, new_el.av_size); if (rc) { free (new_blk); _gdbm_fatal (dbf, gdbm_db_strerror (dbf)); return -1; } if (gdbm_avail_block_validate (dbf, new_blk)) { free (new_blk); _gdbm_fatal (dbf, gdbm_db_strerror (dbf)); return -1; @@ -286,26 +283,25 @@ push_avail_block (GDBM_FILE dbf) /* Caclulate the size of the split block. */ av_size = ( (dbf->header->avail.size * sizeof (avail_elem)) >> 1) + sizeof (avail_block); /* Get address in file for new av_size bytes. */ new_loc = get_elem (av_size, dbf->header->avail.av_table, &dbf->header->avail.count); if (new_loc.av_size == 0) new_loc = get_block (av_size, dbf); av_adr = new_loc.av_adr; /* Split the header block. */ - temp = GDBM_DEBUG_ALLOC ("push_avail_block:malloc-failure", - malloc (av_size)); + temp = malloc (av_size); if (temp == NULL) { GDBM_SET_ERRNO (dbf, GDBM_MALLOC_ERROR, TRUE); _gdbm_fatal (dbf, _("malloc error")); return -1; } /* Set the size to be correct AFTER the pop_avail_block. */ temp->size = dbf->header->avail.size; temp->count = 0; temp->next_block = dbf->header->avail.next_block; dbf->header->avail.next_block = av_adr; @@ -316,35 +312,33 @@ push_avail_block (GDBM_FILE dbf) dbf->header->avail.av_table[index>>1] = dbf->header->avail.av_table[index]; /* Update the header avail count to previous size divided by 2. */ dbf->header->avail.count >>= 1; /* Free the unneeded space. */ new_loc.av_adr += av_size; new_loc.av_size -= av_size; _gdbm_free (dbf, new_loc.av_adr, new_loc.av_size); /* Update the disk. */ - file_pos = GDBM_DEBUG_OVERRIDE ("push_avail_block:lseek-failure", - __lseek (dbf, av_adr, SEEK_SET)); + file_pos = __lseek (dbf, av_adr, SEEK_SET); if (file_pos != av_adr) { GDBM_SET_ERRNO (dbf, GDBM_FILE_SEEK_ERROR, TRUE); _gdbm_fatal (dbf, _("lseek error")); return -1; } - rc = GDBM_DEBUG_OVERRIDE ("push_avail_block:write-failure", - _gdbm_full_write (dbf, temp, av_size)); + rc = _gdbm_full_write (dbf, temp, av_size); if (rc) { GDBM_DEBUG (GDBM_DEBUG_STORE|GDBM_DEBUG_ERR, "%s: error writing avail data: %s", dbf->name, gdbm_db_strerror (dbf)); _gdbm_fatal (dbf, gdbm_db_strerror (dbf)); return -1; } free (temp); return 0; diff --git a/src/findkey.c b/src/findkey.c index bd9fd83..9bb4553 100644 --- a/src/findkey.c +++ b/src/findkey.c @@ -62,50 +62,46 @@ _gdbm_read_entry (GDBM_FILE dbf, int elem_loc) /* Set sizes and pointers. */ key_size = dbf->bucket->h_table[elem_loc].key_size; data_size = dbf->bucket->h_table[elem_loc].data_size; data_ca = &dbf->cache_entry->ca_data; /* Set up the cache. */ if (data_ca->dptr != NULL) free (data_ca->dptr); data_ca->key_size = key_size; data_ca->data_size = data_size; data_ca->elem_loc = elem_loc; data_ca->hash_val = dbf->bucket->h_table[elem_loc].hash_value; - if (GDBM_DEBUG_HOOK ("_gdbm_read_entry:malloc-failure")) - data_ca->dptr = NULL; - else if (key_size + data_size == 0) + if (key_size + data_size == 0) data_ca->dptr = (char *) malloc (1); else data_ca->dptr = (char *) malloc (key_size + data_size); if (data_ca->dptr == NULL) { GDBM_SET_ERRNO2 (dbf, GDBM_MALLOC_ERROR, FALSE, GDBM_DEBUG_LOOKUP); _gdbm_fatal (dbf, _("malloc error")); return NULL; } /* Read into the cache. */ - file_pos = GDBM_DEBUG_OVERRIDE ("_gdbm_read_entry:lseek-failure", - __lseek (dbf, dbf->bucket->h_table[elem_loc].data_pointer, - SEEK_SET)); + file_pos = __lseek (dbf, dbf->bucket->h_table[elem_loc].data_pointer, + SEEK_SET); if (file_pos != dbf->bucket->h_table[elem_loc].data_pointer) { GDBM_SET_ERRNO2 (dbf, GDBM_FILE_SEEK_ERROR, TRUE, GDBM_DEBUG_LOOKUP); _gdbm_fatal (dbf, _("lseek error")); return NULL; } - rc = GDBM_DEBUG_OVERRIDE ("_gdbm_read_entry:read-failure", - _gdbm_full_read (dbf, data_ca->dptr, key_size+data_size)); + rc = _gdbm_full_read (dbf, data_ca->dptr, key_size+data_size); if (rc) { GDBM_DEBUG (GDBM_DEBUG_ERR|GDBM_DEBUG_LOOKUP|GDBM_DEBUG_READ, "%s: error reading entry: %s", dbf->name, gdbm_db_strerror (dbf)); dbf->need_recovery = TRUE; _gdbm_fatal (dbf, gdbm_db_strerror (dbf)); return NULL; } return data_ca->dptr; } diff --git a/src/gdbmdefs.h b/src/gdbmdefs.h index d940c5d..4ae646f 100644 --- a/src/gdbmdefs.h +++ b/src/gdbmdefs.h @@ -316,37 +316,23 @@ struct gdbm_file_info } \ while (0) # define GDBM_SET_ERRNO2(dbf, ec, fatal, m) \ do \ { \ GDBM_DEBUG((m) | GDBM_DEBUG_ERR, "%s: error " #ec "%s", \ ((dbf) ? ((GDBM_FILE)dbf)->name : "<nodbf>"), \ ((fatal) ? " (needs recovery)" : "")); \ gdbm_set_errno(dbf, ec, fatal); \ } \ while (0) - -typedef int (*gdbm_debug_hook) (char const *, int, char const *, void *); -extern void _gdbm_debug_hook_install (char const *, gdbm_debug_hook, void *); -extern void _gdbm_debug_hook_remove (char const *); -extern int _gdbm_debug_hook_check (char const *, int, char const *); -extern int _gdbm_debug_hook_val (char const *); -# define GDBM_DEBUG_HOOK(id) _gdbm_debug_hook_check(__FILE__,__LINE__,id) -# define GDBM_DEBUG_OVERRIDE(id, stmt) \ - (GDBM_DEBUG_HOOK(id) ? _gdbm_debug_hook_val(id) : (stmt)) -# define GDBM_DEBUG_ALLOC(id, stmt) \ - (GDBM_DEBUG_HOOK(id) ? NULL : (stmt)) #else # define GDBM_DEBUG(flags, fmt, ...) # define GDBM_DEBUG_DATUM(flags, dat, fmt, ...) -# define GDBM_DEBUG_HOOK(id) 0 -# define GDBM_DEBUG_OVERRIDE(id, stmt) (stmt) -# define GDBM_DEBUG_ALLOC(id, stmt) (stmt) # define GDBM_SET_ERRNO2(dbf, ec, fatal, m) gdbm_set_errno (dbf, ec, fatal) #endif # define GDBM_SET_ERRNO(dbf, ec, fatal) GDBM_SET_ERRNO2 (dbf, ec, fatal, 0) /* Now define all the routines in use. */ #include "proto.h" diff --git a/src/gdbmopen.c b/src/gdbmopen.c index 9c10d3d..22e7ca6 100644 --- a/src/gdbmopen.c +++ b/src/gdbmopen.c @@ -625,38 +625,36 @@ gdbm_open (const char *file, int block_size, int flags, int mode, return gdbm_fd_open (fd, file, block_size, flags | GDBM_CLOERROR, fatal_func); } /* Initialize the bucket cache. */ int _gdbm_init_cache (GDBM_FILE dbf, size_t size) { int index; if (dbf->bucket_cache == NULL) { - dbf->bucket_cache = GDBM_DEBUG_ALLOC ("_gdbm_init_cache:malloc-failure", - calloc (size, sizeof(cache_elem))); + dbf->bucket_cache = calloc (size, sizeof(cache_elem)); if (dbf->bucket_cache == NULL) { GDBM_SET_ERRNO (dbf, GDBM_MALLOC_ERROR, TRUE); return -1; } dbf->cache_size = size; for (index = 0; index < size; index++) { - (dbf->bucket_cache[index]).ca_bucket = - GDBM_DEBUG_ALLOC ("_gdbm_init_cache:bucket-malloc-failure", - malloc (dbf->header->bucket_size)); + (dbf->bucket_cache[index]).ca_bucket = + malloc (dbf->header->bucket_size); if ((dbf->bucket_cache[index]).ca_bucket == NULL) { GDBM_SET_ERRNO (dbf, GDBM_MALLOC_ERROR, TRUE); return -1; } dbf->bucket_cache[index].ca_data.dptr = NULL; _gdbm_cache_entry_invalidate (dbf, index); } dbf->bucket = dbf->bucket_cache[0].ca_bucket; dbf->cache_entry = &dbf->bucket_cache[0]; } return 0; diff --git a/src/gdbmstore.c b/src/gdbmstore.c index 2ed1616..6b498b2 100644 --- a/src/gdbmstore.c +++ b/src/gdbmstore.c @@ -151,49 +151,45 @@ gdbm_store (GDBM_FILE dbf, datum key, datum content, int flags) dbf->bucket->h_table[elem_loc].hash_value = new_hash_val; memcpy (dbf->bucket->h_table[elem_loc].key_start, key.dptr, (SMALL < key.dsize ? SMALL : key.dsize)); } /* Update current bucket data pointer and sizes. */ dbf->bucket->h_table[elem_loc].data_pointer = file_adr; dbf->bucket->h_table[elem_loc].key_size = key.dsize; dbf->bucket->h_table[elem_loc].data_size = content.dsize; /* Write the data to the file. */ - file_pos = GDBM_DEBUG_OVERRIDE ("gdbm_store:seek-failure", - __lseek (dbf, file_adr, SEEK_SET)); + file_pos = __lseek (dbf, file_adr, SEEK_SET); if (file_pos != file_adr) { GDBM_DEBUG (GDBM_DEBUG_STORE|GDBM_DEBUG_ERR, "%s: lseek: %s", dbf->name, strerror (errno)); GDBM_SET_ERRNO2 (dbf, GDBM_FILE_SEEK_ERROR, TRUE, GDBM_DEBUG_STORE); _gdbm_fatal (dbf, _("lseek error")); return -1; } - rc = GDBM_DEBUG_OVERRIDE ("gdbm_store:write-1-failure", - _gdbm_full_write (dbf, key.dptr, key.dsize)); + rc = _gdbm_full_write (dbf, key.dptr, key.dsize); if (rc) { GDBM_DEBUG (GDBM_DEBUG_STORE|GDBM_DEBUG_ERR, "%s: error writing key: %s", dbf->name, gdbm_db_strerror (dbf)); _gdbm_fatal (dbf, gdbm_db_strerror (dbf)); return -1; } - rc = GDBM_DEBUG_OVERRIDE ("gdbm_store:write-2-failure", - _gdbm_full_write (dbf, - content.dptr, content.dsize)); + rc = _gdbm_full_write (dbf, content.dptr, content.dsize); if (rc) { GDBM_DEBUG (GDBM_DEBUG_STORE|GDBM_DEBUG_ERR, "%s: error writing content: %s", dbf->name, gdbm_db_strerror (dbf)); _gdbm_fatal (dbf, gdbm_db_strerror (dbf)); return -1; } /* Current bucket has changed. */ dbf->cache_entry->ca_changed = TRUE; dbf->bucket_changed = TRUE; @@ -112,27 +112,25 @@ input_context_push (instream_t input) cp->input = input; cp->buf = YY_CURRENT_BUFFER; cp->parent = context_tos; context_tos = cp; return 0; } void lex_trace (int n) { -#if GDBMTOOL_DEBUG yy_flex_debug = n; -#endif } int input_context_pop (void) { struct context *cp; if (!context_tos) return 1; instream_close (context_tos->input); free (context_tos->point.file); memset (&yylloc, 0, sizeof (yylloc)); diff --git a/src/update.c b/src/update.c index 63c6c95..f4b8b78 100644 --- a/src/update.c +++ b/src/update.c @@ -21,35 +21,33 @@ #include "autoconf.h" #include "gdbmdefs.h" /* This procedure writes the header back to the file described by DBF. */ static int write_header (GDBM_FILE dbf) { off_t file_pos; /* Return value for lseek. */ int rc; - file_pos = GDBM_DEBUG_OVERRIDE ("write_header:lseek-failure", - __lseek (dbf, 0L, SEEK_SET)); + file_pos = __lseek (dbf, 0L, SEEK_SET); if (file_pos != 0) { GDBM_SET_ERRNO2 (dbf, GDBM_FILE_SEEK_ERROR, TRUE, GDBM_DEBUG_STORE); _gdbm_fatal (dbf, _("lseek error")); return -1; } - rc = GDBM_DEBUG_OVERRIDE ("write_header:write-failure", - _gdbm_full_write (dbf, dbf->header, dbf->header->block_size)); + rc = _gdbm_full_write (dbf, dbf->header, dbf->header->block_size); if (rc) { GDBM_DEBUG (GDBM_DEBUG_STORE|GDBM_DEBUG_ERR, "%s: error writing header: %s", dbf->name, gdbm_db_strerror (dbf)); return -1; } /* Sync the file if fast_write is FALSE. */ if (dbf->fast_write == FALSE) __fsync (dbf); @@ -87,35 +85,33 @@ _gdbm_end_update (GDBM_FILE dbf) { if (_gdbm_write_bucket (dbf, &dbf->bucket_cache[index])) return -1; } } } dbf->second_changed = FALSE; } /* Write the directory. */ if (dbf->directory_changed) { - file_pos = GDBM_DEBUG_OVERRIDE ("_gdbm_end_update:lseek-failure", - __lseek (dbf, dbf->header->dir, SEEK_SET)); + file_pos = __lseek (dbf, dbf->header->dir, SEEK_SET); if (file_pos != dbf->header->dir) { GDBM_SET_ERRNO2 (dbf, GDBM_FILE_SEEK_ERROR, TRUE, GDBM_DEBUG_STORE); _gdbm_fatal (dbf, _("lseek error")); return -1; } - rc = GDBM_DEBUG_OVERRIDE ("_gdbm_end_update:write-dir-failure", - _gdbm_full_write (dbf, dbf->dir, dbf->header->dir_size)); + rc = _gdbm_full_write (dbf, dbf->dir, dbf->header->dir_size); if (rc) { GDBM_DEBUG (GDBM_DEBUG_STORE|GDBM_DEBUG_ERR, "%s: error writing directory: %s", dbf->name, gdbm_db_strerror (dbf)); _gdbm_fatal (dbf, gdbm_db_strerror (dbf)); return -1; } dbf->directory_changed = FALSE; if (!dbf->header_changed && dbf->fast_write == FALSE) __fsync (dbf); |