source: bin/varnishd/cache/cache.h @ 33a224

Revision 33a224, 27.8 KB checked in by Poul-Henning Kamp <phk@…>, 2 years ago (diff)

Push struct worker out of STV_NewObject()

  • Property mode set to 100644
Line 
1/*-
2 * Copyright (c) 2006 Verdens Gang AS
3 * Copyright (c) 2006-2011 Varnish Software AS
4 * All rights reserved.
5 *
6 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 *    notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 *    notice, this list of conditions and the following disclaimer in the
15 *    documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 *
29 */
30
31/*
32 * This macro can be used in .h files to isolate bits that the manager
33 * should not (need to) see, such as pthread mutexes etc.
34 */
35#define VARNISH_CACHE_CHILD     1
36
37#include "common/common.h"
38
39#include "vapi/vsc_int.h"
40#include "vapi/vsl_int.h"
41
42#include <sys/socket.h>
43
44#include <pthread.h>
45#ifdef HAVE_PTHREAD_NP_H
46#include <pthread_np.h>
47#endif
48#include <stdarg.h>
49#include <string.h>
50#include <limits.h>
51#include <unistd.h>
52
53#if defined(HAVE_EPOLL_CTL)
54#include <sys/epoll.h>
55#endif
56
57
58#include "common/params.h"
59
60enum body_status {
61#define BODYSTATUS(U,l) BS_##U,
62#include "tbl/body_status.h"
63#undef BODYSTATUS
64};
65
66static inline const char *
67body_status(enum body_status e)
68{
69        switch(e) {
70#define BODYSTATUS(U,l) case BS_##U: return (#l);
71#include "tbl/body_status.h"
72#undef BODYSTATUS
73        default:
74                return ("?");
75        }
76}
77
78/*
79 * NB: HDR_STATUS is only used in cache_http.c, everybody else uses the
80 * http->status integer field.
81 */
82
83enum {
84        /* Fields from the first line of HTTP proto */
85        HTTP_HDR_REQ,
86        HTTP_HDR_URL,
87        HTTP_HDR_PROTO,
88        HTTP_HDR_STATUS,
89        HTTP_HDR_RESPONSE,
90        /* HTTP header lines */
91        HTTP_HDR_FIRST,
92};
93
94struct SHA256Context;
95struct VSC_C_lck;
96struct ban;
97struct busyobj;
98struct cli;
99struct cli_proto;
100struct director;
101struct iovec;
102struct mempool;
103struct objcore;
104struct object;
105struct objhead;
106struct pool;
107struct poolparam;
108struct sess;
109struct sesspool;
110struct vbc;
111struct vbo;
112struct vef_priv;
113struct vrt_backend;
114struct vsb;
115struct waitinglist;
116struct worker;
117struct wrw;
118
119#define DIGEST_LEN              32
120
121/*--------------------------------------------------------------------*/
122
123typedef struct {
124        char                    *b;
125        char                    *e;
126} txt;
127
128/*--------------------------------------------------------------------*/
129
130enum step {
131#define STEP(l, u, arg) STP_##u,
132#include "tbl/steps.h"
133#undef STEP
134};
135
136/*--------------------------------------------------------------------*/
137struct lock { void *priv; };    // Opaque
138
139/*--------------------------------------------------------------------
140 * Workspace structure for quick memory allocation.
141 */
142
143struct ws {
144        unsigned                magic;
145#define WS_MAGIC                0x35fac554
146        unsigned                overflow;       /* workspace overflowed */
147        const char              *id;            /* identity */
148        char                    *s;             /* (S)tart of buffer */
149        char                    *f;             /* (F)ree pointer */
150        char                    *r;             /* (R)eserved length */
151        char                    *e;             /* (E)nd of buffer */
152};
153
154/*--------------------------------------------------------------------
155 * HTTP Request/Response/Header handling structure.
156 */
157
158enum httpwhence {
159        HTTP_Rx  = 1,
160        HTTP_Tx  = 2,
161        HTTP_Obj = 3
162};
163
164/* NB: remember to update http_Copy() if you add fields */
165struct http {
166        unsigned                magic;
167#define HTTP_MAGIC              0x6428b5c9
168
169        enum httpwhence         logtag;
170        struct vsl_log          *vsl;
171
172        struct ws               *ws;
173        txt                     *hd;
174        unsigned char           *hdf;
175#define HDF_FILTER              (1 << 0)        /* Filtered by Connection */
176        uint16_t                shd;            /* Size of hd space */
177        uint16_t                nhd;            /* Next free hd */
178        uint16_t                status;
179        uint8_t                 protover;
180        uint8_t                 conds;          /* If-* headers present */
181};
182
183/*--------------------------------------------------------------------
184 * HTTP Protocol connection structure
185 */
186
187struct http_conn {
188        unsigned                magic;
189#define HTTP_CONN_MAGIC         0x3e19edd1
190
191        int                     fd;
192        struct vsl_log          *vsl;
193        unsigned                maxbytes;
194        unsigned                maxhdr;
195        struct ws               *ws;
196        txt                     rxbuf;
197        txt                     pipeline;
198};
199
200/*--------------------------------------------------------------------*/
201
202struct acct {
203#define ACCT(foo)       uint64_t        foo;
204#include "tbl/acct_fields.h"
205#undef ACCT
206};
207
208/*--------------------------------------------------------------------*/
209
210#define L0(t, n)
211#define L1(t, n)                t n;
212#define VSC_F(n, t, l, f, e,d)  L##l(t, n)
213struct dstat {
214#include "tbl/vsc_f_main.h"
215};
216#undef VSC_F
217#undef L0
218#undef L1
219
220/* Fetch processors --------------------------------------------------*/
221
222typedef void vfp_begin_f(struct busyobj *, size_t );
223typedef int vfp_bytes_f(struct busyobj *, struct http_conn *, ssize_t);
224typedef int vfp_end_f(struct busyobj *);
225
226struct vfp {
227        vfp_begin_f     *begin;
228        vfp_bytes_f     *bytes;
229        vfp_end_f       *end;
230};
231
232extern struct vfp vfp_gunzip;
233extern struct vfp vfp_gzip;
234extern struct vfp vfp_testgzip;
235extern struct vfp vfp_esi;
236
237/*--------------------------------------------------------------------*/
238
239struct exp {
240        double                  ttl;
241        double                  grace;
242        double                  keep;
243        double                  age;
244        double                  entered;
245};
246
247/*--------------------------------------------------------------------*/
248
249struct vsl_log {
250        uint32_t                *wlb, *wlp, *wle;
251        unsigned                wlr;
252        unsigned                wid;
253};
254
255/*--------------------------------------------------------------------*/
256
257struct vxid {
258        uint32_t                next;
259        uint32_t                count;
260};
261
262/*--------------------------------------------------------------------*/
263
264struct wrk_accept {
265        unsigned                magic;
266#define WRK_ACCEPT_MAGIC        0x8c4b4d59
267
268        /* Accept stuff */
269        struct sockaddr_storage acceptaddr;
270        socklen_t               acceptaddrlen;
271        int                     acceptsock;
272        struct listen_sock      *acceptlsock;
273        uint32_t                vxid;
274};
275
276/* Worker pool stuff -------------------------------------------------*/
277
278typedef void pool_func_t(struct worker *wrk, void *priv);
279
280struct pool_task {
281        VTAILQ_ENTRY(pool_task)         list;
282        pool_func_t                     *func;
283        void                            *priv;
284};
285
286enum pool_how {
287        POOL_NO_QUEUE,
288        POOL_QUEUE_FRONT,
289        POOL_QUEUE_BACK
290};
291
292/*--------------------------------------------------------------------*/
293
294struct worker {
295        unsigned                magic;
296#define WORKER_MAGIC            0x6391adcf
297        struct pool             *pool;
298        struct objhead          *nobjhead;
299        struct objcore          *nobjcore;
300        struct waitinglist      *nwaitinglist;
301        struct vbo              *nvbo;
302        void                    *nhashpriv;
303        struct dstat            stats;
304
305        struct pool_task        task;
306
307        double                  lastused;
308
309        struct wrw              *wrw;
310
311        pthread_cond_t          cond;
312
313        struct sess             *sp;
314
315        struct VCL_conf         *vcl;
316
317        struct vsl_log          vsl[1];
318
319        struct ws               aws[1];
320
321        struct busyobj          *busyobj;
322
323        /* Temporary accounting */
324        struct acct             acct_tmp;
325};
326
327/* LRU ---------------------------------------------------------------*/
328
329struct lru {
330        unsigned                magic;
331#define LRU_MAGIC               0x3fec7bb0
332        VTAILQ_HEAD(,objcore)   lru_head;
333        struct lock             mtx;
334};
335
336/* Storage -----------------------------------------------------------*/
337
338struct storage {
339        unsigned                magic;
340#define STORAGE_MAGIC           0x1a4e51c0
341
342
343        VTAILQ_ENTRY(storage)   list;
344        struct stevedore        *stevedore;
345        void                    *priv;
346
347        unsigned char           *ptr;
348        unsigned                len;
349        unsigned                space;
350};
351
352/* Object core structure ---------------------------------------------
353 * Objects have sideways references in the binary heap and the LRU list
354 * and we want to avoid paging in a lot of objects just to move them up
355 * or down the binheap or to move a unrelated object on the LRU list.
356 * To avoid this we use a proxy object, objcore, to hold the relevant
357 * housekeeping fields parts of an object.
358 */
359
360typedef struct object *getobj_f(struct dstat *ds, struct objcore *oc);
361typedef unsigned getxid_f(struct dstat *ds, struct objcore *oc);
362typedef void updatemeta_f(struct objcore *oc);
363typedef void freeobj_f(struct objcore *oc);
364typedef struct lru *getlru_f(const struct objcore *oc);
365
366struct objcore_methods {
367        getobj_f        *getobj;
368        getxid_f        *getxid;
369        updatemeta_f    *updatemeta;
370        freeobj_f       *freeobj;
371        getlru_f        *getlru;
372};
373
374struct objcore {
375        unsigned                magic;
376#define OBJCORE_MAGIC           0x4d301302
377        int                     refcnt;
378        struct objcore_methods  *methods;
379        void                    *priv;
380        unsigned                priv2;
381        struct objhead          *objhead;
382        struct busyobj          *busyobj;
383        double                  timer_when;
384        unsigned                flags;
385#define OC_F_BUSY               (1<<1)
386#define OC_F_PASS               (1<<2)
387#define OC_F_LRUDONTMOVE        (1<<4)
388#define OC_F_PRIV               (1<<5)          /* Stevedore private flag */
389#define OC_F_LURK               (3<<6)          /* Ban-lurker-color */
390        unsigned                timer_idx;
391        VTAILQ_ENTRY(objcore)   list;
392        VTAILQ_ENTRY(objcore)   lru_list;
393        VTAILQ_ENTRY(objcore)   ban_list;
394        struct ban              *ban;
395};
396
397static inline unsigned
398oc_getxid(struct dstat *ds, struct objcore *oc)
399{
400        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
401
402        AN(oc->methods);
403        AN(oc->methods->getxid);
404        return (oc->methods->getxid(ds, oc));
405}
406
407static inline struct object *
408oc_getobj(struct dstat *ds, struct objcore *oc)
409{
410
411        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
412        AZ(oc->flags & OC_F_BUSY);
413        AN(oc->methods);
414        AN(oc->methods->getobj);
415        return (oc->methods->getobj(ds, oc));
416}
417
418static inline void
419oc_updatemeta(struct objcore *oc)
420{
421
422        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
423        AN(oc->methods);
424        if (oc->methods->updatemeta != NULL)
425                oc->methods->updatemeta(oc);
426}
427
428static inline void
429oc_freeobj(struct objcore *oc)
430{
431
432        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
433        AN(oc->methods);
434        AN(oc->methods->freeobj);
435        oc->methods->freeobj(oc);
436}
437
438static inline struct lru *
439oc_getlru(const struct objcore *oc)
440{
441
442        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
443        AN(oc->methods);
444        AN(oc->methods->getlru);
445        return (oc->methods->getlru(oc));
446}
447
448/* Busy Object structure ---------------------------------------------
449 *
450 * The busyobj structure captures the aspects of an object related to,
451 * and while it is being fetched from the backend.
452 *
453 * One of these aspects will be how much has been fetched, which
454 * streaming delivery will make use of.
455 */
456
457struct busyobj {
458        unsigned                magic;
459#define BUSYOBJ_MAGIC           0x23b95567
460        struct vbo              *vbo;
461
462        uint8_t                 *vary;
463        unsigned                is_gzip;
464        unsigned                is_gunzip;
465
466        struct vfp              *vfp;
467        struct vep_state        *vep;
468        unsigned                fetch_failed;
469        struct vgz              *vgz_rx;
470
471        struct ws               ws[1];
472        struct vbc              *vbc;
473        struct http             *bereq;
474        struct http             *beresp;
475        struct object           *fetch_obj;
476        struct exp              exp;
477        struct http_conn        htc;
478
479        enum body_status        body_status;
480        struct vef_priv         *vef_priv;
481
482        unsigned                should_close;
483        char                    *h_content_length;
484
485        unsigned                do_esi;
486        unsigned                do_gzip;
487        unsigned                do_gunzip;
488        unsigned                do_stream;
489        unsigned                do_pass;
490
491        /* Timeouts */
492        double                  connect_timeout;
493        double                  first_byte_timeout;
494        double                  between_bytes_timeout;
495
496        struct vsl_log          vsl[1];
497        struct dstat            *stats;
498};
499
500/* Object structure --------------------------------------------------*/
501
502VTAILQ_HEAD(storagehead, storage);
503
504struct object {
505        unsigned                magic;
506#define OBJECT_MAGIC            0x32851d42
507        unsigned                xid;
508        struct storage          *objstore;
509        struct objcore          *objcore;
510
511        struct ws               ws_o[1];
512
513        uint8_t                 *vary;
514        unsigned                hits;
515        uint16_t                response;
516
517        /* XXX: make bitmap */
518        uint8_t                 gziped;
519        /* Bit positions in the gzip stream */
520        ssize_t                 gzip_start;
521        ssize_t                 gzip_last;
522        ssize_t                 gzip_stop;
523
524        ssize_t                 len;
525
526        struct exp              exp;
527
528        double                  last_modified;
529        double                  last_lru;
530
531        struct http             *http;
532
533        struct storagehead      store;
534
535        struct storage          *esidata;
536
537        double                  last_use;
538
539};
540
541/*--------------------------------------------------------------------*/
542
543struct req {
544        unsigned                magic;
545#define REQ_MAGIC               0x2751aaa1
546
547        unsigned                xid;
548        int                     restarts;
549        int                     esi_level;
550        int                     disable_esi;
551        uint8_t                 hash_ignore_busy;
552        uint8_t                 hash_always_miss;
553
554        /* The busy objhead we sleep on */
555        struct objhead          *hash_objhead;
556
557        /* Built Vary string */
558        uint8_t                 *vary_b;
559        uint8_t                 *vary_l;
560        uint8_t                 *vary_e;
561
562        unsigned char           digest[DIGEST_LEN];
563
564        const char              *doclose;
565        struct exp              exp;
566        unsigned                cur_method;
567        unsigned                handling;
568        unsigned char           reqbodydone;
569        unsigned char           wantbody;
570
571        uint16_t                err_code;
572        const char              *err_reason;
573
574        struct director         *director;
575        struct VCL_conf         *vcl;
576
577        uint64_t                req_bodybytes;
578        char                    *ws_req;        /* WS above request data */
579
580        double                  t_resp;
581
582        struct http_conn        htc[1];
583        char                    *client_identity;
584
585        /* HTTP request */
586        struct http             *http;
587        struct http             *http0;
588        struct http             *resp;
589
590        struct ws               ws[1];
591        struct object           *obj;
592        struct objcore          *objcore;
593        /* Lookup stuff */
594        struct SHA256Context    *sha256ctx;
595        /* This is only here so VRT can find it */
596        const char              *storage_hint;
597
598        /* ESI delivery stuff */
599        int                     gzip_resp;
600        ssize_t                 l_crc;
601        uint32_t                crc;
602
603        /* Delivery mode */
604        unsigned                res_mode;
605#define RES_LEN                 (1<<1)
606#define RES_EOF                 (1<<2)
607#define RES_CHUNKED             (1<<3)
608#define RES_ESI                 (1<<4)
609#define RES_ESI_CHILD           (1<<5)
610#define RES_GUNZIP              (1<<6)
611
612        /* Transaction VSL buffer */
613        struct vsl_log          vsl[1];
614
615};
616
617/*--------------------------------------------------------------------
618 * Struct sess is a high memory-load structure because sessions typically
619 * hang around the waiter for relatively long time.
620 *
621 * The size goal for struct sess + struct memitem is <512 bytes
622 *
623 * Getting down to the next relevant size (<256 bytes because of how malloc
624 * works, is not realistic without a lot of code changes.
625 */
626
627struct sess {
628        unsigned                magic;
629#define SESS_MAGIC              0x2c2f9c5a
630
631        enum step               step;
632        int                     fd;
633        unsigned                vsl_id;
634        uint32_t                vxid;
635        uint32_t                vseq;
636
637        /* Cross references ------------------------------------------*/
638
639        struct sesspool         *sesspool;
640        struct worker           *wrk;
641        struct req              *req;
642
643        struct pool_task        task;
644        VTAILQ_ENTRY(sess)      list;
645
646        /* Session related fields ------------------------------------*/
647
648        socklen_t               sockaddrlen;
649        socklen_t               mysockaddrlen;
650        struct sockaddr_storage sockaddr;
651        struct sockaddr_storage mysockaddr;
652        struct listen_sock      *mylsock;
653
654        /* formatted ascii client address */
655        char                    addr[ADDR_BUFSIZE];
656        char                    port[PORT_BUFSIZE];
657
658        struct acct             acct_ses;
659
660        /* Timestamps, all on TIM_real() timescale */
661        double                  t_open;         /* fd accepted */
662        double                  t_idle;         /* fd accepted or resp sent */
663        double                  t_req;
664
665#if defined(HAVE_EPOLL_CTL)
666        struct epoll_event ev;
667#endif
668};
669
670/* Prototypes etc ----------------------------------------------------*/
671
672/* cache_acceptor.c */
673void VCA_Init(void);
674void VCA_Shutdown(void);
675int VCA_Accept(struct listen_sock *ls, struct wrk_accept *wa);
676void VCA_SetupSess(struct worker *w, struct sess *sp);
677void VCA_FailSess(struct worker *w);
678
679/* cache_backend.c */
680void VBE_UseHealth(const struct director *vdi);
681
682struct vbc *VDI_GetFd(const struct director *, struct sess *sp);
683int VDI_Healthy(const struct director *, const struct sess *sp);
684void VDI_CloseFd(struct worker *wrk, struct vbc **vbp);
685void VDI_RecycleFd(struct worker *wrk, struct vbc **vbp);
686void VDI_AddHostHeader(struct http *to, const struct vbc *vbc);
687void VBE_Poll(void);
688void VDI_Init(void);
689
690/* cache_backend_cfg.c */
691void VBE_InitCfg(void);
692struct backend *VBE_AddBackend(struct cli *cli, const struct vrt_backend *vb);
693
694/* cache_backend_poll.c */
695void VBP_Init(void);
696
697/* cache_ban.c */
698struct ban *BAN_New(void);
699int BAN_AddTest(struct cli *, struct ban *, const char *, const char *,
700    const char *);
701void BAN_Free(struct ban *b);
702void BAN_Insert(struct ban *b);
703void BAN_Init(void);
704void BAN_NewObjCore(struct objcore *oc);
705void BAN_DestroyObj(struct objcore *oc);
706int BAN_CheckObject(struct object *o, const struct sess *sp);
707void BAN_Reload(const uint8_t *ban, unsigned len);
708struct ban *BAN_TailRef(void);
709void BAN_Compile(void);
710struct ban *BAN_RefBan(struct objcore *oc, double t0, const struct ban *tail);
711void BAN_TailDeref(struct ban **ban);
712double BAN_Time(const struct ban *ban);
713
714/* cache_busyobj.c */
715void VBO_Init(void);
716struct busyobj *VBO_GetBusyObj(struct worker *wrk);
717void VBO_RefBusyObj(const struct busyobj *busyobj);
718void VBO_DerefBusyObj(struct worker *wrk, struct busyobj **busyobj);
719void VBO_Free(struct vbo **vbo);
720
721/* cache_center.c [CNT] */
722void CNT_Session(struct sess *sp);
723void CNT_Init(void);
724
725/* cache_cli.c [CLI] */
726void CLI_Init(void);
727void CLI_Run(void);
728void CLI_AddFuncs(struct cli_proto *p);
729extern pthread_t cli_thread;
730#define ASSERT_CLI() do {assert(pthread_self() == cli_thread);} while (0)
731
732/* cache_expiry.c */
733void EXP_Clr(struct exp *e);
734double EXP_Get_ttl(const struct exp *e);
735double EXP_Get_grace(const struct exp *e);
736double EXP_Get_keep(const struct exp *e);
737void EXP_Set_ttl(struct exp *e, double v);
738void EXP_Set_grace(struct exp *e, double v);
739void EXP_Set_keep(struct exp *e, double v);
740
741double EXP_Ttl(const struct sess *, const struct object*);
742double EXP_Grace(const struct sess *, const struct object*);
743void EXP_Insert(struct object *o);
744void EXP_Inject(struct objcore *oc, struct lru *lru, double when);
745void EXP_Init(void);
746void EXP_Rearm(const struct object *o);
747int EXP_Touch(struct objcore *oc);
748int EXP_NukeOne(struct busyobj *, struct lru *lru);
749
750/* cache_fetch.c */
751struct storage *FetchStorage(struct busyobj *, ssize_t sz);
752int FetchError(struct busyobj *, const char *error);
753int FetchError2(struct busyobj *, const char *error, const char *more);
754int FetchHdr(struct sess *sp, int need_host_hdr, int sendbody);
755int FetchBody(struct worker *w, struct object *obj);
756int FetchReqBody(const struct sess *sp, int sendbody);
757void Fetch_Init(void);
758
759/* cache_gzip.c */
760struct vgz;
761
762enum vgz_flag { VGZ_NORMAL, VGZ_ALIGN, VGZ_RESET, VGZ_FINISH };
763struct vgz *VGZ_NewUngzip(struct vsl_log *vsl, const char *id);
764struct vgz *VGZ_NewGzip(struct vsl_log *vsl, const char *id);
765void VGZ_Ibuf(struct vgz *, const void *, ssize_t len);
766int VGZ_IbufEmpty(const struct vgz *vg);
767void VGZ_Obuf(struct vgz *, void *, ssize_t len);
768int VGZ_ObufFull(const struct vgz *vg);
769int VGZ_ObufStorage(struct busyobj *, struct vgz *vg);
770int VGZ_Gzip(struct vgz *, const void **, size_t *len, enum vgz_flag);
771int VGZ_Gunzip(struct vgz *, const void **, size_t *len);
772int VGZ_Destroy(struct vgz **);
773void VGZ_UpdateObj(const struct vgz*, struct object *);
774
775int VGZ_WrwInit(struct vgz *vg);
776int VGZ_WrwGunzip(struct worker *w, struct vgz *, const void *ibuf,
777    ssize_t ibufl);
778void VGZ_WrwFlush(struct worker *wrk, struct vgz *vg);
779
780/* Return values */
781#define VGZ_ERROR       -1
782#define VGZ_OK          0
783#define VGZ_END         1
784#define VGZ_STUCK       2
785
786/* cache_http.c */
787unsigned HTTP_estimate(unsigned nhttp);
788void HTTP_Copy(struct http *to, const struct http * const fm);
789struct http *HTTP_create(void *p, uint16_t nhttp);
790const char *http_StatusMessage(unsigned);
791unsigned http_EstimateWS(const struct http *fm, unsigned how, uint16_t *nhd);
792void HTTP_Init(void);
793void http_ClrHeader(struct http *to);
794unsigned http_Write(struct worker *w, const struct http *hp, int resp);
795void http_SetResp(struct http *to, const char *proto, uint16_t status,
796    const char *response);
797void http_FilterReq(const struct sess *sp, unsigned how);
798void http_FilterResp(const struct http *fm, struct http *to, unsigned how);
799void http_PutProtocol(const struct http *to, const char *protocol);
800void http_PutStatus(struct http *to, uint16_t status);
801void http_PutResponse(const struct http *to, const char *response);
802void http_PrintfHeader(struct http *to, const char *fmt, ...)
803    __printflike(2, 3);
804void http_SetHeader(struct http *to, const char *hdr);
805void http_SetH(const struct http *to, unsigned n, const char *fm);
806void http_ForceGet(const struct http *to);
807void http_Setup(struct http *ht, struct ws *ws, struct vsl_log *);
808void http_Teardown(struct http *ht);
809int http_GetHdr(const struct http *hp, const char *hdr, char **ptr);
810int http_GetHdrData(const struct http *hp, const char *hdr,
811    const char *field, char **ptr);
812int http_GetHdrField(const struct http *hp, const char *hdr,
813    const char *field, char **ptr);
814double http_GetHdrQ(const struct http *hp, const char *hdr, const char *field);
815uint16_t http_GetStatus(const struct http *hp);
816const char *http_GetReq(const struct http *hp);
817int http_HdrIs(const struct http *hp, const char *hdr, const char *val);
818uint16_t http_DissectRequest(const struct sess *sp);
819uint16_t http_DissectResponse(struct http *sp, const struct http_conn *htc);
820const char *http_DoConnection(const struct http *hp);
821void http_CopyHome(const struct http *hp);
822void http_Unset(struct http *hp, const char *hdr);
823void http_CollectHdr(struct http *hp, const char *hdr);
824
825/* cache_httpconn.c */
826void HTC_Init(struct http_conn *htc, struct ws *ws, int fd, struct vsl_log *,
827    unsigned maxbytes, unsigned maxhdr);
828int HTC_Reinit(struct http_conn *htc);
829int HTC_Rx(struct http_conn *htc);
830ssize_t HTC_Read(struct http_conn *htc, void *d, size_t len);
831int HTC_Complete(struct http_conn *htc);
832
833#define HTTPH(a, b, c) extern char b[];
834#include "tbl/http_headers.h"
835#undef HTTPH
836
837/* cache_main.c */
838uint32_t VXID_Get(struct vxid *v);
839extern volatile struct params * cache_param;
840void THR_SetName(const char *name);
841const char* THR_GetName(void);
842void THR_SetSession(const struct sess *sp);
843const struct sess * THR_GetSession(void);
844
845/* cache_lck.c */
846
847/* Internal functions, call only through macros below */
848void Lck__Lock(struct lock *lck, const char *p, const char *f, int l);
849void Lck__Unlock(struct lock *lck, const char *p, const char *f, int l);
850int Lck__Trylock(struct lock *lck, const char *p, const char *f, int l);
851void Lck__New(struct lock *lck, struct VSC_C_lck *, const char *);
852void Lck__Assert(const struct lock *lck, int held);
853
854/* public interface: */
855void LCK_Init(void);
856void Lck_Delete(struct lock *lck);
857int Lck_CondWait(pthread_cond_t *cond, struct lock *lck, struct timespec *ts);
858
859#define Lck_New(a, b) Lck__New(a, b, #b)
860#define Lck_Lock(a) Lck__Lock(a, __func__, __FILE__, __LINE__)
861#define Lck_Unlock(a) Lck__Unlock(a, __func__, __FILE__, __LINE__)
862#define Lck_Trylock(a) Lck__Trylock(a, __func__, __FILE__, __LINE__)
863#define Lck_AssertHeld(a) Lck__Assert(a, 1)
864
865#define LOCK(nam) extern struct VSC_C_lck *lck_##nam;
866#include "tbl/locks.h"
867#undef LOCK
868
869/* cache_mempool.c */
870void MPL_AssertSane(void *item);
871struct mempool * MPL_New(const char *name, volatile struct poolparam *pp,
872    volatile unsigned *cur_size);
873void MPL_Destroy(struct mempool **mpp);
874void *MPL_Get(struct mempool *mpl, unsigned *size);
875void MPL_Free(struct mempool *mpl, void *item);
876
877/* cache_panic.c */
878void PAN_Init(void);
879
880/* cache_pipe.c */
881void PipeSession(struct sess *sp);
882
883/* cache_pool.c */
884void Pool_Init(void);
885void Pool_Work_Thread(void *priv, struct worker *w);
886int Pool_Task(struct pool *pp, struct pool_task *task, enum pool_how how);
887
888#define WRW_IsReleased(w)       ((w)->wrw == NULL)
889int WRW_Error(const struct worker *w);
890void WRW_Chunked(struct worker *w);
891void WRW_EndChunk(struct worker *w);
892void WRW_Reserve(struct worker *w, int *fd);
893unsigned WRW_Flush(struct worker *w);
894unsigned WRW_FlushRelease(struct worker *w);
895unsigned WRW_Write(struct worker *w, const void *ptr, int len);
896unsigned WRW_WriteH(struct worker *w, const txt *hh, const char *suf);
897
898/* cache_session.c [SES] */
899struct sess *SES_Alloc(void);
900void SES_Close(struct sess *sp, const char *reason);
901void SES_Delete(struct sess *sp, const char *reason, double now);
902void SES_Charge(struct sess *sp);
903struct sesspool *SES_NewPool(struct pool *pp, unsigned pool_no);
904void SES_DeletePool(struct sesspool *sp);
905int SES_Schedule(struct sess *sp);
906void SES_Handle(struct sess *sp, double now);
907void SES_GetReq(struct sess *sp);
908void SES_ReleaseReq(struct sess *sp);
909pool_func_t SES_pool_accept_task;
910
911/* cache_shmlog.c */
912extern struct VSC_C_main *VSC_C_main;
913void VSM_Init(void);
914void *VSM_Alloc(unsigned size, const char *class, const char *type,
915    const char *ident);
916void VSL_Setup(struct vsl_log *vsl, void *ptr, size_t len);
917void VSM_Free(void *ptr);
918#ifdef VSL_ENDMARKER
919void VSL(enum VSL_tag_e tag, int id, const char *fmt, ...)
920    __printflike(3, 4);
921void WSL(struct vsl_log *, enum VSL_tag_e tag, int id, const char *fmt, ...)
922    __printflike(4, 5);
923void VSLb(struct vsl_log *, enum VSL_tag_e tag, const char *fmt, ...)
924    __printflike(3, 4);
925void VSLbt(struct vsl_log *, enum VSL_tag_e tag, txt t);
926
927void VSL_Flush(struct vsl_log *, int overflow);
928
929#define DSL(flag, tag, id, ...)                                 \
930        do {                                                    \
931                if (cache_param->diag_bitmap & (flag))          \
932                        VSL((tag), (id), __VA_ARGS__);          \
933        } while (0)
934
935#define INCOMPL() do {                                                  \
936        VSL(SLT_Debug, 0, "INCOMPLETE AT: %s(%d)", __func__, __LINE__); \
937        fprintf(stderr,                                                 \
938            "INCOMPLETE AT: %s(%d)\n",                                  \
939            (const char *)__func__, __LINE__);                          \
940        abort();                                                        \
941        } while (0)
942#endif
943
944/* cache_response.c */
945void RES_BuildHttp(const struct sess *sp);
946void RES_WriteObj(struct sess *sp);
947
948/* cache_vary.c */
949struct vsb *VRY_Create(const struct sess *sp, const struct http *hp);
950int VRY_Match(const struct sess *sp, const uint8_t *vary);
951void VRY_Validate(const uint8_t *vary);
952
953/* cache_vcl.c */
954void VCL_Init(void);
955void VCL_Refresh(struct VCL_conf **vcc);
956void VCL_Rel(struct VCL_conf **vcc);
957void VCL_Poll(void);
958const char *VCL_Return_Name(unsigned method);
959
960#define VCL_MET_MAC(l,u,b) void VCL_##l##_method(struct sess *);
961#include "tbl/vcl_returns.h"
962#undef VCL_MET_MAC
963
964/* cache_vrt.c */
965
966char *VRT_String(struct ws *ws, const char *h, const char *p, va_list ap);
967char *VRT_StringList(char *d, unsigned dl, const char *p, va_list ap);
968
969void ESI_Deliver(struct sess *);
970void ESI_DeliverChild(const struct sess *);
971
972/* cache_vrt_vmod.c */
973void VMOD_Init(void);
974
975/* cache_waiter.c */
976void WAIT_Enter(struct sess *sp);
977void WAIT_Init(void);
978const char *WAIT_GetName(void);
979
980/* cache_wrk.c */
981
982void WRK_Init(void);
983int WRK_TrySumStat(struct worker *w);
984void WRK_SumStat(struct worker *w);
985void *WRK_thread(void *priv);
986typedef void *bgthread_t(struct sess *, void *priv);
987void WRK_BgThread(pthread_t *thr, const char *name, bgthread_t *func,
988    void *priv);
989
990/* cache_ws.c */
991
992void WS_Init(struct ws *ws, const char *id, void *space, unsigned len);
993unsigned WS_Reserve(struct ws *ws, unsigned bytes);
994void WS_Release(struct ws *ws, unsigned bytes);
995void WS_ReleaseP(struct ws *ws, char *ptr);
996void WS_Assert(const struct ws *ws);
997void WS_Reset(struct ws *ws, char *p);
998char *WS_Alloc(struct ws *ws, unsigned bytes);
999char *WS_Snapshot(struct ws *ws);
1000
1001/* rfc2616.c */
1002void RFC2616_Ttl(const struct sess *sp);
1003enum body_status RFC2616_Body(const struct sess *sp);
1004unsigned RFC2616_Req_Gzip(const struct sess *sp);
1005int RFC2616_Do_Cond(const struct sess *sp);
1006
1007/* stevedore.c */
1008struct object *STV_NewObject(struct busyobj *, struct objcore **,
1009    const char *hint, unsigned len, uint16_t nhttp);
1010struct storage *STV_alloc(struct busyobj *, size_t size);
1011void STV_trim(struct storage *st, size_t size);
1012void STV_free(struct storage *st);
1013void STV_open(void);
1014void STV_close(void);
1015void STV_Freestore(struct object *o);
1016
1017/* storage_synth.c */
1018struct vsb *SMS_Makesynth(struct object *obj);
1019void SMS_Finish(struct object *obj);
1020void SMS_Init(void);
1021
1022/* storage_persistent.c */
1023void SMP_Init(void);
1024void SMP_Ready(void);
1025void SMP_NewBan(const uint8_t *ban, unsigned len);
1026
1027/*
1028 * A normal pointer difference is signed, but we never want a negative value
1029 * so this little tool will make sure we don't get that.
1030 */
1031
1032static inline unsigned
1033pdiff(const void *b, const void *e)
1034{
1035
1036        assert(b <= e);
1037        return
1038            ((unsigned)((const unsigned char *)e - (const unsigned char *)b));
1039}
1040
1041static inline void
1042Tcheck(const txt t)
1043{
1044
1045        AN(t.b);
1046        AN(t.e);
1047        assert(t.b <= t.e);
1048}
1049
1050/*
1051 * unsigned length of a txt
1052 */
1053
1054static inline unsigned
1055Tlen(const txt t)
1056{
1057
1058        Tcheck(t);
1059        return ((unsigned)(t.e - t.b));
1060}
1061
1062static inline void
1063Tadd(txt *t, const char *p, int l)
1064{
1065        Tcheck(*t);
1066
1067        if (l <= 0) {
1068        } if (t->b + l < t->e) {
1069                memcpy(t->b, p, l);
1070                t->b += l;
1071        } else {
1072                t->b = t->e;
1073        }
1074}
1075
1076static inline void
1077AssertOCBusy(const struct objcore *oc)
1078{
1079        AN(oc);
1080        AN (oc->flags & OC_F_BUSY);
1081        AN(oc->busyobj);
1082}
1083
1084static inline void
1085AssertObjCorePassOrBusy(const struct objcore *oc)
1086{
1087        if (oc != NULL)
1088                AN (oc->flags & OC_F_BUSY);
1089}
1090
1091/*
1092 * We want to cache the most recent timestamp in wrk->lastused to avoid
1093 * extra timestamps in cache_pool.c.  Hide this detail with a macro
1094 */
1095#define W_TIM_real(w) ((w)->lastused = VTIM_real())
Note: See TracBrowser for help on using the repository browser.