aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/bucket.c17
-rw-r--r--src/debug.c137
-rw-r--r--src/falloc.c18
-rw-r--r--src/findkey.c12
-rw-r--r--src/gdbmdefs.h14
-rw-r--r--src/gdbmopen.c8
-rw-r--r--src/gdbmstore.c10
-rw-r--r--src/lex.l2
-rw-r--r--src/update.c12
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;
diff --git a/src/lex.l b/src/lex.l
index eff2ec7..0318031 100644
--- a/src/lex.l
+++ b/src/lex.l
@@ -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);

Return to:

Send suggestions and report system problems to the System administrator.