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

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

Move the accept sockets into the new pool-task API and GC all the
cruft now not needed.

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