Revert "Store per-session symtabs in private storage."

This reverts commit 5fc59f5271d5ca06374782848bcd53adecfffcf1, which
in fact pertains to 4.1 branch.

1 files changed, 48 insertions, 43 deletions

diff --git a/src/variable.c b/src/variable.c
index acdc6f6..bd79c3b 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -310,6 +310,10 @@ symtab_free(struct symtab *st)
 }
 
 
+static struct symtab **symtabv;
+static size_t symtabc;
+static pthread_mutex_t symtab_mtx = PTHREAD_MUTEX_INITIALIZER;
+
 static struct symtab *global_symtab;
 static pthread_mutex_t global_mtx = PTHREAD_MUTEX_INITIALIZER;
 
@@ -377,20 +381,26 @@ vmod_global_unset(VARIABLE_CTX ctx, VCL_STRING name)
         AZ(pthread_mutex_unlock(&global_mtx));
 }
 
-static void
-priv_symtab_free(void *p)
-{
-        symtab_free(p);
-}
-
 static struct symtab *
-get_symtab(struct vmod_priv *priv)
-{
-        if (!priv->priv) {
-                priv->priv = symtab_create();
-                priv->free = priv_symtab_free;
-        }
-        return priv->priv;
+get_symtab(VARIABLE_CTX ctx)
+{
+        struct symtab *st;
+        int fd = ctx->req->sp->fd;
+        AZ(pthread_mutex_lock(&symtab_mtx));
+        if (symtabc <= fd) {
+                size_t n = fd + 1;
+                symtabv = realloc(symtabv, n * sizeof(symtabv[0]));
+                while (symtabc < n)
+                        symtabv[symtabc++] = NULL;
+        }
+        if (!symtabv[fd])
+                symtabv[fd] = symtab_create();
+        st = symtabv[fd];
+        if (st->vxid != ctx->req->sp->vxid)
+                symtab_clear(st);
+        st->vxid = ctx->req->sp->vxid;
+        AZ(pthread_mutex_unlock(&symtab_mtx));
+        return st;
 }
 
 #define getvar(vt, name) symtab_lookup_or_install(vt, name, NULL)
@@ -412,25 +422,24 @@ defvar(struct symtab *vt, const char *name, enum variable_type t,
 }
 
 VCL_VOID
-vmod_clear(VARIABLE_CTX ctx, struct vmod_priv *priv)
+vmod_clear(VARIABLE_CTX ctx)
 {
-        symtab_clear(get_symtab(priv));
+        symtab_clear(get_symtab(ctx));
 }
 
 VCL_STRING
-vmod_get_string(VARIABLE_CTX ctx, struct vmod_priv *priv, VCL_STRING name)
+vmod_get_string(VARIABLE_CTX ctx, VCL_STRING name)
 {
-        struct variable *var = getvar(get_symtab(priv), name);
+        struct variable *var = getvar(get_symtab(ctx), name);
         if (var && var->type == variable_string)
                 return var->v.s;
         return NULL;
 }
 
 VCL_VOID
-vmod_set_string(VARIABLE_CTX ctx, struct vmod_priv *priv,
-                VCL_STRING name, VCL_STRING value)
+vmod_set_string(VARIABLE_CTX ctx, VCL_STRING name, VCL_STRING value)
 {
-        struct symtab *vt = get_symtab(priv);
+        struct symtab *vt = get_symtab(ctx);
         struct variable *var = defvar(vt, name, variable_unset, NULL);
         var->type = variable_string;
         var->v.s = strdup(value ? value : "");
@@ -438,25 +447,23 @@ vmod_set_string(VARIABLE_CTX ctx, struct vmod_priv *priv,
 }
 
 VCL_STRING
-vmod_get(VARIABLE_CTX ctx, struct vmod_priv *priv, VCL_STRING name)
+vmod_get(VARIABLE_CTX ctx, VCL_STRING name)
 {
-        return vmod_get_string(ctx, priv, name);
+        return vmod_get_string(ctx, name);
 }
 
 VCL_VOID
-vmod_set(VARIABLE_CTX ctx, struct vmod_priv *priv,
-         VCL_STRING name, VCL_STRING value)
+vmod_set(VARIABLE_CTX ctx, VCL_STRING name, VCL_STRING value)
 {
-        vmod_set_string(ctx, priv, name, value);
+        vmod_set_string(ctx, name, value);
 }
 
 #define __cat__(a,b) a ## b
 #define DEFGET(r_type, vcl_type, memb)                              \
 vcl_type                                                            \
-__cat__(vmod_get_,r_type)(VARIABLE_CTX ctx, struct vmod_priv *priv, \
-                          VCL_STRING name)                          \
+__cat__(vmod_get_,r_type)(VARIABLE_CTX ctx, VCL_STRING name)        \
 {                                                                   \
-        struct variable *var = getvar(get_symtab(priv), name);      \
+        struct variable *var = getvar(get_symtab(ctx), name);       \
         if (var && var->type == __cat__(variable_,r_type))          \
                 return var->v.memb;                                 \
         return 0;                                                   \
@@ -464,11 +471,10 @@ __cat__(vmod_get_,r_type)(VARIABLE_CTX ctx, struct vmod_priv *priv, \
 
 #define DEFSET(r_type, vcl_type, memb)                              \
 VCL_VOID                                                            \
-__cat__(vmod_set_,r_type)(VARIABLE_CTX ctx, struct vmod_priv *priv, \
-                          VCL_STRING name,                          \
+__cat__(vmod_set_,r_type)(VARIABLE_CTX ctx, VCL_STRING name,        \
                           vcl_type value)                           \
 {                                                                   \
-        struct symtab *vt = get_symtab(priv);                          \
+        struct symtab *vt = get_symtab(ctx);                           \
         struct variable *var = defvar(vt, name, variable_unset, NULL); \
         var->type = __cat__(variable_,r_type);                      \
         var->v.memb = value;                                        \
@@ -483,22 +489,22 @@ DEF(real, VCL_REAL, r)
 DEF(duration, VCL_DURATION, d)
 
 VCL_BOOL
-vmod_defined(VARIABLE_CTX ctx, struct vmod_priv *priv, VCL_STRING name)
+vmod_defined(VARIABLE_CTX ctx, VCL_STRING name)
 {
-        return !!getvar(get_symtab(priv), name);
+        return !!getvar(get_symtab(ctx), name);
 }
 
 VCL_STRING
-vmod_type_of(VARIABLE_CTX ctx, struct vmod_priv *priv, VCL_STRING name)
+vmod_type_of(VARIABLE_CTX ctx, VCL_STRING name)
 {
-        struct variable *var = getvar(get_symtab(priv), name);
+        struct variable *var = getvar(get_symtab(ctx), name);
         return typestr[var ? var->type : variable_unset];
 }
 
 VCL_VOID
-vmod_unset(VARIABLE_CTX ctx, struct vmod_priv *priv, VCL_STRING name)
+vmod_unset(VARIABLE_CTX ctx, VCL_STRING name)
 {
-        symtab_remove(get_symtab(priv), name);
+        symtab_remove(get_symtab(ctx), name);
 }
 
 static void
@@ -710,10 +716,10 @@ setval(union value *val, const char *s, enum variable_type type, char **err)
 }
 
 VCL_VOID
-vmod_regset(VARIABLE_CTX ctx, struct vmod_priv *priv,
-            VCL_STRING vars, VCL_STRING rxs, VCL_STRING input)
+vmod_regset(VARIABLE_CTX ctx, VCL_STRING vars, VCL_STRING rxs,
+            VCL_STRING input)
 {
-        struct symtab *vt = get_symtab(priv);
+        struct symtab *vt = get_symtab(ctx);
         struct vardef *head = NULL, *tail = NULL, *def;
         size_t count = 0;
         size_t n;
@@ -887,10 +893,9 @@ define_param(struct symtab *vt, struct vardef *def,
 }
 
 VCL_VOID
-vmod_queryset(VARIABLE_CTX ctx, struct vmod_priv *priv,
-              VCL_STRING vars, VCL_STRING query)
+vmod_queryset(VARIABLE_CTX ctx, VCL_STRING vars, VCL_STRING query)
 {
-        struct symtab *vt = get_symtab(priv);
+        struct symtab *vt = get_symtab(ctx);
         struct vardef *head = NULL, *tail = NULL, *def;
         size_t count = 0;
         size_t n;