ferret 0.11.6 → 0.11.8.4

data/ext/ferret.h

@@ -4,6 +4,8 @@
 #include "global.h"
 #include "hashset.h"
 #include "document.h"
+#include "symbol.h"
+#include "internal.h"
 
 /* IDs */
 extern ID id_new;
@@ -56,18 +58,19 @@ extern void object_set2(void *key, VALUE obj, const char *file, int line);
 //extern void object_del(void *key);
 #define object_del(key) object_del2(key,  __FILE__, __LINE__)
 extern void object_del2(void *key, const char *file, int line);
-extern void frt_gc_mark(void *key);
+extern void frb_gc_mark(void *key);
 extern VALUE object_get(void *key);
-extern VALUE frt_data_alloc(VALUE klass);
-extern void frt_deref_free(void *p);
-extern void frt_create_dir(VALUE rpath);
-extern VALUE frt_hs_to_rb_ary(HashSet *hs);
-extern void *frt_rb_data_ptr(VALUE val);
-extern char * frt_field(VALUE rfield);
-extern VALUE frt_get_term(const char *field, const char *term);
+extern VALUE frb_data_alloc(VALUE klass);
+extern void frb_deref_free(void *p);
+extern void frb_create_dir(VALUE rpath);
+extern VALUE frb_hs_to_rb_ary(HashSet *hs);
+extern void *frb_rb_data_ptr(VALUE val);
+extern Symbol frb_field(VALUE rfield);
+extern VALUE frb_get_term(Symbol field, const char *term);
 extern char *json_concat_string(char *s, char *field);
 extern char *rs2s(VALUE rstr);
-extern char *nstrdup(VALUE rstr);
+extern char *rstrdup(VALUE rstr);
+extern Symbol rintern(VALUE rstr);
 #define Frt_Make_Struct(klass)\
   rb_data_object_alloc(klass,NULL,(RUBY_DATA_FUNC)NULL,(RUBY_DATA_FUNC)NULL)
 
@@ -87,5 +90,5 @@ extern char *nstrdup(VALUE rstr);
 
 #endif
 
-#define frt_mark_cclass(klass) rb_ivar_set(klass, id_cclass, Qtrue)
-#define frt_is_cclass(obj) (rb_ivar_get(CLASS_OF(obj), id_cclass) == Qtrue)
+#define frb_mark_cclass(klass) rb_ivar_set(klass, id_cclass, Qtrue)
+#define frb_is_cclass(obj) (rb_ivar_get(CLASS_OF(obj), id_cclass) == Qtrue)

data/ext/field_index.c

@@ -0,0 +1,262 @@
+#include <string.h>
+#include "field_index.h"
+#include "internal.h"
+
+/***************************************************************************
+ *
+ * FieldIndex
+ *
+ ***************************************************************************/
+
+static unsigned long field_index_hash(const void *p)
+{
+    FieldIndex *self = (FieldIndex *)p;
+    return sym_hash(self->field) ^ (unsigned long)(self->klass);
+}
+
+static int field_index_eq(const void *p1, const void *p2)
+{
+    FieldIndex *fi1 = (FieldIndex *)p1;
+    FieldIndex *fi2 = (FieldIndex *)p2;
+    return (fi1->field == fi2->field) &&
+        (fi1->klass->type == fi2->klass->type);
+}
+
+static void field_index_destroy(void *p)
+{
+    FieldIndex *self = (FieldIndex *)p;
+    if (self->index) {
+        self->klass->destroy_index(self->index);
+    }
+    free(self);
+}
+
+FieldIndex *field_index_get(IndexReader *ir, Symbol field,
+                            const FieldIndexClass *klass)
+{
+    int length = 0;
+    TermEnum *volatile te = NULL;
+    TermDocEnum *volatile tde = NULL;
+    FieldInfo *fi = fis_get_field(ir->fis, field);
+    const volatile int field_num = fi ? fi->number : -1;
+    FieldIndex *volatile self = NULL;
+    FieldIndex key;
+
+    if (field_num < 0) {
+        RAISE(ARG_ERROR,
+              "Cannot sort by field \"%s\". It doesn't exist in the index.",
+              S(field));
+    }
+
+    if (!ir->field_index_cache) {
+        ir->field_index_cache = h_new(&field_index_hash, &field_index_eq,
+                                      NULL, &field_index_destroy);
+    }
+
+    key.field = field;
+    key.klass = klass;
+    self = (FieldIndex *)h_get(ir->field_index_cache, &key);
+
+    if (self == NULL) {
+        self = ALLOC(FieldIndex);
+        self->klass = klass;
+        /* FieldIndex only lives as long as the IndexReader lives so we can
+         * just use the field_infos field string */
+        self->field = fi->name;
+
+        length = ir->max_doc(ir);
+        if (length > 0) {
+            TRY
+            {
+                void *index;
+                tde = ir->term_docs(ir);
+                te = ir->terms(ir, field_num);
+                index = self->index = klass->create_index(length);
+                while (te->next(te)) {
+                    tde->seek_te(tde, te);
+                    klass->handle_term(index, tde, te->curr_term);
+                }
+            }
+            XFINALLY
+                tde->close(tde);
+                te->close(te);
+            XENDTRY
+        }
+        h_set(ir->field_index_cache, self, self);
+    }
+
+    return self;
+}
+
+/******************************************************************************
+ * ByteFieldIndex < FieldIndex
+ *
+ * The ByteFieldIndex holds an array of integers for each document in the
+ * index where the integer represents the sort value for the document.  This
+ * index should only be used for sorting and not as a field cache of the
+ * column's value.
+ ******************************************************************************/
+static void byte_handle_term(void *index_ptr,
+                             TermDocEnum *tde,
+                             const char *text)
+{
+    long *index = (long *)index_ptr;
+    long val = index[-1]++;
+    (void)text;
+    while (tde->next(tde)) {
+        index[tde->doc_num(tde)] = val;
+    }
+}
+
+static void *byte_create_index(int size)
+{
+    long *index = ALLOC_AND_ZERO_N(long, size + 1);
+    index[0] = 1;
+    return &index[1];
+}
+
+static void byte_destroy_index(void *p)
+{
+    long *index = (long *)p;
+    free(&index[-1]);
+}
+
+const FieldIndexClass BYTE_FIELD_INDEX_CLASS = {
+    "byte",
+    &byte_create_index,
+    &byte_destroy_index,
+    &byte_handle_term
+};
+
+/******************************************************************************
+ * IntegerFieldIndex < FieldIndex
+ ******************************************************************************/
+static void *integer_create_index(int size)
+{
+    return ALLOC_AND_ZERO_N(long, size);
+}
+
+static void integer_handle_term(void *index_ptr,
+                                TermDocEnum *tde,
+                                const char *text)
+{
+    long *index = (long *)index_ptr;
+    long val;
+    sscanf(text, "%ld", &val);
+    while (tde->next(tde)) {
+        index[tde->doc_num(tde)] = val;
+    }
+}
+
+const FieldIndexClass INTEGER_FIELD_INDEX_CLASS = {
+    "integer",
+    &integer_create_index,
+    &free,
+    &integer_handle_term
+};
+
+long get_integer_value(FieldIndex *field_index, long doc_num)
+{
+    if (field_index->klass == &INTEGER_FIELD_INDEX_CLASS && doc_num >= 0) {
+        return ((long *)field_index->index)[doc_num];
+    }
+    return 0l;
+}
+
+
+/******************************************************************************
+ * FloatFieldIndex < FieldIndex
+ ******************************************************************************/
+#define VALUES_ARRAY_START_SIZE 8
+static void *float_create_index(int size)
+{
+    return ALLOC_AND_ZERO_N(float, size);
+}
+
+static void float_handle_term(void *index_ptr,
+                              TermDocEnum *tde,
+                              const char *text)
+{
+    float *index = (float *)index_ptr;
+    float val;
+    sscanf(text, "%g", &val);
+    while (tde->next(tde)) {
+        index[tde->doc_num(tde)] = val;
+    }
+}
+
+const FieldIndexClass FLOAT_FIELD_INDEX_CLASS = {
+    "float",
+    &float_create_index,
+    &free,
+    &float_handle_term
+};
+
+float get_float_value(FieldIndex *field_index, long doc_num)
+{
+    if (field_index->klass == &FLOAT_FIELD_INDEX_CLASS && doc_num >= 0) {
+        return ((float *)field_index->index)[doc_num];
+    }
+    return 0.0f;
+}
+
+/******************************************************************************
+ * StringFieldIndex < FieldIndex
+ ******************************************************************************/
+ 
+static void *string_create_index(int size)
+{
+    StringIndex *self = ALLOC_AND_ZERO(StringIndex);
+    self->size = size;
+    self->index = ALLOC_AND_ZERO_N(long, size);
+    self->v_capa = VALUES_ARRAY_START_SIZE;
+    self->v_size = 1; /* leave the first value as NULL */
+    self->values = ALLOC_AND_ZERO_N(char *, VALUES_ARRAY_START_SIZE);
+    return self;
+}
+
+static void string_destroy_index(void *p)
+{
+    StringIndex *self = (StringIndex *)p;
+    int i;
+    free(self->index);
+    for (i = 0; i < self->v_size; i++) {
+        free(self->values[i]);
+    }
+    free(self->values);
+    free(self);
+}
+
+static void string_handle_term(void *index_ptr,
+                               TermDocEnum *tde,
+                               const char *text)
+{
+    StringIndex *index = (StringIndex *)index_ptr;
+    if (index->v_size >= index->v_capa) {
+        index->v_capa *= 2;
+        index->values = REALLOC_N(index->values, char *, index->v_capa);
+    }
+    index->values[index->v_size] = estrdup(text);
+    while (tde->next(tde)) {
+        index->index[tde->doc_num(tde)] = index->v_size;
+    }
+    index->v_size++;
+}
+
+const FieldIndexClass STRING_FIELD_INDEX_CLASS = {
+    "string",
+    &string_create_index,
+    &string_destroy_index,
+    &string_handle_term
+};
+
+const char *get_string_value(FieldIndex *field_index, long doc_num)
+{
+    if (field_index->klass == &STRING_FIELD_INDEX_CLASS) {
+        StringIndex *string_index = (StringIndex *)field_index->index;
+        if (doc_num >= 0 && doc_num < string_index->size) {
+            return string_index->values[string_index->index[doc_num]];
+        }
+    }
+    return NULL;
+}

data/ext/field_index.h

@@ -0,0 +1,52 @@
+#ifndef FRT_FIELD_INDEX_H
+#define FRT_FIELD_INDEX_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "index.h"
+
+/***************************************************************************
+ *
+ * FrtFieldIndex
+ *
+ ***************************************************************************/
+
+typedef struct FrtStringIndex {
+    int size;
+    long *index;
+    char **values;
+    int v_size;
+    int v_capa;
+} FrtStringIndex;
+
+typedef struct FrtFieldIndexClass {
+    const char *type;
+    void *(*create_index)(int size);
+    void  (*destroy_index)(void *p);
+    void  (*handle_term)(void *index, FrtTermDocEnum *tde, const char *text);
+} FrtFieldIndexClass;
+
+typedef struct FrtFieldIndex {
+    FrtSymbol field;
+    const FrtFieldIndexClass *klass;
+    void *index;
+} FrtFieldIndex;
+
+extern const FrtFieldIndexClass FRT_INTEGER_FIELD_INDEX_CLASS;
+extern const FrtFieldIndexClass   FRT_FLOAT_FIELD_INDEX_CLASS;
+extern const FrtFieldIndexClass  FRT_STRING_FIELD_INDEX_CLASS;
+extern const FrtFieldIndexClass    FRT_BYTE_FIELD_INDEX_CLASS;
+
+extern FrtFieldIndex *frt_field_index_get(FrtIndexReader *ir, FrtSymbol field,
+                                   const FrtFieldIndexClass *klass);
+extern const char *frt_get_string_value(FrtFieldIndex *field_index, long doc_num);
+extern float frt_get_float_value(FrtFieldIndex *field_index, long doc_num);
+extern long frt_get_integer_value(FrtFieldIndex *field_index, long doc_num);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif

data/ext/filter.c

@@ -1,5 +1,7 @@
 #include "search.h"
+#include "symbol.h"
 #include <string.h>
+#include "internal.h"
 
 /***************************************************************************
  *
@@ -10,7 +12,6 @@
 void filt_destroy_i(Filter *filt)
 {
     h_destroy(filt->cache);
-    free(filt->name);
     free(filt);
 }
 void filt_deref(Filter *filt)
@@ -22,7 +23,7 @@ void filt_deref(Filter *filt)
 
 BitVector *filt_get_bv(Filter *filt, IndexReader *ir)
 {
-    CacheObject *co = h_get(filt->cache, ir);
+    CacheObject *co = (CacheObject *)h_get(filt->cache, ir);
 
     if (!co) {
         BitVector *bv;
@@ -38,26 +39,26 @@ BitVector *filt_get_bv(Filter *filt, IndexReader *ir)
 
 static char *filt_to_s_i(Filter *filt)
 {
-    return estrdup(filt->name);
+    return estrdup(S(filt->name));
 }
 
-unsigned long filt_hash_default(Filter *filt)
+static unsigned long filt_hash_default(Filter *filt)
 {
     (void)filt;
     return 0;
 }
 
-int filt_eq_default(Filter *filt, Filter *o)
+static int filt_eq_default(Filter *filt, Filter *o)
 {
     (void)filt; (void)o;
     return false;
 }
 
-Filter *filt_create(size_t size, const char *name)
+Filter *filt_create(size_t size, Symbol name)
 {
     Filter *filt    = (Filter *)emalloc(size);
     filt->cache     = co_hash_create();
-    filt->name      = estrdup(name);
+    filt->name      = name;
     filt->to_s      = &filt_to_s_i;
     filt->hash      = &filt_hash_default;
     filt->eq        = &filt_eq_default;
@@ -68,13 +69,13 @@ Filter *filt_create(size_t size, const char *name)
 
 unsigned long filt_hash(Filter *filt)
 {
-    return str_hash(filt->name) ^ filt->hash(filt);
+    return sym_hash(filt->name) ^ filt->hash(filt);
 }
 
 int filt_eq(Filter *filt, Filter *o)
 {
     return ((filt == o)
-            || ((strcmp(filt->name, o->name) == 0)
+            || ((filt->name == o->name)
                 && (filt->eq == o->eq)
                 && (filt->eq(filt, o))));
 }
@@ -95,7 +96,7 @@ typedef struct QueryFilter
 static char *qfilt_to_s(Filter *filt)
 {
     Query *query = QF(filt)->query;
-    char *query_str = query->to_s(query, "");
+    char *query_str = query->to_s(query, NULL);
     char *filter_str = strfmt("QueryFilter< %s >", query_str);
     free(query_str);
     return filter_str;

data/ext/fs_store.c

@@ -1,4 +1,5 @@
 #include "store.h"
+#include "lang.h"
 #include <time.h>
 #include <sys/types.h>
 #include <fcntl.h>
@@ -14,6 +15,7 @@
 # endif
 # ifndef DIR_SEPARATOR
 #   define DIR_SEPARATOR "\\"
+#   define DIR_SEPARATOR_CHAR '\\'
 # endif
 # ifndef S_IRUSR
 #   define S_IRUSR _S_IREAD
@@ -23,18 +25,14 @@
 # endif
 #else
 # define DIR_SEPARATOR "/"
+# define DIR_SEPARATOR_CHAR '/'
 # include <unistd.h>
 # include <dirent.h>
 #endif
 #ifndef O_BINARY
 # define O_BINARY 0
 #endif
-
-extern Store *store_new();
-extern void store_destroy(Store *store);
-extern OutStream *os_new();
-extern InStream *is_new();
-extern int file_is_lock(char *filename);
+#include "internal.h"
 
 /**
  * Create a filepath for a file in the store using the operating systems
@@ -46,7 +44,7 @@ static char *join_path(char *buf, const char *base, const char *filename)
   return buf;
 }
 
-static void fs_touch(Store *store, char *filename)
+static void fs_touch(Store *store, const char *filename)
 {
     int f;
     char path[MAX_FILE_PATH];
@@ -58,7 +56,7 @@ static void fs_touch(Store *store, char *filename)
     close(f);
 }
 
-static int fs_exists(Store *store, char *filename)
+static int fs_exists(Store *store, const char *filename)
 {
     int fd;
     char path[MAX_FILE_PATH];
@@ -75,13 +73,13 @@ static int fs_exists(Store *store, char *filename)
     return true;
 }
 
-static int fs_remove(Store *store, char *filename)
+static int fs_remove(Store *store, const char *filename)
 {
     char path[MAX_FILE_PATH];
     return remove(join_path(path, store->dir.path, filename));
 }
 
-static void fs_rename(Store *store, char *from, char *to)
+static void fs_rename(Store *store, const char *from, const char *to)
 {
     char path1[MAX_FILE_PATH], path2[MAX_FILE_PATH];
 
@@ -117,7 +115,7 @@ static int fs_count(Store *store)
     return cnt;
 }
 
-static void fs_each(Store *store, void (*func)(char *fname, void *arg), void *arg)
+static void fs_each(Store *store, void (*func)(const char *fname, void *arg), void *arg)
 {
     struct dirent *de;
     DIR *d = opendir(store->dir.path);
@@ -155,6 +153,20 @@ static void fs_clear_locks(Store *store)
     closedir(d);
 }
 
+static void remove_if_index_file(const char *base_path, const char *file_name)
+{
+    char path[MAX_FILE_PATH];
+    char *basename;
+    join_path(path, base_path, file_name);
+    /* get basename of path */
+    basename = strrchr(path, DIR_SEPARATOR_CHAR);
+    basename = (basename ? basename + 1 : path);
+    /* we don't want to delete non-index files here */
+    if (file_name_filter_is_index_file(basename, true)) {
+        remove(path);
+    }
+}
+
 static void fs_clear(Store *store)
 {
     struct dirent *de;
@@ -168,13 +180,16 @@ static void fs_clear(Store *store)
     while ((de = readdir(d)) != NULL) {
         if (de->d_name[0] > '/' /* skip ., .., / and '\0'*/
                 && !file_is_lock(de->d_name)) {
-            char path[MAX_FILE_PATH];
-            remove(join_path(path, store->dir.path, de->d_name));
+            remove_if_index_file(store->dir.path, de->d_name);
         }
     }
     closedir(d);
 }
 
+/**
+ * Clear all files which belong to the index. Use fs_clear to clear the
+ * directory regardless of the files origin.
+ */
 static void fs_clear_all(Store *store)
 {
     struct dirent *de;
@@ -187,8 +202,7 @@ static void fs_clear_all(Store *store)
 
     while ((de = readdir(d)) != NULL) {
         if (de->d_name[0] > '/') { /* skip ., .., / and '\0'*/
-            char path[MAX_FILE_PATH];
-            remove(join_path(path, store->dir.path, de->d_name));
+            remove_if_index_file(store->dir.path, de->d_name);
         }
     }
     closedir(d);
@@ -211,7 +225,7 @@ static void fs_destroy(Store *store)
     store_destroy(store);
 }
 
-static off_t fs_length(Store *store, char *filename)
+static off_t fs_length(Store *store, const char *filename)
 {
     char path[MAX_FILE_PATH];
     struct stat stt;
@@ -224,7 +238,7 @@ static off_t fs_length(Store *store, char *filename)
     return stt.st_size;
 }
 
-static void fso_flush_i(OutStream *os, uchar *src, int len)
+static void fso_flush_i(OutStream *os, const uchar *src, int len)
 {
     if (len != write(os->file.fd, src, len)) {
         RAISE(IO_ERROR, "flushing src of length %d, <%s>", len,
@@ -235,7 +249,7 @@ static void fso_flush_i(OutStream *os, uchar *src, int len)
 static void fso_seek_i(OutStream *os, off_t pos)
 {
     if (lseek(os->file.fd, pos, SEEK_SET) < 0) {
-        RAISE(IO_ERROR, "seeking position %"F_OFF_T_PFX"d: <%s>",
+        RAISE(IO_ERROR, "seeking position %"OFF_T_PFX"d: <%s>",
               pos, strerror(errno));
     }
 }
@@ -247,7 +261,7 @@ static void fso_close_i(OutStream *os)
     }
 }
 
-const struct OutStreamMethods FS_OUT_STREAM_METHODS = {
+static const struct OutStreamMethods FS_OUT_STREAM_METHODS = {
     fso_flush_i,
     fso_seek_i,
     fso_close_i
@@ -289,7 +303,7 @@ static void fsi_read_i(InStream *is, uchar *path, int len)
 static void fsi_seek_i(InStream *is, off_t pos)
 {
     if (lseek(is->file.fd, pos, SEEK_SET) < 0) {
-        RAISE(IO_ERROR, "seeking pos %"F_OFF_T_PFX"d: <%s>",
+        RAISE(IO_ERROR, "seeking pos %"OFF_T_PFX"d: <%s>",
               pos, strerror(errno));
     }
 }
@@ -297,7 +311,7 @@ static void fsi_seek_i(InStream *is, off_t pos)
 static void fsi_close_i(InStream *is)
 {
     if (close(is->file.fd)) {
-        RAISE(IO_ERROR, strerror(errno));
+        RAISE(IO_ERROR, "%s", strerror(errno));
     }
     free(is->d.path);
 }
@@ -337,10 +351,6 @@ static InStream *fs_open_input(Store *store, const char *filename)
 
 #define LOCK_OBTAIN_TIMEOUT 10
 
-#ifdef RUBY_BINDINGS
-struct timeval rb_time_interval _((VALUE));
-#endif
-
 static int fs_lock_obtain(Lock *lock)
 {
     int f;
@@ -377,12 +387,12 @@ static int fs_lock_is_locked(Lock *lock)
     }
 }
 
-void fs_lock_release(Lock *lock)
+static void fs_lock_release(Lock *lock)
 {
     remove(lock->name);
 }
 
-static Lock *fs_open_lock_i(Store *store, char *lockname)
+static Lock *fs_open_lock_i(Store *store, const char *lockname)
 {
     Lock *lock = ALLOC(Lock);
     char lname[100];
@@ -403,19 +413,7 @@ static void fs_close_lock_i(Lock *lock)
     free(lock);
 }
 
-static HashTable stores = {
-    /* fill */       0,
-    /* used */       0,
-    /* mask */       HASH_MINSIZE - 1,
-    /* ref_cnt */    1,
-    /* table */      stores.smalltable,
-    /* smalltable */ {{0, NULL, NULL}},
-    /* lookup */     (h_lookup_ft)&h_lookup_str,
-    /* hash */       NULL,
-    /* eq */         NULL,
-    /* free_key */   (free_ft)&dummy_free,
-    /* free_value */ (free_ft)&fs_destroy
-};
+static Hash *stores = NULL;
 
 #ifndef UNTHREADED
 static mutex_t stores_mutex = MUTEX_INITIALIZER;
@@ -424,7 +422,7 @@ static mutex_t stores_mutex = MUTEX_INITIALIZER;
 static void fs_close_i(Store *store)
 {
     mutex_lock(&stores_mutex);
-    h_del(&stores, store->dir.path);
+    h_del(stores, store->dir.path);
     mutex_unlock(&stores_mutex);
 }
 
@@ -435,11 +433,26 @@ static Store *fs_store_new(const char *pathname)
 
     new_store->file_mode = S_IRUSR | S_IWUSR;
 #ifndef POSH_OS_WIN32
-    if (!stat(pathname, &stt) && stt.st_gid == getgid()) {
-        if (stt.st_mode & S_IWGRP) {
-            umask(S_IWOTH);
+    if (!stat(pathname, &stt)) {
+        gid_t st_gid = stt.st_gid;
+        bool is_grp = (st_gid == getgid());
+
+        if (!is_grp) {
+            int size = getgroups(0, NULL);
+            gid_t list[size];
+
+            if (getgroups(size, list) != -1) {
+                int i = 0;
+                while (i < size && !(is_grp = (st_gid == list[i]))) i++;
+            }
+        }
+
+        if (is_grp) {
+            if (stt.st_mode & S_IWGRP) {
+                umask(S_IWOTH);
+            }
+            new_store->file_mode |= stt.st_mode & (S_IRGRP | S_IWGRP);
         }
-        new_store->file_mode |= stt.st_mode & (S_IRGRP | S_IWGRP);
     }
 #endif
 
@@ -466,8 +479,13 @@ Store *open_fs_store(const char *pathname)
 {
     Store *store = NULL;
 
+    if (!stores) {
+        stores = h_new_str(NULL, (free_ft)fs_destroy);
+        register_for_cleanup(stores, (free_ft)h_destroy);
+    }
+
     mutex_lock(&stores_mutex);
-    store = h_get(&stores, pathname);
+    store = (Store *)h_get(stores, pathname);
     if (store) {
         mutex_lock(&store->mutex);
         store->ref_cnt++;
@@ -475,7 +493,7 @@ Store *open_fs_store(const char *pathname)
     }
     else {
         store = fs_store_new(pathname);
-        h_set(&stores, store->dir.path, store);
+        h_set(stores, store->dir.path, store);
     }
     mutex_unlock(&stores_mutex);