diff options
Diffstat (limited to 'src')
-rw-r--r-- | src/bucket.c | 6 | ||||
-rw-r--r-- | src/falloc.c | 4 | ||||
-rw-r--r-- | src/findkey.c | 2 | ||||
-rw-r--r-- | src/fullio.c | 4 | ||||
-rw-r--r-- | src/gdbmclose.c | 2 | ||||
-rw-r--r-- | src/gdbmopen.c | 4 | ||||
-rw-r--r-- | src/gdbmsetopt.c | 2 | ||||
-rw-r--r-- | src/gdbmstore.c | 2 | ||||
-rw-r--r-- | src/gdbmsync.c | 2 | ||||
-rw-r--r-- | src/gdbmtool.c | 4 | ||||
-rw-r--r-- | src/proto.h | 20 | ||||
-rw-r--r-- | src/recover.c | 2 | ||||
-rw-r--r-- | src/systems.h | 16 | ||||
-rw-r--r-- | src/update.c | 8 |
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; } |