Changeset cb257d


Ignore:
Timestamp:
2009-11-27 12:06:32 (4 years ago)
Author:
Poul-Henning Kamp <phk@…>
Branches:
2.1, tags/varnish-2.1.0, tags/varnish-2.1.1, tags/varnish-2.1.2, tags/varnish-2.1.3, tags/varnish-2.1.4
Children:
b4ebe7
Parents:
e0cf3f7
git-author:
Poul-Henning Kamp <phk@…> (2009-11-27 12:06:32)
git-committer:
Poul-Henning Kamp <phk@…> (2009-11-27 12:06:32)
Message:

Eliminate the obj.hash hack.

This was originally a quick hack to allow purging to take the Host:
header into account.

We have a much better and precisely expressive purge syntax now, so
this hack can die.

git-svn-id:  http://www.varnish-cache.org/svn/trunk@4376 d4fa192b-c00b-0410-8231-f00ffab90ce4

Files:
23 edited

Legend:

Unmodified
Added
Removed
  • bin/varnishd/cache.h

    r181c28 rcb257d  
    423423        struct acct             acct; 
    424424        struct acct             acct_req; 
    425  
    426         /* pointers to hash string components */ 
    427         unsigned                nhashptr; 
    428         unsigned                ihashptr; 
    429         unsigned                lhashptr; 
    430         const char              **hashptr; 
    431425 
    432426#if defined(HAVE_EPOLL_CTL) 
  • bin/varnishd/cache_ban.c

    r181c28 rcb257d  
    161161 
    162162static int 
    163 ban_cond_hash(const struct ban_test *bt, const struct object *o, 
    164    const struct sess *sp) 
    165 { 
    166         (void)sp; 
    167         CHECK_OBJ_NOTNULL(o, OBJECT_MAGIC); 
    168         CHECK_OBJ_NOTNULL(o->objcore, OBJCORE_MAGIC); 
    169         CHECK_OBJ_NOTNULL(o->objcore->objhead, OBJHEAD_MAGIC); 
    170         AN(o->objcore->objhead->hash); 
    171         return(ban_cond_str(bt, o->objcore->objhead->hash)); 
    172 } 
    173  
    174 static int 
    175163ban_cond_req_http(const struct ban_test *bt, const struct object *o, 
    176164   const struct sess *sp) 
     
    760748ccf_purge_hash(struct cli *cli, const char * const *av, void *priv) 
    761749{ 
    762         const char *aav[6]; 
    763  
     750 
     751        (void)av; 
    764752        (void)priv; 
    765         if (!save_hash) { 
    766                 cli_out(cli, 
    767                     "purge.hash not possible.\n" 
    768                     "Set the \"purge_hash\" parameter to on\n" 
    769                     "and restart the varnish worker process to enable.\n"); 
    770                 cli_result(cli, CLIS_CANT); 
    771                 return; 
    772         } 
    773         aav[0] = NULL; 
    774         aav[1] = "purge"; 
    775         aav[2] = "obj.hash"; 
    776         aav[3] = "~"; 
    777         aav[4] = av[2]; 
    778         aav[5] = NULL; 
    779         ccf_purge(cli, aav, priv); 
     753        cli_out(cli, "purge.hash is no longer supported.\n"); 
     754        cli_result(cli, CLIS_CANT); 
     755        return; 
    780756} 
    781757 
     
    820796         */ 
    821797        { CLI_HIDDEN("url.purge", 1, 1)         ccf_purge_url }, 
    822         { CLI_HIDDEN("hash.purge", 1, 1)        ccf_purge_hash }, 
     798        { CLI_HIDDEN("hash.purge", 0, 1)        ccf_purge_hash }, 
     799        { CLI_HIDDEN("purge.hash", 0, 1)        ccf_purge_hash }, 
    823800 
    824801        { CLI_PURGE_URL,                        ccf_purge_url }, 
    825         { CLI_PURGE_HASH,                       ccf_purge_hash }, 
    826802        { CLI_PURGE,                            ccf_purge }, 
    827803        { CLI_PURGE_LIST,                       ccf_purge_list }, 
  • bin/varnishd/cache_center.c

    r181c28 rcb257d  
    777777 
    778778        if (sp->obj == NULL) { 
    779                 HSH_BeforeVclHash(sp, sp->vcl->nhashcount); 
     779                HSH_BeforeVclHash(sp); 
    780780                VCL_hash_method(sp); 
    781781                assert(sp->handling == VCL_RET_HASH); 
  • bin/varnishd/cache_hash.c

    r181c28 rcb257d  
    7272 
    7373static const struct hash_slinger *hash; 
    74 unsigned        save_hash; 
    7574 
    7675double 
     
    158157        Lck_Delete(&oh->mtx); 
    159158        w->stats.n_objecthead--; 
    160         free(oh->hash); 
    161159        FREE_OBJ(oh); 
    162160} 
     
    175173 
    176174void 
    177 HSH_Copy(const struct sess *sp, struct objhead *oh) 
    178 { 
    179         unsigned u, v; 
    180         char *b; 
    181  
    182         CHECK_OBJ_NOTNULL(sp, SESS_MAGIC); 
    183         CHECK_OBJ_NOTNULL(oh, OBJHEAD_MAGIC); 
    184         if (!save_hash) 
    185                 return; 
    186  
    187         oh->hash = malloc(sp->lhashptr); 
    188         XXXAN(oh->hash); 
    189         b = oh->hash; 
    190         for (u = 0; u < sp->ihashptr; u += 2) { 
    191                 v = pdiff(sp->hashptr[u], sp->hashptr[u + 1]); 
    192                 memcpy(b, sp->hashptr[u], v); 
    193                 b += v; 
    194                 *b++ = '#'; 
    195         } 
    196         *b++ = '\0'; 
    197         assert(b <= oh->hash + sp->lhashptr); 
    198 } 
    199  
    200 void 
    201 HSH_BeforeVclHash(struct sess *sp, unsigned nhashcount) 
    202 { 
    203         char *p; 
    204         unsigned u; 
     175HSH_BeforeVclHash(const struct sess *sp) 
     176{ 
    205177 
    206178        SHA256_Init(sp->wrk->sha256ctx); 
    207         if (!save_hash) 
    208                 return; 
    209  
    210         /* Allocate the pointers we need, align properly. */ 
    211         sp->lhashptr = 1;       /* space for NUL */ 
    212         sp->ihashptr = 0; 
    213         sp->nhashptr = nhashcount * 2; 
    214         p = WS_Alloc(sp->http->ws, sizeof(const char *) * (sp->nhashptr + 1L)); 
    215         XXXAN(p); 
    216         /* Align pointer properly (?) */ 
    217         u = (uintptr_t)p; 
    218         u &= sizeof(const char *) - 1; 
    219         if (u) 
    220                 p += sizeof(const char *) - u; 
    221         sp->hashptr = (void*)p; 
    222179} 
    223180 
     
    231188 
    232189void 
    233 HSH_AddString(struct sess *sp, const char *str) 
     190HSH_AddString(const struct sess *sp, const char *str) 
    234191{ 
    235192        int l; 
     
    244201        if (params->log_hash) 
    245202                WSP(sp, SLT_Hash, "%s", str); 
    246  
    247         if (!save_hash) 
    248                 return; 
    249  
    250         /* 
    251         * XXX: handle this by bouncing sp->vcl->nhashcount when it fails 
    252         * XXX: and dispose of this request either by reallocating the 
    253         * XXX: hashptr (if possible) or restarting/error the request 
    254         */ 
    255         xxxassert(sp->ihashptr < sp->nhashptr); 
    256  
    257         sp->hashptr[sp->ihashptr] = str; 
    258         sp->hashptr[sp->ihashptr + 1] = str + l; 
    259         sp->ihashptr += 2; 
    260         sp->lhashptr += l + 1; 
    261203} 
    262204 
     
    496438                if (params->diag_bitmap & 0x20) 
    497439                        WSP(sp, SLT_Debug, 
    498                                 "on waiting list <%s>", oh->hash); 
     440                                "on waiting list <%p>", oh); 
    499441                SES_Charge(sp); 
    500442                sp->objhead = oh; 
     
    735677 
    736678        assert(DIGEST_LEN == SHA256_LEN);       /* avoid #include pollution */ 
    737         save_hash = params->save_hash; 
    738679        hash = heritage.hash; 
    739680        if (hash->start != NULL) 
  • bin/varnishd/cache_vrt.c

    r181c28 rcb257d  
    778778} 
    779779 
    780 const char * 
    781 VRT_r_obj_hash(const struct sess *sp) 
    782 { 
    783  
    784         CHECK_OBJ_NOTNULL(sp, SESS_MAGIC); 
    785         if (sp->obj == NULL) 
    786                 return (NULL); 
    787         CHECK_OBJ_NOTNULL(sp->obj, OBJECT_MAGIC); 
    788         if (sp->obj->objcore == NULL) 
    789                 return (NULL); 
    790         CHECK_OBJ_NOTNULL(sp->obj->objcore, OBJCORE_MAGIC); 
    791         CHECK_OBJ_NOTNULL(sp->obj->objcore->objhead, OBJHEAD_MAGIC); 
    792         return (sp->obj->objcore->objhead->hash); 
    793 } 
    794  
    795780unsigned 
    796781VRT_r_req_backend_healthy(const struct sess *sp) 
  • bin/varnishd/hash_classic.c

    r181c28 rcb257d  
    151151        noh->hoh_head = hp; 
    152152 
    153         HSH_Copy(sp, noh); 
    154  
    155153        Lck_Unlock(&hp->mtx); 
    156154        return (noh); 
  • bin/varnishd/hash_critbit.c

    r181c28 rcb257d  
    298298        if (hcb_is_node(p)) { 
    299299                oh = hcb_l_node(p); 
    300                 cli_out(cli, "%*.*sN %d r%u <%02x%02x%02x...> <%s>\n", 
     300                cli_out(cli, "%*.*sN %d r%u <%02x%02x%02x...>\n", 
    301301                    indent, indent, "", indent / 2, oh->refcnt, 
    302                     oh->digest[0], oh->digest[1], oh->digest[2], 
    303                     oh->hash); 
     302                    oh->digest[0], oh->digest[1], oh->digest[2]); 
    304303                return; 
    305304        } 
     
    425424        unsigned u; 
    426425 
     426        (void)sp; 
    427427        oh =  hcb_insert(&hcb_root, noh, 0); 
    428428        if (oh != NULL) { 
     
    448448         * somebody else beats us back, they do not get surprised. 
    449449         */ 
    450         HSH_Copy(sp, noh); 
    451450        Lck_Lock(&hcb_mtx); 
    452451        assert(noh->refcnt == 1); 
     
    459458        } else { 
    460459                CHECK_OBJ_NOTNULL(noh, OBJHEAD_MAGIC); 
    461                 free(noh->hash); 
    462                 noh->hash = NULL; 
    463460                VSL_stats->hcb_lock++; 
    464461#ifdef PHK 
  • bin/varnishd/hash_simple_list.c

    r7fbb41 rcb257d  
    9292                VTAILQ_INSERT_TAIL(&hsl_head, noh, hoh_list); 
    9393 
    94         HSH_Copy(sp, noh); 
    95  
    9694        Lck_Unlock(&hsl_mtx); 
    9795        return (noh); 
  • bin/varnishd/hash_slinger.h

    r986587 rcb257d  
    5555void HSH_Cleanup(struct worker *w); 
    5656void HSH_Freestore(struct object *o); 
    57 void HSH_Copy(const struct sess *sp, struct objhead *o); 
    5857struct objcore *HSH_Lookup(struct sess *sp, struct objhead **poh); 
    5958void HSH_Unbusy(const struct sess *sp); 
     
    6261double HSH_Grace(double g); 
    6362void HSH_Init(void); 
    64 void HSH_AddString(struct sess *sp, const char *str); 
    65 void HSH_BeforeVclHash(struct sess *sp, unsigned hashcount); 
     63void HSH_AddString(const struct sess *sp, const char *str); 
     64void HSH_BeforeVclHash(const struct sess *sp); 
    6665void HSH_AfterVclHash(const struct sess *sp); 
    6766void HSH_DerefObjCore(struct sess *sp); 
     
    8079        unsigned                refcnt; 
    8180        VTAILQ_HEAD(,objcore)   objcs; 
    82         char                    *hash; 
    8381        unsigned char           digest[DIGEST_LEN]; 
    8482        union { 
     
    104102}; 
    105103 
    106 extern unsigned save_hash; 
    107104void HSH_DeleteObjHead(struct worker *w, struct objhead *oh); 
    108105void HSH_Deref(struct worker *w, struct object **o); 
  • bin/varnishd/heritage.h

    r181c28 rcb257d  
    177177        unsigned                log_hash; 
    178178 
    179         /* Log hash string to shm */ 
    180         unsigned                save_hash; 
    181  
    182179        /* Log local socket address to shm */ 
    183180        unsigned                log_local_addr; 
  • bin/varnishd/mgt_param.c

    r181c28 rcb257d  
    713713                0, 
    714714                "off", "bool" }, 
    715         { "purge_hash", tweak_bool, &master.save_hash, 0, 0, 
    716                 "Enable purge.hash command.\n" 
    717                 "NB: this increases storage requirement per object " 
    718                 "by the length of the hash string.\n", 
    719                 MUST_RESTART, 
    720                 "off", "bool" }, 
    721715        { "log_local_address", tweak_bool, &master.log_local_addr, 0, 0, 
    722716                "Log the local address on the TCP connection in the " 
  • bin/varnishtest/tests/c00007.vtc

    rcb5fa8 rcb257d  
    33test "Test banning a hash" 
    44 
    5 server s1 { 
    6         rxreq 
    7         expect req.url == "/foo" 
    8         txresp -body "1111\n" 
    9         rxreq 
    10         expect req.url == "/foo" 
    11         txresp -body "11111\n" 
    12 } -start 
    13  
    14 varnish v1 -arg "-ppurge_hash=off" -vcl+backend { } -start 
    15 varnish v1 -clierr 300 "purge.hash foo" 
    16 varnish v1 -stop 
    17 varnish v1 -cliok "param.set purge_hash on" 
    18 varnish v1 -start 
    19  
    20 client c1 { 
    21         txreq -url "/foo" 
    22         rxresp 
    23         expect resp.status == 200 
    24         expect resp.http.content-length == 5 
    25 }  
    26  
    27 client c1 -run 
    28  
    29 varnish v1 -cliok "purge.hash foo" 
    30  
    31 client c1 { 
    32         txreq -url "/foo" 
    33         rxresp 
    34         expect resp.status == 200 
    35         expect resp.http.content-length == 6 
    36 } 
    37  
    38 client c1 -run 
     5varnish v1 -arg "-b 127.0.0.1:80 -a 127.0.0.1:0" -start -clierr 300 "purge.hash foo" 
  • bin/varnishtest/tests/c00019.vtc

    rcb5fa8 rcb257d  
    1414} -start 
    1515 
    16 varnish v1 -arg "-p purge_hash=on" -vcl+backend {} -start 
     16varnish v1 -vcl+backend {} -start 
    1717 
    1818varnish v1 -cliok "purge.url FOO" 
     
    6262 
    6363 
    64 # Now add another two purge, the hash should not be hit. 
    65 varnish v1 -cliok "purge.hash FOO" 
     64# Now add another two purges, Kilroy should not be hit 
     65varnish v1 -cliok "purge.url KILROY" 
    6666varnish v1 -cliok "purge.url FOO" 
    6767varnish v1 -expect n_purge_add == 5 
  • include/cli.h

    r181c28 rcb257d  
    6565        "purge.url <regexp>",                                           \ 
    6666        "\tAll objects where the urls matches regexp will be "          \ 
    67             "marked obsolete.",                                         \ 
    68         1, 1 
    69  
    70 #define CLI_PURGE_HASH                                                  \ 
    71         "purge.hash",                                                   \ 
    72         "purge.hash <regexp>",                                          \ 
    73         "\tAll objects where the hash string matches regexp will be "   \ 
    7467            "marked obsolete.",                                         \ 
    7568        1, 1 
  • include/purge_vars.h

    r181c28 rcb257d  
    3636 
    3737PVAR("req.url",         PVAR_REQ,               ban_cond_url) 
    38 PVAR("obj.hash",        0,                      ban_cond_hash) 
    3938PVAR("req.http.",       PVAR_REQ|PVAR_HTTP,     ban_cond_req_http) 
    4039PVAR("obj.http.",       PVAR_HTTP,              ban_cond_obj_http) 
  • include/vcl.h

    r20e57f rcb257d  
    5454        const char      **srcbody; 
    5555 
    56         unsigned        nhashcount; 
    57  
    5856        vcl_init_f      *init_func; 
    5957        vcl_fini_f      *fini_func; 
  • include/vrt_obj.h

    r391ac93 rcb257d  
    6767void VRT_l_obj_grace(const struct sess *, double); 
    6868double VRT_r_obj_lastuse(const struct sess *); 
    69 const char * VRT_r_obj_hash(const struct sess *); 
    7069const char * VRT_r_resp_proto(const struct sess *); 
    7170void VRT_l_resp_proto(const struct sess *, const char *, ...); 
  • lib/libvcl/vcc_action.c

    r181c28 rcb257d  
    270270                 * number of slots for composing the hash string. 
    271271                 */ 
    272                 tl->nhashcount++; 
    273272                break; 
    274273        case STRING: 
  • lib/libvcl/vcc_compile.c

    rd93879 rcb257d  
    358358        Fc(tl, 0, "\t.srcname = srcname,\n"); 
    359359        Fc(tl, 0, "\t.srcbody = srcbody,\n"); 
    360         Fc(tl, 0, "\t.nhashcount = %u,\n", tl->nhashcount); 
    361360#define VCL_MET_MAC(l,u,b) \ 
    362361        Fc(tl, 0, "\t." #l "_func = VGC_function_vcl_" #l ",\n"); 
  • lib/libvcl/vcc_compile.h

    r00dd17 rcb257d  
    9191 
    9292        unsigned                recnt; 
    93         unsigned                nhashcount; 
    9493        unsigned                nsockaddr; 
    9594}; 
  • lib/libvcl/vcc_fixed_token.c

    r181c28 rcb257d  
    11/* 
    2  * $Id: vcc_gen_fixed_token.tcl 4236 2009-09-14 08:47:03Z phk $ 
     2 * $Id: vcc_gen_fixed_token.tcl 4358 2009-11-19 19:03:25Z phk $ 
    33 * 
    44 * NB:  This file is machine generated, DO NOT EDIT! 
     
    160160        /* ../../include/vcl.h */ 
    161161 
    162         vsb_cat(sb, "/*\n * $Id: vcc_gen_fixed_token.tcl 4236 2009-09-14 08"); 
    163         vsb_cat(sb, ":47:03Z phk $\n *\n * NB:  This file is machine genera"); 
     162        vsb_cat(sb, "/*\n * $Id: vcc_gen_fixed_token.tcl 4358 2009-11-19 19"); 
     163        vsb_cat(sb, ":03:25Z phk $\n *\n * NB:  This file is machine genera"); 
    164164        vsb_cat(sb, "ted, DO NOT EDIT!\n *\n * Edit and run vcc_gen_fixed_t"); 
    165165        vsb_cat(sb, "oken.tcl instead\n */\n\nstruct sess;\n"); 
     
    189189        vsb_cat(sb, "\tunsigned\tdiscard;\n\n\tunsigned\tnsrc;\n"); 
    190190        vsb_cat(sb, "\tconst char\t**srcname;\n\tconst char\t**srcbody;\n"); 
    191         vsb_cat(sb, "\n\tunsigned\tnhashcount;\n\n\tvcl_init_f\t*init_func;"); 
    192         vsb_cat(sb, "\n\tvcl_fini_f\t*fini_func;\n\n"); 
    193         vsb_cat(sb, "\tvcl_func_f\t*recv_func;\n\tvcl_func_f\t*pipe_func;\n"); 
    194         vsb_cat(sb, "\tvcl_func_f\t*pass_func;\n\tvcl_func_f\t*hash_func;\n"); 
    195         vsb_cat(sb, "\tvcl_func_f\t*miss_func;\n\tvcl_func_f\t*hit_func;\n"); 
    196         vsb_cat(sb, "\tvcl_func_f\t*fetch_func;\n\tvcl_func_f\t*deliver_fun"); 
    197         vsb_cat(sb, "c;\n\tvcl_func_f\t*error_func;\n"); 
    198         vsb_cat(sb, "};\n"); 
     191        vsb_cat(sb, "\n\tvcl_init_f\t*init_func;\n\tvcl_fini_f\t*fini_func;"); 
     192        vsb_cat(sb, "\n\n\tvcl_func_f\t*recv_func;\n"); 
     193        vsb_cat(sb, "\tvcl_func_f\t*pipe_func;\n\tvcl_func_f\t*pass_func;\n"); 
     194        vsb_cat(sb, "\tvcl_func_f\t*hash_func;\n\tvcl_func_f\t*miss_func;\n"); 
     195        vsb_cat(sb, "\tvcl_func_f\t*hit_func;\n\tvcl_func_f\t*fetch_func;\n"); 
     196        vsb_cat(sb, "\tvcl_func_f\t*deliver_func;\n\tvcl_func_f\t*error_fun"); 
     197        vsb_cat(sb, "c;\n};\n"); 
    199198 
    200199        /* ../../include/vrt.h */ 
     
    320319        /* ../../include/vrt_obj.h */ 
    321320 
    322         vsb_cat(sb, "/*\n * $Id: vcc_gen_fixed_token.tcl 4236 2009-09-14 08"); 
    323         vsb_cat(sb, ":47:03Z phk $\n *\n * NB:  This file is machine genera"); 
     321        vsb_cat(sb, "/*\n * $Id: vcc_gen_fixed_token.tcl 4358 2009-11-19 19"); 
     322        vsb_cat(sb, ":03:25Z phk $\n *\n * NB:  This file is machine genera"); 
    324323        vsb_cat(sb, "ted, DO NOT EDIT!\n *\n * Edit and run vcc_gen_fixed_t"); 
    325324        vsb_cat(sb, "oken.tcl instead\n */\n\nstruct sockaddr * VRT_r_clien"); 
     
    385384        vsb_cat(sb, "void VRT_l_obj_grace(const struct sess *, double);\n"); 
    386385        vsb_cat(sb, "double VRT_r_obj_lastuse(const struct sess *);\n"); 
    387         vsb_cat(sb, "const char * VRT_r_obj_hash(const struct sess *);\n"); 
    388386        vsb_cat(sb, "const char * VRT_r_resp_proto(const struct sess *);\n"); 
    389387        vsb_cat(sb, "void VRT_l_resp_proto(const struct sess *, const char "); 
  • lib/libvcl/vcc_gen_fixed_token.tcl

    r181c28 rcb257d  
    302302        RO 
    303303        { hit deliver error } 
    304         "const struct sess *" 
    305     } 
    306     { obj.hash                          STRING 
    307         RO 
    308         { miss hit deliver error } 
    309304        "const struct sess *" 
    310305    } 
     
    585580        const char      **srcbody; 
    586581 
    587         unsigned        nhashcount; 
    588  
    589582        vcl_init_f      *init_func; 
    590583        vcl_fini_f      *fini_func; 
  • lib/libvcl/vcc_obj.c

    r181c28 rcb257d  
    11/* 
    2  * $Id: vcc_gen_fixed_token.tcl 4236 2009-09-14 08:47:03Z phk $ 
     2 * $Id: vcc_gen_fixed_token.tcl 4358 2009-11-19 19:03:25Z phk $ 
    33 * 
    44 * NB:  This file is machine generated, DO NOT EDIT! 
     
    280280            VCL_MET_HIT | VCL_MET_DELIVER | VCL_MET_ERROR 
    281281        }, 
    282         { "obj.hash", STRING, 8, 
    283             "VRT_r_obj_hash(sp)", 
    284             NULL, 
    285             V_RO,           0, 
    286             VCL_MET_MISS | VCL_MET_HIT | VCL_MET_DELIVER | VCL_MET_ERROR 
    287         }, 
    288282        { "resp.proto", STRING, 10, 
    289283            "VRT_r_resp_proto(sp)", 
Note: See TracChangeset for help on using the changeset viewer.