Lines Matching refs:tdb
29 #include "tdb.h"
49 #define BUCKET(hash) ((hash) % tdb->header.hash_size)
81 static int tdb_brlock(TDB_CONTEXT *tdb, tdb_off offset,
89 if (tdb->fd == -1) return 0; /* for in memory tdb */
91 if (tdb->read_only) return -1;
99 if (fcntl(tdb->fd, lck_type, &fl) != 0) {
106 tdb->ecode = TDB_ERR_LOCK;
114 static int tdb_lock(TDB_CONTEXT *tdb, int list)
116 if (list < -1 || list >= (int)tdb->header.hash_size) {
122 if (tdb->locked[list+1] == 0) {
123 if (tdb_brlock(tdb, LIST_LOCK_BASE + 4*list, LOCK_SET,
128 tdb->locked[list+1]++;
133 static int tdb_unlock(TDB_CONTEXT *tdb, int list)
135 if (list < -1 || list >= (int)tdb->header.hash_size) {
142 if (tdb->locked[list+1] == 0) {
146 tdb->ecode = TDB_ERR_LOCK;
149 if (tdb->locked[list+1] == 1) {
150 if (tdb_brlock(tdb, LIST_LOCK_BASE + 4*list, LOCK_CLEAR,
155 tdb->locked[list+1]--;
178 static tdb_off tdb_hash_top(TDB_CONTEXT *tdb, unsigned hash)
190 static int tdb_oob(TDB_CONTEXT *tdb, tdb_off offset)
193 if ((offset <= tdb->map_size) || (tdb->fd == -1)) return 0;
195 fstat(tdb->fd, &st);
197 tdb->ecode = TDB_ERR_IO;
202 if (tdb->map_ptr) {
203 munmap(tdb->map_ptr, tdb->map_size);
204 tdb->map_ptr = NULL;
208 tdb->map_size = st.st_size;
210 tdb->map_ptr = (void *)mmap(NULL, tdb->map_size,
211 tdb->read_only?PROT_READ:PROT_READ|PROT_WRITE,
212 MAP_SHARED | MAP_FILE, tdb->fd, 0);
219 static int tdb_write(TDB_CONTEXT *tdb, tdb_off offset, const char *buf, tdb_len len)
221 if (tdb_oob(tdb, offset + len) != 0) {
226 if (tdb->map_ptr) {
227 memcpy(offset + (char *)tdb->map_ptr, buf, len);
229 if (lseek(tdb->fd, offset, SEEK_SET) != offset ||
230 write(tdb->fd, buf, len) != (ssize_t)len) {
231 tdb->ecode = TDB_ERR_IO;
239 static int tdb_read(TDB_CONTEXT *tdb, tdb_off offset, char *buf, tdb_len len)
241 if (tdb_oob(tdb, offset + len) != 0) {
246 if (tdb->map_ptr) {
247 memcpy(buf, offset + (char *)tdb->map_ptr, len);
249 if (lseek(tdb->fd, offset, SEEK_SET) != offset ||
250 read(tdb->fd, buf, len) != (ssize_t)len) {
251 tdb->ecode = TDB_ERR_IO;
260 static char *tdb_alloc_read(TDB_CONTEXT *tdb, tdb_off offset, tdb_len len)
267 tdb->ecode = TDB_ERR_OOM;
271 if (tdb_read(tdb, offset, buf, len) == -1) {
280 static int rec_write(TDB_CONTEXT *tdb, tdb_off offset, struct list_struct *rec)
282 return tdb_write(tdb, offset, (char *)rec, sizeof(*rec));
286 static int ofs_write(TDB_CONTEXT *tdb, tdb_off offset, tdb_off *d)
288 return tdb_write(tdb, offset, (char *)d, sizeof(*d));
292 static int ofs_read(TDB_CONTEXT *tdb, tdb_off offset, tdb_off *d)
294 return tdb_read(tdb, offset, (char *)d, sizeof(*d));
298 static int rec_read(TDB_CONTEXT *tdb, tdb_off offset, struct list_struct *rec)
300 if (tdb_read(tdb, offset, (char *)rec, sizeof(*rec)) == -1) return -1;
306 tdb->ecode = TDB_ERR_CORRUPT;
309 if (tdb_oob(tdb, rec->next) != 0) {
317 static int tdb_expand(TDB_CONTEXT *tdb, tdb_off length)
323 tdb_lock(tdb,-1);
327 tdb_oob(tdb,tdb->map_size + 1);
333 length = ((tdb->map_size + length + TDB_PAGE_SIZE) & ~(TDB_PAGE_SIZE - 1)) - tdb->map_size;
336 if (tdb->fd != -1) {
337 lseek(tdb->fd, tdb->map_size + length - 1, SEEK_SET);
338 if (write(tdb->fd, &b, 1) != 1) goto fail;
345 if (ofs_read(tdb, offset, &rec.next) == -1) {
350 if (tdb->fd != -1 && tdb->map_ptr) {
351 munmap(tdb->map_ptr, tdb->map_size);
352 tdb->map_ptr = NULL;
356 tdb->map_size += length;
358 if (tdb->fd == -1) {
359 tdb->map_ptr = realloc(tdb->map_ptr, tdb->map_size);
363 if (rec_write(tdb, tdb->map_size - length, &rec) == -1) {
368 ptr = tdb->map_size - length;
369 if (ofs_write(tdb, offset, &ptr) == -1) goto fail;
372 if (tdb->fd != -1) {
373 tdb->map_ptr = (void *)mmap(NULL, tdb->map_size,
375 MAP_SHARED | MAP_FILE, tdb->fd, 0);
379 tdb_unlock(tdb, -1);
383 tdb_unlock(tdb,-1);
393 static tdb_off tdb_allocate(TDB_CONTEXT *tdb, tdb_len length)
398 tdb_lock(tdb, -1);
405 if (ofs_read(tdb, offset, &rec_ptr) == -1) {
412 if (tdb_read(tdb, rec_ptr, (char *)&rec, sizeof(rec)) == -1) {
435 if (rec_write(tdb, rec.next, &newrec) == -1) {
439 if (rec_write(tdb, rec_ptr, &rec) == -1) {
448 if (ofs_write(tdb, offset, &rec.next) == -1) {
453 if (rec_write(tdb, last_ptr, &lastrec) == -1) {
459 tdb_unlock(tdb, -1);
471 if (tdb_expand(tdb, length + sizeof(rec)) == 0) goto again;
477 tdb_unlock(tdb, -1);
482 static int tdb_new_database(TDB_CONTEXT *tdb, int hash_size)
494 lseek(tdb->fd, 0, SEEK_SET);
495 ftruncate(tdb->fd, 0);
497 if (tdb->fd != -1 && write(tdb->fd, &header, sizeof(header)) !=
499 tdb->ecode = TDB_ERR_IO;
508 if (tdb->fd != -1 && write(tdb->fd, buf, sizeof(buf)) !=
510 tdb->ecode = TDB_ERR_IO;
516 if (tdb->fd != -1 && write(tdb->fd, buf, sizeof(tdb_off)) !=
518 tdb->ecode = TDB_ERR_IO;
523 if (tdb->fd == -1) {
524 tdb->map_ptr = calloc(size, 1);
525 tdb->map_size = size;
526 if (tdb->map_ptr == NULL) {
527 tdb->ecode = TDB_ERR_IO;
530 memcpy(&tdb->header, &header, sizeof(header));
542 static tdb_off tdb_find(TDB_CONTEXT *tdb, TDB_DATA key, unsigned int hash,
548 offset = tdb_hash_top(tdb, hash);
551 if (ofs_read(tdb, offset, &rec_ptr) == -1)
556 if (rec_read(tdb, rec_ptr, rec) == -1)
562 k = tdb_alloc_read(tdb, rec_ptr + sizeof(*rec),
582 return an error string for the last tdb error
584 char *tdb_error(TDB_CONTEXT *tdb)
598 if (tdb != NULL) {
600 if (tdb->ecode == emap[i].ecode) return emap[i].estring;
603 return "Invalid tdb context";
613 int tdb_update(TDB_CONTEXT *tdb, TDB_DATA key, TDB_DATA dbuf)
620 if (tdb == NULL) {
630 tdb_lock(tdb, BUCKET(hash));
631 rec_ptr = tdb_find(tdb, key, hash, &rec);
640 if (tdb_write(tdb, rec_ptr + sizeof(rec) + rec.key_len,
647 ret = rec_write(tdb, rec_ptr, &rec);
652 tdb_unlock(tdb, BUCKET(hash));
657 TDB_DATA tdb_fetch(TDB_CONTEXT *tdb, TDB_DATA key)
664 if (tdb == NULL) {
674 tdb_lock(tdb, BUCKET(hash));
675 rec_ptr = tdb_find(tdb, key, hash, &rec);
678 ret.dptr = tdb_alloc_read(tdb,
684 tdb_unlock(tdb, BUCKET(hash));
694 int tdb_exists(TDB_CONTEXT *tdb, TDB_DATA key)
700 if (tdb == NULL) {
710 tdb_lock(tdb, BUCKET(hash));
711 rec_ptr = tdb_find(tdb, key, hash, &rec);
712 tdb_unlock(tdb, BUCKET(hash));
717 /* traverse the entire database - calling fn(tdb, key, data) on each element.
722 int tdb_traverse(TDB_CONTEXT *tdb, int (*fn)(TDB_CONTEXT *tdb, TDB_DATA key, TDB_DATA dbuf, void* state), void* state)
731 if (tdb == NULL) {
739 for (h = 0; h < tdb->header.hash_size; h++) {
740 tdb_lock(tdb, BUCKET(h));
743 offset = tdb_hash_top(tdb, h);
744 if (ofs_read(tdb, offset, &rec_ptr) == -1) {
750 if (rec_read(tdb, rec_ptr, &rec) == -1) {
755 data = tdb_alloc_read(tdb, rec_ptr + sizeof(rec),
767 if (fn && fn(tdb, key, dbuf, state) != 0) {
770 tdb_unlock(tdb, BUCKET(h));
780 tdb_unlock(tdb, BUCKET(h));
787 tdb_unlock(tdb, BUCKET(h));
793 TDB_DATA tdb_firstkey(TDB_CONTEXT *tdb)
800 if (tdb == NULL) {
809 hash < tdb->header.hash_size;
812 offset = tdb_hash_top(tdb, hash);
814 tdb_lock(tdb, BUCKET(hash));
817 if (ofs_read(tdb, offset, &rec_ptr) == -1) {
823 tdb_unlock(tdb, BUCKET(hash));
829 if (rec_read(tdb, rec_ptr, &rec) == -1) {
834 ret.dptr = tdb_alloc_read(tdb, rec_ptr + sizeof(rec), rec.key_len);
836 tdb_unlock(tdb, BUCKET(hash));
840 tdb_unlock(tdb, BUCKET(hash));
845 TDB_DATA tdb_nextkey(TDB_CONTEXT *tdb, TDB_DATA key)
852 if (tdb == NULL) {
863 tdb_lock(tdb, hbucket);
864 rec_ptr = tdb_find(tdb, key, hash, &rec);
872 tdb_unlock(tdb, hbucket);
874 if (++hbucket >= tdb->header.hash_size - 1)
877 offset = tdb_hash_top(tdb, hbucket);
878 tdb_lock(tdb, hbucket);
880 if (ofs_read(tdb, offset, &rec_ptr) == -1) {
881 tdb_unlock(tdb, hbucket);
887 if (rec_read(tdb, rec_ptr, &rec) == -1) {
888 tdb_unlock(tdb, hbucket);
892 ret.dptr = tdb_alloc_read(tdb, rec_ptr + sizeof(rec), rec.key_len);
894 tdb_unlock(tdb, hbucket);
900 int tdb_delete(TDB_CONTEXT *tdb, TDB_DATA key)
907 if (tdb == NULL) {
917 tdb_lock(tdb, BUCKET(hash));
920 offset = tdb_hash_top(tdb, hash);
923 if (ofs_read(tdb, offset, &rec_ptr) == -1) {
931 if (rec_read(tdb, rec_ptr, &rec) == -1) {
937 data = tdb_alloc_read(tdb, rec_ptr + sizeof(rec),
946 offset = tdb_hash_top(tdb, hash);
947 if (ofs_write(tdb, offset, &rec.next) == -1) {
952 if (rec_write(tdb, last_ptr, &lastrec) == -1) {
956 tdb_unlock(tdb, BUCKET(hash));
957 tdb_lock(tdb, -1);
960 if (ofs_read(tdb, offset, &rec.next) == -1) {
964 if (rec_write(tdb, rec_ptr, &rec) == -1) {
967 if (ofs_write(tdb, offset, &rec_ptr) == -1) {
973 tdb_unlock(tdb, -1);
990 tdb_unlock(tdb, BUCKET(hash));
995 tdb_unlock(tdb, -1);
1005 int tdb_store(TDB_CONTEXT *tdb, TDB_DATA key, TDB_DATA dbuf, int flag)
1012 if (tdb == NULL) {
1023 if (flag == TDB_INSERT && tdb_exists(tdb, key)) {
1024 tdb->ecode = TDB_ERR_EXISTS;
1029 if (flag != TDB_INSERT && tdb_update(tdb, key, dbuf) == 0) {
1033 rec_ptr = tdb_allocate(tdb, key.dsize + dbuf.dsize);
1038 tdb_lock(tdb, BUCKET(hash));
1042 tdb_delete(tdb, key);
1046 if (tdb_read(tdb, rec_ptr, (char *)&rec, sizeof(rec)) == -1) {
1053 offset = tdb_hash_top(tdb, hash);
1056 if (ofs_read(tdb, offset, &rec.next) == -1) {
1067 tdb->ecode = TDB_ERR_OOM;
1075 if (tdb_write(tdb, rec_ptr, p, sizeof(rec)+key.dsize+dbuf.dsize) == -1)
1082 if (ofs_write(tdb, offset, &rec_ptr) == -1) goto fail;
1084 tdb_unlock(tdb, BUCKET(hash));
1092 tdb_unlock(tdb, BUCKET(hash));
1109 TDB_CONTEXT tdb, *ret;
1112 memset(&tdb, 0, sizeof(tdb));
1114 tdb.fd = -1;
1115 tdb.name = NULL;
1116 tdb.map_ptr = NULL;
1124 tdb.read_only = ((open_flags & O_ACCMODE) == O_RDONLY);
1127 tdb.fd = open(name, open_flags, mode);
1128 if (tdb.fd == -1) {
1134 tdb_brlock(&tdb, GLOBAL_LOCK, LOCK_SET, F_WRLCK, F_SETLKW);
1139 if (tdb_brlock(&tdb, ACTIVE_LOCK, LOCK_SET, F_WRLCK, F_SETLK) == 0) {
1140 ftruncate(tdb.fd, 0);
1141 tdb_brlock(&tdb, ACTIVE_LOCK, LOCK_CLEAR, F_WRLCK, F_SETLK);
1146 tdb_brlock(&tdb, ACTIVE_LOCK, LOCK_SET, F_RDLCK, F_SETLKW);
1148 if (read(tdb.fd, &tdb.header, sizeof(tdb.header)) != sizeof(tdb.header) ||
1149 strcmp(tdb.header.magic_food, TDB_MAGIC_FOOD) != 0 ||
1150 tdb.header.version != TDB_VERSION) {
1155 if (tdb_new_database(&tdb, hash_size) == -1) goto fail;
1157 lseek(tdb.fd, 0, SEEK_SET);
1158 if (tdb.fd != -1 && read(tdb.fd, &tdb.header,
1159 sizeof(tdb.header)) !=
1160 sizeof(tdb.header))
1164 if (tdb.fd != -1) {
1165 fstat(tdb.fd, &st);
1168 tdb.name = (char *)strdup(name);
1169 tdb.map_size = st.st_size;
1172 tdb.locked = (int *)calloc(tdb.header.hash_size+1,
1173 sizeof(tdb.locked[0]));
1174 if (!tdb.locked) {
1179 if (tdb.fd != -1) {
1180 tdb.map_ptr = (void *)mmap(NULL, st.st_size,
1181 tdb.read_only? PROT_READ : PROT_READ|PROT_WRITE,
1182 MAP_SHARED | MAP_FILE, tdb.fd, 0);
1186 ret = (TDB_CONTEXT *)malloc(sizeof(tdb));
1189 *ret = tdb;
1193 hash_size, tdb.map_size);
1196 tdb_brlock(&tdb, GLOBAL_LOCK, LOCK_CLEAR, F_WRLCK, F_SETLKW);
1200 if (tdb.name) free(tdb.name);
1201 if (tdb.fd != -1) close(tdb.fd);
1202 if (tdb.map_ptr) munmap(tdb.map_ptr, tdb.map_size);
1208 int tdb_close(TDB_CONTEXT *tdb)
1210 if (!tdb) return -1;
1212 if (tdb->name) free(tdb->name);
1213 if (tdb->fd != -1) close(tdb->fd);
1214 if (tdb->locked) free(tdb->locked);
1216 if (tdb->map_ptr) {
1217 if (tdb->fd != -1) {
1218 munmap(tdb->map_ptr, tdb->map_size);
1220 free(tdb->map_ptr);
1224 memset(tdb, 0, sizeof(*tdb));
1225 free(tdb);
1231 int tdb_writelock(TDB_CONTEXT *tdb)
1233 if (tdb == NULL) {
1240 return tdb_lock(tdb, -1);
1244 int tdb_writeunlock(TDB_CONTEXT *tdb)
1246 if (tdb == NULL) {
1253 return tdb_unlock(tdb, -1);
1258 int tdb_lockchain(TDB_CONTEXT *tdb, TDB_DATA key)
1260 if (tdb == NULL) {
1267 return tdb_lock(tdb, BUCKET(tdb_hash(&key)));
1272 int tdb_unlockchain(TDB_CONTEXT *tdb, TDB_DATA key)
1274 if (tdb == NULL) {
1281 return tdb_unlock(tdb, BUCKET(tdb_hash(&key)));