Bug fix: missing close (and leaking file handle)

[idzebra-moved-to-github.git] / isamb / isamb.c

diff --git a/isamb/isamb.c b/isamb/isamb.c
index 1e0a7dd..2ac59fb 100644 (file)
--- a/isamb/isamb.c
+++ b/isamb/isamb.c
@@ -1,9 +1,26 @@
-/*
- *  Copyright (c) 2000-2002, Index Data.
- *  See the file LICENSE for details.
- *
- *  $Id: isamb.c,v 1.18 2002-07-15 11:50:45 adam Exp $
- */
+/* $Id: isamb.c,v 1.23 2003-03-02 23:12:50 adam Exp $
+   Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003
+   Index Data Aps
+
+This file is part of the Zebra server.
+
+Zebra 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 2, or (at your option) any later
+version.
+
+Zebra 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 Zebra; see the file LICENSE.zebra.  If not, write to the
+Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+02111-1307, USA.
+*/
+
+#include <string.h>
 #include <yaz/xmalloc.h>
 #include <yaz/log.h>
 #include <isamb.h>
@@ -14,6 +31,7 @@ struct ISAMB_head {
     int last_block;
     int block_size;
     int block_max;
+    int free_list;
 };
 
 #define ISAMB_DATA_OFFSET 3
@@ -48,6 +66,8 @@ struct ISAMB_s {
     struct ISAMB_file *file;
     int no_cat;
     int cache; /* 0=no cache, 1=use cache, -1=dummy isam (for testing only) */
+    int log_io;        /* log level for bf_read/bf_write calls */
+    int log_freelist;  /* log level for freelist handling */
 };
 
 struct ISAMB_block {
@@ -56,10 +76,12 @@ struct ISAMB_block {
     int size;
     int leaf;
     int dirty;
+    int deleted;
     int offset;
     char *bytes;
     unsigned char *buf;
     void *decodeClientData;
+    int log_rw;
 };
 
 struct ISAMB_PP_s {
@@ -93,6 +115,7 @@ ISAMB isamb_open (BFiles bfs, const char *name, int writeflag, ISAMC_M method,
     isamb->method = (ISAMC_M) xmalloc (sizeof(*method));
     memcpy (isamb->method, method, sizeof(*method));
     isamb->no_cat = 4;
+    isamb->log_io = 0;
     isamb->cache = cache;
 
     isamb->file = xmalloc (sizeof(*isamb->file) * isamb->no_cat);
@@ -116,6 +139,7 @@ ISAMB isamb_open (BFiles bfs, const char *name, int writeflag, ISAMC_M method,
             isamb->file[i].head.last_block = isamb->file[i].head.first_block;
             isamb->file[i].head.block_size = b_size;
             isamb->file[i].head.block_max = b_size - ISAMB_DATA_OFFSET;
+            isamb->file[i].head.free_list = 0;
        }
         assert (isamb->file[i].head.block_size >= ISAMB_DATA_OFFSET);
         isamb->file[i].head_dirty = 0;
@@ -133,7 +157,10 @@ static void flush_blocks (ISAMB b, int cat)
         b->file[cat].cache_entries = ce_this->next;
 
         if (ce_this->dirty)
+        {
+            yaz_log (b->log_io, "bf_write: flush_blocks");
             bf_write (b->file[cat].bf, ce_this->pos, 0, 0, ce_this->buf);
+        }
         xfree (ce_this->buf);
         xfree (ce_this);
     }
@@ -183,7 +210,10 @@ static int get_block (ISAMB b, ISAMC_P pos, char *userbuf, int wr)
         ce_this = *ce_last;
         *ce_last = 0;  /* remove the last entry from list */
         if (ce_this->dirty)
+        {
+            yaz_log (b->log_io, "bf_write: get_block");
             bf_write (b->file[cat].bf, ce_this->pos, 0, 0, ce_this->buf);
+        }
         xfree (ce_this->buf);
         xfree (ce_this);
     }
@@ -192,6 +222,7 @@ static int get_block (ISAMB b, ISAMC_P pos, char *userbuf, int wr)
     b->file[cat].cache_entries = ce_this;
     ce_this->buf = xmalloc (ISAMB_CACHE_ENTRY_SIZE);
     ce_this->pos = norm;
+    yaz_log (b->log_io, "bf_read: get_block");
     if (!bf_read (b->file[cat].bf, norm, 0, 0, ce_this->buf))
         memset (ce_this->buf, 0, ISAMB_CACHE_ENTRY_SIZE);
     if (wr)
@@ -218,6 +249,7 @@ void isamb_close (ISAMB isamb)
             bf_write (isamb->file[i].bf, 0, 0,
                       sizeof(struct ISAMB_head), &isamb->file[i].head);
         
+        bf_close (isamb->file[i].bf);
     }
     xfree (isamb->file);
     xfree (isamb->method);
@@ -238,6 +270,7 @@ struct ISAMB_block *open_block (ISAMB b, ISAMC_P pos)
 
     if (!get_block (b, pos, p->buf, 0))
     {
+        yaz_log (b->log_io, "bf_read: open_block");
         if (!bf_read (b->file[cat].bf, pos/4, 0, 0, p->buf))
         {
             yaz_log (LOG_FATAL, "read failure for pos=%ld block=%ld",
@@ -250,6 +283,7 @@ struct ISAMB_block *open_block (ISAMB b, ISAMC_P pos)
     p->size = p->buf[1] + 256 * p->buf[2] - ISAMB_DATA_OFFSET;
     p->offset = 0;
     p->dirty = 0;
+    p->deleted = 0;
     p->decodeClientData = (*b->method->code_start)(ISAMC_DECODE);
     return p;
 }
@@ -257,20 +291,41 @@ struct ISAMB_block *open_block (ISAMB b, ISAMC_P pos)
 struct ISAMB_block *new_block (ISAMB b, int leaf, int cat)
 {
     struct ISAMB_block *p;
-    int block_no;
-    
+
     p = xmalloc (sizeof(*p));
-    block_no = b->file[cat].head.last_block++;
-    p->cat = cat;
-    p->pos = block_no * 4 + cat;
+    p->buf = xmalloc (b->file[cat].head.block_size);
+
+    if (!b->file[cat].head.free_list)
+    {
+        int block_no;
+        block_no = b->file[cat].head.last_block++;
+        p->pos = block_no * 4 + cat;
+    }
+    else
+    {
+        p->pos = b->file[cat].head.free_list;
+        if (!get_block (b, p->pos, p->buf, 0))
+        {
+            yaz_log (b->log_io, "bf_read: new_block");
+            if (!bf_read (b->file[cat].bf, p->pos/4, 0, 0, p->buf))
+            {
+                yaz_log (LOG_FATAL, "read failure for pos=%ld block=%ld",
+                         (long) p->pos/4, (long) p->pos/4);
+                abort ();
+            }
+        }
+        yaz_log (b->log_freelist, "got block %d from freelist %d:%d", p->pos,
+                 cat, p->pos/4);
+        memcpy (&b->file[cat].head.free_list, p->buf, sizeof(int));
+    }
     p->cat = cat;
     b->file[cat].head_dirty = 1;
-    p->buf = xmalloc (b->file[cat].head.block_size);
     memset (p->buf, 0, b->file[cat].head.block_size);
     p->bytes = p->buf + ISAMB_DATA_OFFSET;
     p->leaf = leaf;
     p->size = 0;
     p->dirty = 1;
+    p->deleted = 0;
     p->offset = 0;
     p->decodeClientData = (*b->method->code_start)(ISAMC_DECODE);
     return p;
@@ -291,14 +346,29 @@ void close_block (ISAMB b, struct ISAMB_block *p)
 {
     if (!p)
         return;
-    if (p->dirty)
+    if (p->deleted)
+    {
+        yaz_log (b->log_freelist, "release block %d from freelist %d:%d",
+                 p->pos, p->cat, p->pos/4);
+        memcpy (p->buf, &b->file[p->cat].head.free_list, sizeof(int));
+        b->file[p->cat].head.free_list = p->pos;
+        if (!get_block (b, p->pos, p->buf, 1))
+        {
+            yaz_log (b->log_io, "bf_write: close_block");
+            bf_write (b->file[p->cat].bf, p->pos/4, 0, 0, p->buf);
+        }
+    }
+    else if (p->dirty)
     {
         int size = p->size + ISAMB_DATA_OFFSET;
         p->buf[0] = p->leaf;
         p->buf[1] = size & 255;
         p->buf[2] = size >> 8;
         if (!get_block (b, p->pos, p->buf, 1))
+        {
+            yaz_log (b->log_io, "bf_write: close_block");
             bf_write (b->file[p->cat].bf, p->pos/4, 0, 0, p->buf);
+        }
     }
     (*b->method->code_stop)(ISAMC_DECODE, p->decodeClientData);
     xfree (p->buf);
@@ -583,6 +653,7 @@ int insert_leaf (ISAMB b, struct ISAMB_block **sp1, void *lookahead_item,
         new_size > b->file[p->cat].head.block_max)
     {
         /* non-btree block will be removed */
+        p->deleted = 1;
         close_block (b, p);
         /* delete it too!! */
         p = 0; /* make a new one anyway */
@@ -768,7 +839,7 @@ int isamb_block_info (ISAMB isamb, int cat)
 
 void isamb_pp_close (ISAMB_PP pp)
 {
-    return isamb_pp_close_x (pp, 0, 0);
+    isamb_pp_close_x (pp, 0, 0);
 }
 
 int isamb_pp_read (ISAMB_PP pp, void *buf)