source: bin/varnishd/cache/cache.h @ 22c90f

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

Move do_gzip, do_gunzip and do_esi from worker to busyobj

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