X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=index%2Frecindex.c;h=73ef6339d94b3e9eadfc238d6a9d99472b23998a;hb=e9a1d4a77195ebba6dc3ddaf1b970958bb7e6a62;hp=bdd134cbe02f0eb9ac7334db1bff0cd3604de577;hpb=ea01436a957572aaaa878b59469a4cedce7e5e21;p=idzebra-moved-to-github.git

diff --git a/index/recindex.c b/index/recindex.c
index bdd134c..73ef633 100644
--- a/index/recindex.c
+++ b/index/recindex.c
@@ -1,10 +1,80 @@
 /*
- * Copyright (C) 1994-1995, Index Data I/S 
+ * Copyright (C) 1994-1998, Index Data I/S 
  * All rights reserved.
  * Sebastian Hammer, Adam Dickmeiss
  *
  * $Log: recindex.c,v $
- * Revision 1.4  1995-11-20 16:59:46  adam
+ * Revision 1.20  1998-01-12 15:04:08  adam
+ * The test option (-s) only uses read-lock (and not write lock).
+ *
+ * Revision 1.19  1997/09/17 12:19:16  adam
+ * Zebra version corresponds to YAZ version 1.4.
+ * Changed Zebra server so that it doesn't depend on global common_resource.
+ *
+ * Revision 1.18  1997/07/15 16:28:42  adam
+ * Bug fix: storeData didn't work with files with multiple records.
+ * Bug fix: fixed memory management with records; not really well
+ *  thought through.
+ *
+ * Revision 1.17  1997/02/12 20:39:46  adam
+ * Implemented options -f <n> that limits the log to the first <n>
+ * records.
+ * Changed some log messages also.
+ *
+ * Revision 1.16  1996/06/04 10:19:00  adam
+ * Minor changes - removed include of ctype.h.
+ *
+ * Revision 1.15  1996/05/13  14:23:06  adam
+ * Work on compaction of set/use bytes in dictionary.
+ *
+ * Revision 1.14  1996/02/01  20:48:15  adam
+ * The total size of records are always checked in rec_cache_insert to
+ * reduce memory usage.
+ *
+ * Revision 1.13  1995/12/11  09:12:49  adam
+ * The rec_get function returns NULL if record doesn't exist - will
+ * happen in the server if the result set records have been deleted since
+ * the creation of the set (i.e. the search).
+ * The server saves a result temporarily if it is 'volatile', i.e. the
+ * set is register dependent.
+ *
+ * Revision 1.12  1995/12/07  17:38:47  adam
+ * Work locking mechanisms for concurrent updates/commit.
+ *
+ * Revision 1.11  1995/12/06  13:58:26  adam
+ * Improved flushing of records - all flushes except the last one
+ * don't write the last accessed. Also flush takes place if record
+ * info occupy more than about 256k.
+ *
+ * Revision 1.10  1995/12/06  12:41:24  adam
+ * New command 'stat' for the index program.
+ * Filenames can be read from stdin by specifying '-'.
+ * Bug fix/enhancement of the transformation from terms to regular
+ * expressons in the search engine.
+ *
+ * Revision 1.9  1995/11/30  08:34:33  adam
+ * Started work on commit facility.
+ * Changed a few malloc/free to xmalloc/xfree.
+ *
+ * Revision 1.8  1995/11/28  14:26:21  adam
+ * Bug fix: recordId with constant wasn't right.
+ * Bug fix: recordId dictionary entry wasn't deleted when needed.
+ *
+ * Revision 1.7  1995/11/28  09:09:43  adam
+ * Zebra config renamed.
+ * Use setting 'recordId' to identify record now.
+ * Bug fix in recindex.c: rec_release_blocks was invokeded even
+ * though the blocks were already released.
+ * File traversal properly deletes records when needed.
+ *
+ * Revision 1.6  1995/11/25  10:24:06  adam
+ * More record fields - they are enumerated now.
+ * New options: flagStoreData flagStoreKey.
+ *
+ * Revision 1.5  1995/11/22  17:19:18  adam
+ * Record management uses the bfile system.
+ *
+ * Revision 1.4  1995/11/20  16:59:46  adam
  * New update method: the 'old' keys are saved for each records.
  *
  * Revision 1.3  1995/11/16  15:34:55  adam
@@ -20,280 +90,291 @@
 #include <stdio.h>
 #include <assert.h>
 #include <string.h>
-#include <ctype.h>
-#include <assert.h>
-#include <fcntl.h>
-#include <unistd.h>
-
-#include "recindex.h"
-
-struct records_info {
-    int rw;
-    int index_fd;
-    char *index_fname;
-    int data_fd;
-    char *data_fname;
-    struct records_head {
-        char magic[8];
-	int no_records;
-        int index_free;
-        int index_last;
-        int data_size;
-        int data_slack;
-        int data_used;
-    } head;
-    char *tmp_buf;
-    int tmp_size;
-    int cache_size;
-    int cache_cur;
-    int cache_max;
-    struct record_cache_entry *record_cache;
-};
-
-struct record_cache_entry {
-    Record rec;
-    int dirty;
-};
-
-struct record_index_entry {
-    union {
-        struct {
-            int offset;
-            int size;
-        } used;
-        struct {
-            int next;
-        } free;
-    } u;
-};
-
-#define REC_HEAD_MAGIC "rechead"
-
-char *rec_strdup (const char *s, size_t *len)
-{
-    char *p;
 
-    if (!s)
-    {
-        *len = 0;
-        return NULL;
-    }
-    *len = strlen(s)+1;
-    p = malloc (*len);
-    if (!p)
-    {
-        logf (LOG_FATAL|LOG_ERRNO, "malloc");
-        exit (1);
-    }
-    strcpy (p, s);
-    return p;
-}
+#include "recindxp.h"
 
 static void rec_write_head (Records p)
 {
     int r;
 
     assert (p);
-    assert (p->index_fd != -1);
-    if (lseek (p->index_fd, (off_t) 0, SEEK_SET) == -1)
+    assert (p->index_BFile);
+
+    r = bf_write (p->index_BFile, 0, 0, sizeof(p->head), &p->head);    
+    if (r)
     {
-        logf (LOG_FATAL|LOG_ERRNO, "lseek to 0 in %s", p->index_fname);
+        logf (LOG_FATAL|LOG_ERRNO, "write head of %s", p->index_fname);
         exit (1);
     }
-    r = write (p->index_fd, &p->head, sizeof(p->head));    
-    switch (r)
+}
+
+static void rec_tmp_expand (Records p, int size, int dst_type)
+{
+    if (p->tmp_size < size + 2048 ||
+        p->tmp_size < p->head.block_size[dst_type]*2)
     {
-    case -1:
-        logf (LOG_FATAL|LOG_ERRNO, "write head of %s", p->index_fname);
-        exit (1);
-    case sizeof(p->head):
-        break;
-    default:
-        logf (LOG_FATAL, "write head of %s. wrote %d", p->index_fname, r);
-        exit (1);
+        xfree (p->tmp_buf);
+        p->tmp_size = size + p->head.block_size[dst_type]*2 + 2048;
+        p->tmp_buf = xmalloc (p->tmp_size);
     }
 }
 
-Records rec_open (int rw)
+static int read_indx (Records p, int sysno, void *buf, int itemsize, 
+                      int ignoreError)
 {
-    Records p;
     int r;
+    int pos = (sysno-1)*itemsize;
 
-    if (!(p = malloc (sizeof(*p))))
+    r = bf_read (p->index_BFile, 1+pos/128, pos%128, itemsize, buf);
+    if (r != 1 && !ignoreError)
     {
-        logf (LOG_FATAL|LOG_ERRNO, "malloc");
-        exit (1);
-    }
-    p->rw = rw;
-    p->tmp_buf = NULL;
-    p->tmp_size = 0;
-    p->data_fname = "recdata";
-    p->data_fd = -1;
-    p->index_fname = "recindex";
-    p->index_fd = open (p->index_fname,
-                        rw ? (O_RDWR|O_CREAT) : O_RDONLY, 0666);
-    if (p->index_fd == -1)
-    {
-        logf (LOG_FATAL|LOG_ERRNO, "open %s", p->index_fname);
+        logf (LOG_FATAL|LOG_ERRNO, "read in %s at pos %ld",
+              p->index_fname, (long) pos);
         exit (1);
     }
-    r = read (p->index_fd, &p->head, sizeof(p->head));
-    switch (r)
+    return r;
+}
+
+static void write_indx (Records p, int sysno, void *buf, int itemsize)
+{
+    int pos = (sysno-1)*itemsize;
+
+    bf_write (p->index_BFile, 1+pos/128, pos%128, itemsize, buf);
+}
+
+static void rec_release_blocks (Records p, int sysno)
+{
+    struct record_index_entry entry;
+    int freeblock, freenext;
+    int dst_type;
+
+    if (read_indx (p, sysno, &entry, sizeof(entry), 1) != 1)
+        return ;
+    p->head.total_bytes -= entry.size;
+    freeblock = entry.next;
+    assert (freeblock > 0);
+    dst_type = freeblock & 7;
+    assert (dst_type < REC_BLOCK_TYPES);
+    freeblock = freeblock / 8;
+    while (freeblock)
     {
-    case -1:
-        logf (LOG_FATAL|LOG_ERRNO, "read %s", p->index_fname);
-        exit (1);
-    case 0:
-        memcpy (p->head.magic, REC_HEAD_MAGIC, sizeof(p->head.magic));
-        p->head.index_free = 0;
-        p->head.index_last = 1;
-        p->head.no_records = 0;
-        p->head.data_size = 0;
-        p->head.data_slack = 0;
-        p->head.data_used = 0;
-        if (rw)
-            rec_write_head (p);
-        break;
-    case sizeof(p->head):
-        if (memcmp (p->head.magic, REC_HEAD_MAGIC, sizeof(p->head.magic)))
+        if (bf_read (p->data_BFile[dst_type], freeblock, 0, sizeof(freenext),
+                     &freenext) != 1)
         {
-            logf (LOG_FATAL, "read %s. bad header", p->index_fname);
+            logf (LOG_FATAL|LOG_ERRNO, "read in rec_del_single");
             exit (1);
         }
-        break;
-    default:
-        logf (LOG_FATAL, "read head of %s. expected %d. got %d",
-	      p->index_fname, sizeof(p->head), r);
-        exit (1);
-    }
-    p->data_fd = open (p->data_fname,
-                       rw ? (O_RDWR|O_CREAT) : O_RDONLY, 0666);
-    if (p->data_fd == -1)
-    {
-        logf (LOG_FATAL|LOG_ERRNO, "open %s", p->data_fname);
-        exit (1);
-    }
-    p->cache_max = 10;
-    p->cache_cur = 0;
-    if (!(p->record_cache = malloc (sizeof(*p->record_cache)*p->cache_max)))
-    {
-        logf (LOG_FATAL|LOG_ERRNO, "malloc");
-        exit (1);
+        if (bf_write (p->data_BFile[dst_type], freeblock, 0, sizeof(freenext),
+                      &p->head.block_free[dst_type]))
+        {
+            logf (LOG_FATAL|LOG_ERRNO, "write in rec_del_single");
+            exit (1);
+        }
+        p->head.block_free[dst_type] = freeblock;
+        freeblock = freenext;
+        p->head.block_used[dst_type]--;
     }
-    return p;
 }
 
-static void read_indx (Records p, int sysno, void *buf, int itemsize)
+static void rec_delete_single (Records p, Record rec)
 {
-    int r;
-    off_t pos = (sysno-1)*itemsize + sizeof(p->head);
+    struct record_index_entry entry;
 
-    if (lseek (p->index_fd, pos, SEEK_SET) == (pos) -1)
-    {
-        logf (LOG_FATAL|LOG_ERRNO, "seek in %s to pos %ld",
-              p->index_fname, (long) pos);
-        exit (1);
-    }
-    r = read (p->index_fd, buf, itemsize);
-    if (r != itemsize)
-    {
-        if (r == -1)
-            logf (LOG_FATAL|LOG_ERRNO, "read in %s at pos %ld",
-                  p->index_fname, (long) pos);
-        else
-            logf (LOG_FATAL, "read in %s at pos %ld",
-                  p->index_fname, (long) pos);
-        exit (1);
-    }
+    rec_release_blocks (p, rec->sysno);
+
+    entry.next = p->head.index_free;
+    entry.size = 0;
+    p->head.index_free = rec->sysno;
+    write_indx (p, rec->sysno, &entry, sizeof(entry));
 }
 
+
 static void rec_write_single (Records p, Record rec)
 {
-    struct record_index_entry entry;
-    int r, i, size = 0, got;
+    int i, size = 0;
     char *cptr;
-    off_t pos = (rec->sysno-1)*sizeof(entry) + sizeof(p->head);
+    int dst_type = 0;
+    int no_written = 0;
+    int block_prev = -1, block_free;
+    struct record_index_entry entry;
 
     for (i = 0; i < REC_NO_INFO; i++)
         if (!rec->info[i])
             size += sizeof(*rec->size);
         else
             size += sizeof(*rec->size) + rec->size[i];
-    
-    entry.u.used.offset = p->head.data_size;
-    entry.u.used.size = size;
-    p->head.data_size += size;
-    p->head.data_used += size;
 
-    if (lseek (p->index_fd, pos, SEEK_SET) == (pos) -1)
+    for (i = 1; i<REC_BLOCK_TYPES; i++)
+        if (size >= p->head.block_move[i])
+            dst_type = i;
+
+    rec_tmp_expand (p, size, dst_type);
+
+    cptr = p->tmp_buf + sizeof(int);           /* a hack! */
+    for (i = 0; i < REC_NO_INFO; i++)
     {
-        logf (LOG_FATAL|LOG_ERRNO, "seek in %s to pos %ld",
-              p->index_fname, (long) pos);
-        exit (1);
+        memcpy (cptr, &rec->size[i], sizeof(*rec->size));
+        cptr += sizeof(*rec->size);
+        if (rec->info[i])
+        {
+            memcpy (cptr, rec->info[i], rec->size[i]);
+            cptr += rec->size[i];
+        }
     }
-    r = write (p->index_fd, &entry, sizeof(entry));
-    if (r != sizeof(entry))
+    cptr = p->tmp_buf;
+    while (no_written < size)
     {
-        if (r == -1)
-            logf (LOG_FATAL|LOG_ERRNO, "write of %s at pos %ld",
-                  p->index_fname, (long) pos);
+        block_free = p->head.block_free[dst_type];
+        if (block_free)
+        {
+            if (bf_read (p->data_BFile[dst_type],
+                         block_free, 0, sizeof(*p->head.block_free),
+                         &p->head.block_free[dst_type]) != 1)
+            {
+                logf (LOG_FATAL|LOG_ERRNO, "read in %s at free block %d",
+                      p->data_fname[dst_type], block_free);
+		exit (1);
+            }
+        }
         else
-            logf (LOG_FATAL, "write of %s at pos %ld",
-                  p->index_fname, (long) pos);
-        exit (1);
+            block_free = p->head.block_last[dst_type]++;
+        if (block_prev == -1)
+        {
+            entry.next = block_free*8 + dst_type;
+            entry.size = size;
+            p->head.total_bytes += size;
+            write_indx (p, rec->sysno, &entry, sizeof(entry));
+        }
+        else
+        {
+            memcpy (cptr, &block_free, sizeof(int));
+            bf_write (p->data_BFile[dst_type], block_prev, 0, 0, cptr);
+            cptr = p->tmp_buf + no_written;
+        }
+        block_prev = block_free;
+        no_written += p->head.block_size[dst_type] - sizeof(int);
+        p->head.block_used[dst_type]++;
     }
-    if (lseek (p->data_fd, entry.u.used.offset, SEEK_SET) == -1) 
+    assert (block_prev != -1);
+    block_free = 0;
+    memcpy (cptr, &block_free, sizeof(int));
+    bf_write (p->data_BFile[dst_type], block_prev, 0,
+              sizeof(int) + (p->tmp_buf+size) - cptr, cptr);
+}
+
+static void rec_update_single (Records p, Record rec)
+{
+    rec_release_blocks (p, rec->sysno);
+    rec_write_single (p, rec);
+}
+
+Records rec_open (BFiles bfs, int rw)
+{
+    Records p;
+    int i, r;
+
+    p = xmalloc (sizeof(*p));
+    p->rw = rw;
+    p->tmp_size = 1024;
+    p->tmp_buf = xmalloc (p->tmp_size);
+    p->index_fname = "recindex";
+    p->index_BFile = bf_open (bfs, p->index_fname, 128, rw);
+    if (p->index_BFile == NULL)
     {
-        logf (LOG_FATAL|LOG_ERRNO, "lseek in %s to pos %ld",
-              p->data_fname, entry.u.used.offset);
+        logf (LOG_FATAL|LOG_ERRNO, "open %s", p->index_fname);
         exit (1);
     }
-    if (p->tmp_size < entry.u.used.size) 
+    r = bf_read (p->index_BFile, 0, 0, 0, p->tmp_buf);
+    switch (r)
     {
-        free (p->tmp_buf);
-        p->tmp_size = entry.u.used.size + 16384;
-        if (!(p->tmp_buf = malloc (p->tmp_size)))
+    case 0:
+        memcpy (p->head.magic, REC_HEAD_MAGIC, sizeof(p->head.magic));
+        p->head.index_free = 0;
+        p->head.index_last = 1;
+        p->head.no_records = 0;
+        p->head.total_bytes = 0;
+        for (i = 0; i<REC_BLOCK_TYPES; i++)
+        {
+            p->head.block_free[i] = 0;
+            p->head.block_last[i] = 1;
+            p->head.block_used[i] = 0;
+        }
+        p->head.block_size[0] = 128;
+        p->head.block_move[0] = 0;
+        for (i = 1; i<REC_BLOCK_TYPES; i++)
         {
-            logf (LOG_FATAL|LOG_ERRNO, "malloc");
+            p->head.block_size[i] = p->head.block_size[i-1] * 4;
+            p->head.block_move[i] = p->head.block_size[i] * 3;
+        }
+        if (rw)
+            rec_write_head (p);
+        break;
+    case 1:
+        memcpy (&p->head, p->tmp_buf, sizeof(p->head));
+        if (memcmp (p->head.magic, REC_HEAD_MAGIC, sizeof(p->head.magic)))
+        {
+            logf (LOG_FATAL, "read %s. bad header", p->index_fname);
             exit (1);
         }
+        break;
     }
-    cptr = p->tmp_buf;
-    for (i = 0; i < REC_NO_INFO; i++)
+    for (i = 0; i<REC_BLOCK_TYPES; i++)
     {
-        memcpy (cptr, &rec->size[i], sizeof(*rec->size));
-        cptr += sizeof(*rec->size);
-        if (rec->info[i])
-        {
-            memcpy (cptr, rec->info[i], rec->size[i]);
-            cptr += rec->size[i];
-        }
+        char str[80];
+        sprintf (str, "recdata%c", i + 'A');
+        p->data_fname[i] = xmalloc (strlen(str)+1);
+        strcpy (p->data_fname[i], str);
+        p->data_BFile[i] = NULL;
     }
-    for (got = 0; got < entry.u.used.size; got += r)
+    for (i = 0; i<REC_BLOCK_TYPES; i++)
     {
-        r = write (p->data_fd, p->tmp_buf + got, entry.u.used.size - got);
-        if (r <= 0)
+        if (!(p->data_BFile[i] = bf_open (bfs, p->data_fname[i],
+                                          p->head.block_size[i],
+                                          rw)))
         {
-            logf (LOG_FATAL|LOG_ERRNO, "write of %s", p->data_fname);
+            logf (LOG_FATAL|LOG_ERRNO, "bf_open %s", p->data_fname[i]);
             exit (1);
         }
     }
+    p->cache_max = 10;
+    p->cache_cur = 0;
+    p->record_cache = xmalloc (sizeof(*p->record_cache)*p->cache_max);
+    return p;
 }
 
-static void rec_cache_flush (Records p)
+static void rec_cache_flush (Records p, int saveCount)
 {
-    int i;
-    for (i = 0; i<p->cache_cur; i++)
+    int i, j;
+
+    if (saveCount >= p->cache_cur)
+        saveCount = 0;
+    for (i = 0; i<p->cache_cur - saveCount; i++)
     {
         struct record_cache_entry *e = p->record_cache + i;
-        if (e->dirty)
+        switch (e->flag)
+        {
+        case recordFlagNop:
+            break;
+        case recordFlagNew:
             rec_write_single (p, e->rec);
+            break;
+        case recordFlagWrite:
+            rec_update_single (p, e->rec);
+            break;
+        case recordFlagDelete:
+            rec_delete_single (p, e->rec);
+            break;
+        }
         rec_rm (&e->rec);
     }
-    p->cache_cur = 0;
+    for (j = 0; j<saveCount; j++, i++)
+        memcpy (p->record_cache+j, p->record_cache+i,
+                sizeof(*p->record_cache));
+    p->cache_cur = saveCount;
 }
 
-static Record *rec_cache_lookup (Records p, int sysno, int dirty)
+static Record *rec_cache_lookup (Records p, int sysno,
+                                 enum recordCacheFlag flag)
 {
     int i;
     for (i = 0; i<p->cache_cur; i++)
@@ -301,112 +382,129 @@ static Record *rec_cache_lookup (Records p, int sysno, int dirty)
         struct record_cache_entry *e = p->record_cache + i;
         if (e->rec->sysno == sysno)
         {
-            if (dirty)
-                e->dirty = 1;
+            if (flag != recordFlagNop && e->flag == recordFlagNop)
+                e->flag = flag;
             return &e->rec;
         }
     }
     return NULL;
 }
 
-static void rec_cache_insert (Records p, Record rec, int dirty)
+static void rec_cache_insert (Records p, Record rec, enum recordCacheFlag flag)
 {
     struct record_cache_entry *e;
 
     if (p->cache_cur == p->cache_max)
-        rec_cache_flush (p);
+        rec_cache_flush (p, 1);
+    else if (p->cache_cur > 0)
+    {
+        int i, j;
+        int used = 0;
+        for (i = 0; i<p->cache_cur; i++)
+        {
+            Record r = (p->record_cache + i)->rec;
+            for (j = 0; j<REC_NO_INFO; j++)
+                used += r->size[j];
+        }
+        if (used > 256000)
+            rec_cache_flush (p, 1);
+    }
     assert (p->cache_cur < p->cache_max);
 
     e = p->record_cache + (p->cache_cur)++;
-    e->dirty = dirty;
+    e->flag = flag;
     e->rec = rec_cp (rec);
 }
 
-void rec_close (Records *p)
+void rec_close (Records *pp)
 {
-    assert (*p);
-
-    rec_cache_flush (*p);
-    free ((*p)->record_cache);
+    Records p = *pp;
+    int i;
 
-    if ((*p)->rw)
-        rec_write_head (*p);
+    assert (p);
 
-    if ((*p)->index_fd != -1)
-        close ((*p)->index_fd);
+    rec_cache_flush (p, 0);
+    xfree (p->record_cache);
 
-    if ((*p)->data_fd != -1)
-        close ((*p)->data_fd);
+    if (p->rw)
+        rec_write_head (p);
 
-    free ((*p)->tmp_buf);
+    if (p->index_BFile)
+        bf_close (p->index_BFile);
 
-    free (*p);
-    *p = NULL;
+    for (i = 0; i<REC_BLOCK_TYPES; i++)
+    {
+        if (p->data_BFile[i])
+            bf_close (p->data_BFile[i]);
+        xfree (p->data_fname[i]);
+    }
+    xfree (p->tmp_buf);
+    xfree (p);
+    *pp = NULL;
 }
 
+
 Record rec_get (Records p, int sysno)
 {
     int i;
     Record rec, *recp;
     struct record_index_entry entry;
-    int r, got;
-    char *nptr;
+    int freeblock, dst_type;
+    char *nptr, *cptr;
 
     assert (sysno > 0);
     assert (p);
 
-    if ((recp = rec_cache_lookup (p, sysno, 0)))
+    if ((recp = rec_cache_lookup (p, sysno, recordFlagNop)))
         return rec_cp (*recp);
 
-    read_indx (p, sysno, &entry, sizeof(entry));
+    if (!read_indx (p, sysno, &entry, sizeof(entry), 1))
+        return NULL;       /* record is not there! */
+
+    if (!entry.size)
+        return NULL;       /* record is deleted */
+
+    dst_type = entry.next & 7;
+    assert (dst_type < REC_BLOCK_TYPES);
+    freeblock = entry.next / 8;
+
+    assert (freeblock > 0);
     
-    if (!(rec = malloc (sizeof(*rec))))
-    {
-        logf (LOG_FATAL|LOG_ERRNO, "malloc");
-        exit (1);
-    }
-    if (lseek (p->data_fd, entry.u.used.offset, SEEK_SET) == -1) 
-    {
-        logf (LOG_FATAL|LOG_ERRNO, "lseek in %s to pos %ld",
-              p->data_fname, entry.u.used.offset);
-        exit (1);
-    }
-    if (p->tmp_size < entry.u.used.size) 
-    {
-        free (p->tmp_buf);
-        p->tmp_size = entry.u.used.size + 16384;
-        if (!(p->tmp_buf = malloc (p->tmp_size)))
-        {
-            logf (LOG_FATAL|LOG_ERRNO, "malloc");
-            exit (1);
-        }
-    }
-    for (got = 0; got < entry.u.used.size; got += r)
+    rec = xmalloc (sizeof(*rec));
+    rec_tmp_expand (p, entry.size, dst_type);
+
+    cptr = p->tmp_buf;
+    bf_read (p->data_BFile[dst_type], freeblock, 0, 0, cptr);
+    memcpy (&freeblock, cptr, sizeof(freeblock));
+
+    while (freeblock)
     {
-        r = read (p->data_fd, p->tmp_buf + got, entry.u.used.size - got);
-        if (r <= 0)
-        {
-            logf (LOG_FATAL|LOG_ERRNO, "read of %s", p->data_fname);
-            exit (1);
-        }
+        int tmp;
+
+        cptr += p->head.block_size[dst_type] - sizeof(freeblock);
+        
+        memcpy (&tmp, cptr, sizeof(tmp));
+        bf_read (p->data_BFile[dst_type], freeblock, 0, 0, cptr);
+        memcpy (&freeblock, cptr, sizeof(freeblock));
+        memcpy (cptr, &tmp, sizeof(tmp));
     }
-    rec->sysno = sysno;
 
-    nptr = p->tmp_buf;
+    rec->sysno = sysno;
+    nptr = p->tmp_buf + sizeof(freeblock);
     for (i = 0; i < REC_NO_INFO; i++)
     {
         memcpy (&rec->size[i], nptr, sizeof(*rec->size));
         nptr += sizeof(*rec->size);
         if (rec->size[i])
         {
-            rec->info[i] = malloc (rec->size[i]);
+            rec->info[i] = xmalloc (rec->size[i]);
             memcpy (rec->info[i], nptr, rec->size[i]);
             nptr += rec->size[i];
         }
         else
             rec->info[i] = NULL;
     }
-    rec_cache_insert (p, rec, 0);
+    rec_cache_insert (p, rec, recordFlagNop);
     return rec;
 }
 
@@ -416,20 +514,16 @@ Record rec_new (Records p)
     Record rec;
 
     assert (p);
-    if (!(rec = malloc (sizeof(*rec))))
-    {
-        logf (LOG_FATAL|LOG_ERRNO, "malloc");
-        exit (1);
-    }
-    if (p->head.index_free == 0)
+    rec = xmalloc (sizeof(*rec));
+    if (1 || p->head.index_free == 0)
         sysno = (p->head.index_last)++;
     else
     {
         struct record_index_entry entry;
 
-        read_indx (p, p->head.index_free, &entry, sizeof(entry));
+        read_indx (p, p->head.index_free, &entry, sizeof(entry), 0);
         sysno = p->head.index_free;
-        p->head.index_free = entry.u.free.next;
+        p->head.index_free = entry.next;
     }
     (p->head.no_records)++;
     rec->sysno = sysno;
@@ -438,22 +532,40 @@ Record rec_new (Records p)
         rec->info[i] = NULL;
         rec->size[i] = 0;
     }
-    rec_cache_insert (p, rec, 1);
+    rec_cache_insert (p, rec, recordFlagNew);
     return rec;
 }
 
+void rec_del (Records p, Record *recpp)
+{
+    Record *recp;
+
+    (p->head.no_records)--;
+    if ((recp = rec_cache_lookup (p, (*recpp)->sysno, recordFlagDelete)))
+    {
+        rec_rm (recp);
+        *recp = *recpp;
+    }
+    else
+    {
+        rec_cache_insert (p, *recpp, recordFlagDelete);
+        rec_rm (recpp);
+    }
+    *recpp = NULL;
+}
+
 void rec_put (Records p, Record *recpp)
 {
     Record *recp;
 
-    if ((recp = rec_cache_lookup (p, (*recpp)->sysno, 1)))
+    if ((recp = rec_cache_lookup (p, (*recpp)->sysno, recordFlagWrite)))
     {
         rec_rm (recp);
         *recp = *recpp;
     }
     else
     {
-        rec_cache_insert (p, *recpp, 1);
+        rec_cache_insert (p, *recpp, recordFlagWrite);
         rec_rm (recpp);
     }
     *recpp = NULL;
@@ -462,9 +574,12 @@ void rec_put (Records p, Record *recpp)
 void rec_rm (Record *recpp)
 {
     int i;
+
+    if (!*recpp)
+        return ;
     for (i = 0; i < REC_NO_INFO; i++)
-        free ((*recpp)->info[i]);
-    free (*recpp);
+        xfree ((*recpp)->info[i]);
+    xfree (*recpp);
     *recpp = NULL;
 }
 
@@ -473,11 +588,7 @@ Record rec_cp (Record rec)
     Record n;
     int i;
 
-    if (!(n = malloc (sizeof(*n))))
-    {
-        logf (LOG_FATAL|LOG_ERRNO, "malloc");
-        exit (1);
-    }
+    n = xmalloc (sizeof(*n));
     n->sysno = rec->sysno;
     for (i = 0; i < REC_NO_INFO; i++)
         if (!rec->info[i])
@@ -488,12 +599,25 @@ Record rec_cp (Record rec)
         else
         {
             n->size[i] = rec->size[i];
-            if (!(n->info[i] = malloc (rec->size[i])))
-            {
-                logf (LOG_FATAL|LOG_ERRNO, "malloc. rec_cp");
-                exit (1);
-            }
+            n->info[i] = xmalloc (rec->size[i]);
             memcpy (n->info[i], rec->info[i], rec->size[i]);
         }
     return n;
 }
+
+
+char *rec_strdup (const char *s, size_t *len)
+{
+    char *p;
+
+    if (!s)
+    {
+        *len = 0;
+        return NULL;
+    }
+    *len = strlen(s)+1;
+    p = xmalloc (*len);
+    strcpy (p, s);
+    return p;
+}
+