source: bin/varnishd/cache/cache.h @ d3f869

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

Remove sendfile(2) support, it doesn't seem to actually make any
difference in practice and complicates the code and increases the
size of storage data structures.

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