1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
|
/* proto.h - The prototypes for the dbm routines. */
/* This file is part of GDBM, the GNU data base manager.
Copyright (C) 1990-2023 Free Software Foundation, Inc.
GDBM is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
GDBM is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GDBM. If not, see <http://www.gnu.org/licenses/>. */
/* From bucket.c */
void _gdbm_new_bucket (GDBM_FILE, hash_bucket *, int);
int _gdbm_get_bucket (GDBM_FILE, int);
int _gdbm_split_bucket (GDBM_FILE, int);
int _gdbm_write_bucket (GDBM_FILE, cache_elem *);
int _gdbm_cache_init (GDBM_FILE, size_t);
void _gdbm_cache_free (GDBM_FILE dbf);
int _gdbm_cache_flush (GDBM_FILE dbf);
/* Mark current bucket as changed. */
static inline void
_gdbm_current_bucket_changed (GDBM_FILE dbf)
{
dbf->cache_mru->ca_changed = TRUE;
}
/* Return true if the directory entry at DIR_INDEX can be considered
valid. This means that DIR_INDEX is in the valid range for addressing
the dir array, and the offset stored in dir[DIR_INDEX] points past
first two blocks in file. This does not necessarily mean that there's
a valid bucket or data block at that offset. All this implies is that
it is safe to use the offset for look up in the bucket cache and to
attempt to read a block at that offset. */
static inline int
gdbm_dir_entry_valid_p (GDBM_FILE dbf, int dir_index)
{
return dir_index >= 0
&& dir_index < GDBM_DIR_COUNT (dbf)
&& dbf->dir[dir_index] >= dbf->header->block_size;
}
/* From falloc.c */
off_t _gdbm_alloc (GDBM_FILE, int);
int _gdbm_free (GDBM_FILE, off_t, int);
void _gdbm_put_av_elem (avail_elem, avail_elem [], int *, int);
int _gdbm_avail_block_read (GDBM_FILE dbf, avail_block *avblk, size_t size);
/* From findkey.c */
char *_gdbm_read_entry (GDBM_FILE, int);
int _gdbm_findkey (GDBM_FILE, datum, char **, int *);
/* From hash.c */
int _gdbm_hash (datum);
void _gdbm_hash_key (GDBM_FILE dbf, datum key, int *hash, int *bucket,
int *offset);
int _gdbm_bucket_dir (GDBM_FILE dbf, int hash);
/* From update.c */
int _gdbm_end_update (GDBM_FILE);
void _gdbm_fatal (GDBM_FILE, const char *);
/* From gdbmopen.c */
int _gdbm_validate_header (GDBM_FILE dbf);
int _gdbm_file_size (GDBM_FILE dbf, off_t *psize);
/* From gdbmload.c */
int _gdbm_str2fmt (char const *str);
/* From mmap.c */
int _gdbm_mapped_init (GDBM_FILE);
void _gdbm_mapped_unmap (GDBM_FILE);
ssize_t _gdbm_mapped_read (GDBM_FILE, void *, size_t);
ssize_t _gdbm_mapped_write (GDBM_FILE, void *, size_t);
off_t _gdbm_mapped_lseek (GDBM_FILE, off_t, int);
int _gdbm_mapped_sync (GDBM_FILE);
/* From lock.c */
void _gdbm_unlock_file (GDBM_FILE);
int _gdbm_lock_file (GDBM_FILE);
/* From fullio.c */
int _gdbm_full_read (GDBM_FILE, void *, size_t);
int _gdbm_full_write (GDBM_FILE, void *, size_t);
int _gdbm_file_extend (GDBM_FILE dbf, off_t size);
/* From base64.c */
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);
/* avail.c */
int gdbm_avail_block_validate (GDBM_FILE dbf, avail_block *avblk, size_t size);
int gdbm_bucket_avail_table_validate (GDBM_FILE dbf, hash_bucket *bucket);
int gdbm_avail_traverse (GDBM_FILE dbf,
int (*cb) (avail_block *, off_t, void *),
void *data);
/* I/O functions */
static inline ssize_t
gdbm_file_read (GDBM_FILE dbf, void *buf, size_t size)
{
#if HAVE_MMAP
return _gdbm_mapped_read (dbf, buf, size);
#else
return read (dbf->desc, buf, size);
#endif
}
static inline ssize_t
gdbm_file_write (GDBM_FILE dbf, void *buf, size_t size)
{
#if HAVE_MMAP
return _gdbm_mapped_write (dbf, buf, size);
#else
return write (dbf->desc, buf, size);
#endif
}
static inline off_t
gdbm_file_seek (GDBM_FILE dbf, off_t off, int whence)
{
#if HAVE_MMAP
return _gdbm_mapped_lseek (dbf, off, whence);
#else
return lseek (dbf->desc, off, whence);
#endif
}
/* From gdbmsync.c */
int gdbm_file_sync (GDBM_FILE dbf);
#ifdef GDBM_FAILURE_ATOMIC
extern int _gdbm_snapshot(GDBM_FILE);
#endif /* GDBM_FAILURE_ATOMIC */
static inline void
_gdbmsync_init (GDBM_FILE dbf)
{
#ifdef GDBM_FAILURE_ATOMIC
dbf->snapfd[0] = dbf->snapfd[1] = -1;
dbf->eo = 0;
#endif
}
static inline void
_gdbmsync_done (GDBM_FILE dbf)
{
#ifdef GDBM_FAILURE_ATOMIC
if (dbf->snapfd[0] >= 0)
close (dbf->snapfd[0]);
if (dbf->snapfd[1] >= 0)
close (dbf->snapfd[1]);
#endif
}
|
