aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/bucket.c6
-rw-r--r--src/falloc.c4
-rw-r--r--src/findkey.c2
-rw-r--r--src/fullio.c4
-rw-r--r--src/gdbmclose.c2
-rw-r--r--src/gdbmopen.c4
-rw-r--r--src/gdbmsetopt.c2
-rw-r--r--src/gdbmstore.c2
-rw-r--r--src/gdbmsync.c2
-rw-r--r--src/gdbmtool.c4
-rw-r--r--src/proto.h20
-rw-r--r--src/recover.c2
-rw-r--r--src/systems.h16
-rw-r--r--src/update.c8
14 files changed, 41 insertions, 37 deletions
diff --git a/src/bucket.c b/src/bucket.c
index 2289594..e17019c 100644
--- a/src/bucket.c
+++ b/src/bucket.c
@@ -103,25 +103,25 @@ _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 = __lseek (dbf, bucket_adr, SEEK_SET);
+ file_pos = gdbm_file_seek (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]))
@@ -178,25 +178,25 @@ _gdbm_read_bucket_at (GDBM_FILE dbf, off_t off, hash_bucket *bucket,
/* Look in the cache. */
for (i = 0; i < dbf->cache_size; i++)
{
if (dbf->bucket_cache[i].ca_adr == off)
{
memcpy (bucket, dbf->bucket_cache[i].ca_bucket, size);
return 0;
}
}
/* Read the bucket. */
- file_pos = __lseek (dbf, off, SEEK_SET);
+ file_pos = gdbm_file_seek (dbf, off, SEEK_SET);
if (file_pos != off)
{
GDBM_SET_ERRNO (dbf, GDBM_FILE_SEEK_ERROR, TRUE);
return -1;
}
if (_gdbm_full_read (dbf, bucket, size))
{
GDBM_DEBUG (GDBM_DEBUG_ERR,
"%s: error reading bucket: %s",
dbf->name, gdbm_db_strerror (dbf));
return -1;
}
@@ -423,25 +423,25 @@ _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 = __lseek (dbf, ca_entry->ca_adr, SEEK_SET);
+ file_pos = gdbm_file_seek (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_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));
diff --git a/src/falloc.c b/src/falloc.c
index 13ee0ed..2f21ebe 100644
--- a/src/falloc.c
+++ b/src/falloc.c
@@ -182,25 +182,25 @@ pop_avail_block (GDBM_FILE dbf)
+ sizeof (avail_block));
/* Allocate space for the block. */
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 = __lseek (dbf, new_el.av_adr, SEEK_SET);
+ file_pos = gdbm_file_seek (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_full_read (dbf, new_blk, new_el.av_size);
if (rc)
{
free (new_blk);
@@ -312,25 +312,25 @@ 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 = __lseek (dbf, av_adr, SEEK_SET);
+ file_pos = gdbm_file_seek (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_full_write (dbf, temp, av_size);
if (rc)
{
GDBM_DEBUG (GDBM_DEBUG_STORE|GDBM_DEBUG_ERR,
"%s: error writing avail data: %s",
diff --git a/src/findkey.c b/src/findkey.c
index 9bb4553..9c8fd71 100644
--- a/src/findkey.c
+++ b/src/findkey.c
@@ -74,25 +74,25 @@ _gdbm_read_entry (GDBM_FILE dbf, int elem_loc)
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 = __lseek (dbf, dbf->bucket->h_table[elem_loc].data_pointer,
+ file_pos = gdbm_file_seek (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_full_read (dbf, data_ca->dptr, key_size+data_size);
if (rc)
{
GDBM_DEBUG (GDBM_DEBUG_ERR|GDBM_DEBUG_LOOKUP|GDBM_DEBUG_READ,
diff --git a/src/fullio.c b/src/fullio.c
index bdb51cb..84eea60 100644
--- a/src/fullio.c
+++ b/src/fullio.c
@@ -18,25 +18,25 @@
#include "gdbmdefs.h"
/* Read exactly SIZE bytes of data into BUFFER. Return value is 0 on
success, and -1 on error. In the latter case, gdbm_errno is set to
GDBM_FILE_EOF, if not enough data is available, and to
GDBM_FILE_READ_ERROR, if a read error occurs. */
int
_gdbm_full_read (GDBM_FILE dbf, void *buffer, size_t size)
{
char *ptr = buffer;
while (size)
{
- ssize_t rdbytes = __read (dbf, ptr, size);
+ ssize_t rdbytes = gdbm_file_read (dbf, ptr, size);
if (rdbytes == -1)
{
if (errno == EINTR)
continue;
if (gdbm_last_errno (dbf) == GDBM_NO_ERROR)
GDBM_SET_ERRNO (dbf, GDBM_FILE_READ_ERROR, FALSE);
return -1;
}
if (rdbytes == 0)
{
GDBM_SET_ERRNO (dbf, GDBM_FILE_EOF, FALSE);
return -1;
@@ -46,25 +46,25 @@ _gdbm_full_read (GDBM_FILE dbf, void *buffer, size_t size)
}
return 0;
}
/* Write exactly SIZE bytes of data from BUFFER tp DBF. Return 0 on
success, and -1 (setting gdbm_errno to GDBM_FILE_READ_ERROR) on error. */
int
_gdbm_full_write (GDBM_FILE dbf, void *buffer, size_t size)
{
char *ptr = buffer;
while (size)
{
- ssize_t wrbytes = __write (dbf, ptr, size);
+ ssize_t wrbytes = gdbm_file_write (dbf, ptr, size);
if (wrbytes == -1)
{
if (errno == EINTR)
continue;
if (gdbm_last_errno (dbf) == GDBM_NO_ERROR)
GDBM_SET_ERRNO (dbf, GDBM_FILE_WRITE_ERROR, TRUE);
return -1;
}
if (wrbytes == 0)
{
errno = ENOSPC;
GDBM_SET_ERRNO (dbf, GDBM_FILE_WRITE_ERROR, TRUE);
diff --git a/src/gdbmclose.c b/src/gdbmclose.c
index c638183..ead9187 100644
--- a/src/gdbmclose.c
+++ b/src/gdbmclose.c
@@ -26,25 +26,25 @@
Before freeing members of DBF, check and make sure that they were
allocated. */
void
gdbm_close (GDBM_FILE dbf)
{
int index; /* For freeing the bucket cache. */
if (dbf->desc != -1)
{
/* Make sure the database is all on disk. */
if (dbf->read_write != GDBM_READER)
- __fsync (dbf);
+ gdbm_file_sync (dbf);
/* Close the file and free all malloced memory. */
#if HAVE_MMAP
_gdbm_mapped_unmap (dbf);
#endif
if (dbf->file_locking)
_gdbm_unlock_file (dbf);
close (dbf->desc);
}
gdbm_clear_error (dbf);
diff --git a/src/gdbmopen.c b/src/gdbmopen.c
index 22e7ca6..53d62a4 100644
--- a/src/gdbmopen.c
+++ b/src/gdbmopen.c
@@ -420,25 +420,25 @@ gdbm_fd_open (int fd, const char *file_name, int block_size,
if (_gdbm_full_write (dbf, dbf->bucket, dbf->header->bucket_size))
{
GDBM_DEBUG (GDBM_DEBUG_OPEN|GDBM_DEBUG_ERR,
"%s: error writing bucket: %s",
dbf->name, gdbm_db_strerror (dbf));
if (!(flags & GDBM_CLOERROR))
dbf->desc = -1;
SAVE_ERRNO (gdbm_close (dbf));
return NULL;
}
/* Wait for initial configuration to be written to disk. */
- __fsync (dbf);
+ gdbm_file_sync (dbf);
free (dbf->bucket);
}
else
{
/* This is an old database. Read in the information from the file
header and initialize the hash directory. */
gdbm_file_header partial_header; /* For the first part of it. */
int rc;
/* Read the partial file header. */
@@ -499,25 +499,25 @@ gdbm_fd_open (int fd, const char *file_name, int block_size,
/* Allocate space for the hash table directory. */
dbf->dir = malloc (dbf->header->dir_size);
if (dbf->dir == NULL)
{
if (!(flags & GDBM_CLOERROR))
dbf->desc = -1;
gdbm_close (dbf);
GDBM_SET_ERRNO2 (NULL, GDBM_MALLOC_ERROR, FALSE, GDBM_DEBUG_OPEN);
return NULL;
}
/* Read the hash table directory. */
- file_pos = __lseek (dbf, dbf->header->dir, SEEK_SET);
+ file_pos = gdbm_file_seek (dbf, dbf->header->dir, SEEK_SET);
if (file_pos != dbf->header->dir)
{
if (!(flags & GDBM_CLOERROR))
dbf->desc = -1;
SAVE_ERRNO (gdbm_close (dbf));
GDBM_SET_ERRNO2 (NULL, GDBM_FILE_SEEK_ERROR, FALSE, GDBM_DEBUG_OPEN);
return NULL;
}
if (_gdbm_full_read (dbf, dbf->dir, dbf->header->dir_size))
{
GDBM_DEBUG (GDBM_DEBUG_ERR|GDBM_DEBUG_OPEN,
diff --git a/src/gdbmsetopt.c b/src/gdbmsetopt.c
index ca62290..69e244c 100644
--- a/src/gdbmsetopt.c
+++ b/src/gdbmsetopt.c
@@ -181,25 +181,25 @@ setopt_gdbm_getcoalesceblks (GDBM_FILE dbf, void *optval, int optlen)
#if HAVE_MMAP
static int
setopt_gdbm_setmmap (GDBM_FILE dbf, void *optval, int optlen)
{
int n;
if ((n = getbool (optval, optlen)) == -1)
{
GDBM_SET_ERRNO (dbf, GDBM_OPT_ILLEGAL, FALSE);
return -1;
}
- __fsync (dbf);
+ gdbm_file_sync (dbf);
if (n == dbf->memory_mapping)
return 0;
if (n)
{
if (_gdbm_mapped_init (dbf) == 0)
dbf->memory_mapping = TRUE;
else
return -1;
}
else
{
_gdbm_mapped_unmap (dbf);
diff --git a/src/gdbmstore.c b/src/gdbmstore.c
index 6b498b2..b8a1e66 100644
--- a/src/gdbmstore.c
+++ b/src/gdbmstore.c
@@ -151,25 +151,25 @@ 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 = __lseek (dbf, file_adr, SEEK_SET);
+ file_pos = gdbm_file_seek (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_full_write (dbf, key.dptr, key.dsize);
if (rc)
{
diff --git a/src/gdbmsync.c b/src/gdbmsync.c
index 10fbaad..5d94cbe 100644
--- a/src/gdbmsync.c
+++ b/src/gdbmsync.c
@@ -25,15 +25,15 @@
/* Make sure the database is all on disk. */
void
gdbm_sync (GDBM_FILE dbf)
{
/* Return immediately if the database needs recovery */
GDBM_ASSERT_CONSISTENCY (dbf, );
/* Initialize the gdbm_errno variable. */
gdbm_set_errno (dbf, GDBM_NO_ERROR, FALSE);
/* Do the sync on the file. */
- __fsync (dbf);
+ gdbm_file_sync (dbf);
}
diff --git a/src/gdbmtool.c b/src/gdbmtool.c
index 11b6f20..dbb7510 100644
--- a/src/gdbmtool.c
+++ b/src/gdbmtool.c
@@ -218,25 +218,25 @@ _gdbm_avail_list_size (GDBM_FILE dbf, size_t min_size)
lines = 4 + dbf->header->avail.count;
if (lines > min_size)
return lines;
/* Initialize the variables for a pass throught the avail stack. */
temp = dbf->header->avail.next_block;
size = (((dbf->header->avail.size * sizeof (avail_elem)) >> 1)
+ sizeof (avail_block));
av_stk = emalloc (size);
/* Traverse the stack. */
while (temp)
{
- if (__lseek (dbf, temp, SEEK_SET) != temp)
+ if (gdbm_file_seek (dbf, temp, SEEK_SET) != temp)
{
terror ("lseek: %s", strerror (errno));
break;
}
if (_gdbm_full_read (dbf, av_stk, size))
{
terror ("read: %s", gdbm_db_strerror (dbf));
break;
}
if (gdbm_avail_block_valid_p (av_stk))
@@ -276,25 +276,25 @@ _gdbm_print_avail_list (FILE *fp, GDBM_FILE dbf)
dbf->header->avail.size, dbf->header->avail.count);
av_table_display (dbf->header->avail.av_table, dbf->header->avail.count, fp);
/* Initialize the variables for a pass throught the avail stack. */
temp = dbf->header->avail.next_block;
size = (dbf->header->avail.size * sizeof (avail_elem))
+ sizeof (avail_block);
av_stk = emalloc (size);
/* Print the stack. */
while (temp)
{
- if (__lseek (dbf, temp, SEEK_SET) != temp)
+ if (gdbm_file_seek (dbf, temp, SEEK_SET) != temp)
{
terror ("lseek: %s", strerror (errno));
break;
}
if (_gdbm_full_read (dbf, av_stk, size))
{
terror ("read: %s", gdbm_db_strerror (dbf));
break;
}
/* Print the block! */
diff --git a/src/proto.h b/src/proto.h
index 9592f52..563505f 100644
--- a/src/proto.h
+++ b/src/proto.h
@@ -74,13 +74,33 @@ int _gdbm_base64_encode (const unsigned char *input, size_t input_len,
unsigned char **output, size_t *output_size,
size_t *outbytes);
int _gdbm_base64_decode (const unsigned char *input, size_t input_len,
unsigned char **output, size_t *output_size,
size_t *inbytes, size_t *outbytes);
int _gdbm_load (FILE *fp, GDBM_FILE *pdbf, unsigned long *line);
int _gdbm_dump (GDBM_FILE dbf, FILE *fp);
/* From recover.c */
int _gdbm_next_bucket_dir (GDBM_FILE dbf, int bucket_dir);
+/* I/O macros. */
+#if HAVE_MMAP
+# define gdbm_file_read(_dbf, _buf, _size) \
+ _gdbm_mapped_read(_dbf, _buf, _size)
+# define gdbm_file_write(_dbf, _buf, _size) \
+ _gdbm_mapped_write(_dbf, _buf, _size)
+# define gdbm_file_seek(_dbf, _off, _whn) \
+ _gdbm_mapped_lseek(_dbf, _off, _whn)
+# define gdbm_file_sync(_dbf) \
+ _gdbm_mapped_sync(_dbf)
+#else
+# define gdbm_file_read(_dbf, _buf, _size) read(_dbf->desc, _buf, _size)
+# define gdbm_file_write(_dbf, _buf, _size) write(_dbf->desc, _buf, _size)
+# define gdbm_file_seek(_dbf, _off, _whn) lseek(_dbf->desc, _off, _whn)
+# if HAVE_FSYNC
+# define gdbm_file_sync(_dbf) fsync(_dbf->desc)
+# else
+# define gdbm_file_sync(_dbf) { sync(); sync(); }
+# endif
+#endif
diff --git a/src/recover.c b/src/recover.c
index 074c76f..f6859ea 100644
--- a/src/recover.c
+++ b/src/recover.c
@@ -169,25 +169,25 @@ _gdbm_finish_transfer (GDBM_FILE dbf, GDBM_FILE new_dbf,
dbf->second_changed = new_dbf->second_changed;
free (new_dbf->name);
free (new_dbf);
#if HAVE_MMAP
/* Re-initialize mapping if required */
if (dbf->memory_mapping)
_gdbm_mapped_init (dbf);
#endif
/* Make sure the new database is all on disk. */
- __fsync (dbf);
+ gdbm_file_sync (dbf);
/* Force the right stuff for a correct bucket cache. */
dbf->cache_entry = &dbf->bucket_cache[0];
return _gdbm_get_bucket (dbf, 0);
}
int
_gdbm_next_bucket_dir (GDBM_FILE dbf, int bucket_dir)
{
int dir_count = GDBM_DIR_COUNT (dbf);
if (bucket_dir < 0 || bucket_dir >= dir_count)
bucket_dir = dir_count;
diff --git a/src/systems.h b/src/systems.h
index c678573..750aa51 100644
--- a/src/systems.h
+++ b/src/systems.h
@@ -54,29 +54,13 @@
/* Do we have ftruncate? */
#if HAVE_FTRUNCATE
# define TRUNCATE(dbf) ftruncate (dbf->desc, 0)
#else
# define TRUNCATE(dbf) close( open (dbf->name, O_RDWR|O_TRUNC, mode));
#endif
#ifndef STDERR_FILENO
# define STDERR_FILENO 2
#endif
-/* I/O macros. */
-#if HAVE_MMAP
-# define __read(_dbf, _buf, _size) _gdbm_mapped_read(_dbf, _buf, _size)
-# define __write(_dbf, _buf, _size) _gdbm_mapped_write(_dbf, _buf, _size)
-# define __lseek(_dbf, _off, _whn) _gdbm_mapped_lseek(_dbf, _off, _whn)
-# define __fsync(_dbf) _gdbm_mapped_sync(_dbf)
-#else
-# define __read(_dbf, _buf, _size) read(_dbf->desc, _buf, _size)
-# define __write(_dbf, _buf, _size) write(_dbf->desc, _buf, _size)
-# define __lseek(_dbf, _off, _whn) lseek(_dbf->desc, _off, _whn)
-# if HAVE_FSYNC
-# define __fsync(_dbf) fsync(_dbf->desc)
-# else
-# define __fsync(_dbf) { sync(); sync(); }
-# endif
-#endif
diff --git a/src/update.c b/src/update.c
index f4b8b78..e3ee717 100644
--- a/src/update.c
+++ b/src/update.c
@@ -21,45 +21,45 @@
#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 = __lseek (dbf, 0L, SEEK_SET);
+ file_pos = gdbm_file_seek (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_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);
+ gdbm_file_sync (dbf);
return 0;
}
/* After all changes have been made in memory, we now write them
all to disk. */
int
_gdbm_end_update (GDBM_FILE dbf)
{
off_t file_pos; /* Return value for lseek. */
int rc;
@@ -85,45 +85,45 @@ _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 = __lseek (dbf, dbf->header->dir, SEEK_SET);
+ file_pos = gdbm_file_seek (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_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);
+ gdbm_file_sync (dbf);
}
/* Final write of the header. */
if (dbf->header_changed)
{
if (write_header (dbf))
return -1;
dbf->header_changed = FALSE;
}
return 0;
}

Return to:

Send suggestions and report system problems to the System administrator.