source: bin/varnishd/cache.h @ 3e3008f

Revision 3e3008f, 20.6 KB checked in by Poul-Henning Kamp <phk@…>, 3 years ago (diff)

Eliminate sp->objhead as a general variable, it was always tracking
sp->objcore and we can find the objhead from the objcore.

Rename it to match its remaining functionality: recording which
busy objhead we are sleeping on.

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

  • Property mode set to 100644
Line 
1/*-
2 * Copyright (c) 2006 Verdens Gang AS
3 * Copyright (c) 2006-2010 Redpill Linpro 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 * $Id$
30 */
31
32/*
33 * This macro can be used in .h files to isolate bits that the manager
34 * should not (need to) see, such as pthread mutexes etc.
35 */
36#define VARNISH_CACHE_CHILD     1
37
38#include <sys/time.h>
39#include <sys/uio.h>
40#include <sys/socket.h>
41
42#include <pthread.h>
43#ifdef HAVE_PTHREAD_NP_H
44#include <pthread_np.h>
45#endif
46#include <stdarg.h>
47#include <stdint.h>
48#include <string.h>
49#include <limits.h>
50#include <unistd.h>
51
52#if defined(HAVE_EPOLL_CTL)
53#include <sys/epoll.h>
54#endif
55
56#include "vqueue.h"
57
58#include "vsb.h"
59
60#include "libvarnish.h"
61
62#include "common.h"
63#include "heritage.h"
64#include "miniobj.h"
65
66#include "vsc.h"
67#include "vsl.h"
68#include "vtypes.h"
69
70/*
71 * NB: HDR_STATUS is only used in cache_http.c, everybody else uses the
72 * http->status integer field.
73 */
74
75enum {
76        /* Fields from the first line of HTTP proto */
77        HTTP_HDR_REQ,
78        HTTP_HDR_URL,
79        HTTP_HDR_PROTO,
80        HTTP_HDR_STATUS,
81        HTTP_HDR_RESPONSE,
82        /* HTTP header lines */
83        HTTP_HDR_FIRST,
84};
85
86struct cli;
87struct vsb;
88struct sess;
89struct director;
90struct object;
91struct objhead;
92struct objcore;
93struct workreq;
94struct esidata;
95struct vrt_backend;
96struct cli_proto;
97struct ban;
98struct SHA256Context;
99struct vsc_lck;
100
101struct lock { void *priv; };            // Opaque
102
103#define DIGEST_LEN              32
104
105
106/*--------------------------------------------------------------------
107 * Pointer aligment magic
108 */
109
110#define PALGN           (sizeof(void *) - 1)
111#define PAOK(p)         (((uintptr_t)(p) & PALGN) == 0)
112#define PRNDDN(p)       ((uintptr_t)(p) & ~PALGN)
113#define PRNDUP(p)       (((uintptr_t)(p) + PALGN) & ~PALGN)
114
115/*--------------------------------------------------------------------*/
116
117typedef struct {
118        char                    *b;
119        char                    *e;
120} txt;
121
122/*--------------------------------------------------------------------*/
123
124enum step {
125#define STEP(l, u)      STP_##u,
126#include "steps.h"
127#undef STEP
128};
129
130/*--------------------------------------------------------------------
131 * Workspace structure for quick memory allocation.
132 */
133
134struct ws {
135        unsigned                magic;
136#define WS_MAGIC                0x35fac554
137        const char              *id;            /* identity */
138        char                    *s;             /* (S)tart of buffer */
139        char                    *f;             /* (F)ree pointer */
140        char                    *r;             /* (R)eserved length */
141        char                    *e;             /* (E)nd of buffer */
142        int                     overflow;       /* workspace overflowed */
143};
144
145/*--------------------------------------------------------------------
146 * HTTP Request/Response/Header handling structure.
147 */
148
149enum httpwhence {
150        HTTP_Rx  = 1,
151        HTTP_Tx  = 2,
152        HTTP_Obj = 3
153};
154
155/* NB: remember to update http_Copy() if you add fields */
156struct http {
157        unsigned                magic;
158#define HTTP_MAGIC              0x6428b5c9
159
160        struct ws               *ws;
161
162        unsigned char           conds;          /* If-* headers present */
163        enum httpwhence         logtag;
164        int                     status;
165        double                  protover;
166
167        unsigned                shd;            /* Size of hd space */
168        txt                     *hd;
169        unsigned char           *hdf;
170#define HDF_FILTER              (1 << 0)        /* Filtered by Connection */
171#define HDF_COPY                (1 << 1)        /* Copy this field */
172        unsigned                nhd;            /* Next free hd */
173};
174
175/*--------------------------------------------------------------------
176 * HTTP Protocol connection structure
177 */
178
179struct http_conn {
180        unsigned                magic;
181#define HTTP_CONN_MAGIC         0x3e19edd1
182
183        int                     fd;
184        struct ws               *ws;
185        txt                     rxbuf;
186        txt                     pipeline;
187};
188
189/*--------------------------------------------------------------------*/
190
191struct acct {
192        double                  first;
193#define ACCT(foo)       uint64_t        foo;
194#include "acct_fields.h"
195#undef ACCT
196};
197
198/*--------------------------------------------------------------------*/
199
200#define L0(n)
201#define L1(n)                   int n;
202#define VSC_F(n, t, l, f, e)    L##l(n)
203#define VSC_DO_MAIN
204struct dstat {
205#include "vsc_fields.h"
206};
207#undef VSC_F
208#undef VSC_DO_MAIN
209#undef L0
210#undef L1
211
212/*--------------------------------------------------------------------*/
213
214struct worker {
215        unsigned                magic;
216#define WORKER_MAGIC            0x6391adcf
217        struct objhead          *nobjhead;
218        struct objcore          *nobjcore;
219        void                    *nhashpriv;
220        struct dstat            stats;
221
222        double                  lastused;
223
224        pthread_cond_t          cond;
225
226        VTAILQ_ENTRY(worker)    list;
227        struct workreq          *wrq;
228
229        int                     *wfd;
230        unsigned                werr;   /* valid after WRK_Flush() */
231        struct iovec            *iov;
232        unsigned                siov;
233        unsigned                niov;
234        ssize_t                 liov;
235
236        struct VCL_conf         *vcl;
237
238        uint32_t                *wlb, *wlp, *wle;
239        unsigned                wlr;
240
241        struct SHA256Context    *sha256ctx;
242
243        struct http_conn        htc[1];
244        struct ws               ws[1];
245        struct http             *http[3];
246        struct http             *bereq;
247        struct http             *beresp1;
248        struct http             *beresp;
249        struct http             *resp;
250
251        enum body_status        body_status;
252        unsigned                cacheable;
253        double                  age;
254        double                  entered;
255        double                  ttl;
256        double                  grace;
257        unsigned                do_esi;
258
259        /* Timeouts */
260        double                  connect_timeout;
261        double                  first_byte_timeout;
262        double                  between_bytes_timeout;
263
264};
265
266/* Work Request for worker thread ------------------------------------*/
267
268/*
269 * This is a worker-function.
270 * XXX: typesafety is probably not worth fighting for
271 */
272
273typedef void workfunc(struct worker *, void *priv);
274
275struct workreq {
276        VTAILQ_ENTRY(workreq)   list;
277        workfunc                *func;
278        void                    *priv;
279};
280
281/* Storage -----------------------------------------------------------*/
282
283struct storage {
284        unsigned                magic;
285#define STORAGE_MAGIC           0x1a4e51c0
286        VTAILQ_ENTRY(storage)   list;
287        struct stevedore        *stevedore;
288        void                    *priv;
289
290        unsigned char           *ptr;
291        unsigned                len;
292        unsigned                space;
293
294        int                     fd;
295        off_t                   where;
296};
297
298/* Object core structure ---------------------------------------------
299 * Objects have sideways references in the binary heap and the LRU list
300 * and we want to avoid paging in a lot of objects just to move them up
301 * or down the binheap or to move a unrelated object on the LRU list.
302 * To avoid this we use a proxy object, objcore, to hold the relevant
303 * housekeeping fields parts of an object.
304 */
305
306typedef struct object *getobj_f(struct worker *wrk, struct objcore *oc);
307typedef void updatemeta_f(struct objcore *oc);
308typedef void freeobj_f(struct objcore *oc);
309
310struct objcore_methods {
311        getobj_f        *getobj;
312        updatemeta_f    *updatemeta;
313        freeobj_f       *freeobj;
314};
315
316extern struct objcore_methods default_oc_methods;
317
318struct objcore {
319        unsigned                magic;
320#define OBJCORE_MAGIC           0x4d301302
321        unsigned                refcnt;
322        struct objcore_methods  *methods;
323        void                    *priv;
324        unsigned                priv2;
325        struct objhead          *objhead;
326        double                  timer_when;
327        unsigned                flags;
328#define OC_F_ONLRU              (1<<0)
329#define OC_F_BUSY               (1<<1)
330#define OC_F_PASS               (1<<2)
331#define OC_F_LRUDONTMOVE        (1<<4)
332#define OC_F_PRIV               (1<<5)          /* Stevedore private flag */
333        unsigned                timer_idx;
334        VTAILQ_ENTRY(objcore)   list;
335        VLIST_ENTRY(objcore)    lru_list;
336        VTAILQ_ENTRY(objcore)   ban_list;
337        struct ban              *ban;
338};
339
340static inline struct object *
341oc_getobj(struct worker *wrk, struct objcore *oc)
342{
343
344        return (oc->methods->getobj(wrk, oc));
345}
346
347static inline void
348oc_updatemeta(struct objcore *oc)
349{
350
351        if (oc->methods->updatemeta != NULL)
352                oc->methods->updatemeta(oc);
353}
354
355static inline void
356oc_freeobj(struct objcore *oc)
357{
358
359        oc->methods->freeobj(oc);
360}
361
362/*--------------------------------------------------------------------*/
363
364struct lru {
365        unsigned                magic;
366#define LRU_MAGIC               0x3fec7bb0
367        VLIST_HEAD(,objcore)    lru_head;
368        struct objcore          senteniel;
369};
370
371/* Object structure --------------------------------------------------*/
372
373struct object {
374        unsigned                magic;
375#define OBJECT_MAGIC            0x32851d42
376        unsigned                xid;
377        struct storage          *objstore;
378        struct objcore          *objcore;
379
380        unsigned                smp_index;
381
382        struct ws               ws_o[1];
383        unsigned char           *vary;
384
385        double                  ban_t;
386        unsigned                response;
387
388        unsigned                cacheable;
389
390        unsigned                len;
391
392        double                  ttl;
393        double                  age;
394        double                  entered;
395        double                  grace;
396
397        double                  last_modified;
398        double                  last_lru;
399
400        struct http             *http;
401
402        VTAILQ_HEAD(, storage)  store;
403
404        struct esidata          *esidata;
405
406        double                  last_use;
407
408        int                     hits;
409};
410
411/* -------------------------------------------------------------------*/
412
413struct sess {
414        unsigned                magic;
415#define SESS_MAGIC              0x2c2f9c5a
416        int                     fd;
417        int                     id;
418        unsigned                xid;
419
420        int                     restarts;
421        int                     esis;
422        int                     disable_esi;
423
424        uint8_t                 hash_ignore_busy;
425        uint8_t                 hash_always_miss;
426
427        struct worker           *wrk;
428
429        socklen_t               sockaddrlen;
430        socklen_t               mysockaddrlen;
431        struct sockaddr_storage *sockaddr;
432        struct sockaddr_storage *mysockaddr;
433        struct listen_sock      *mylsock;
434
435        /* formatted ascii client address */
436        char                    *addr;
437        char                    *port;
438        char                    *client_identity;
439
440        /* HTTP request */
441        const char              *doclose;
442        struct http             *http;
443        struct http             *http0;
444
445        struct ws               ws[1];
446        char                    *ws_ses;        /* WS above session data */
447        char                    *ws_req;        /* WS above request data */
448
449        unsigned char           digest[DIGEST_LEN];
450
451        struct http_conn        htc[1];
452
453        /* Timestamps, all on TIM_real() timescale */
454        double                  t_open;
455        double                  t_req;
456        double                  t_resp;
457        double                  t_end;
458
459        /* Acceptable grace period */
460        double                  grace;
461
462        enum step               step;
463        unsigned                cur_method;
464        unsigned                handling;
465        unsigned char           pass;
466        unsigned char           sendbody;
467        unsigned char           wantbody;
468        int                     err_code;
469        const char              *err_reason;
470
471        VTAILQ_ENTRY(sess)      list;
472
473        struct director         *director;
474        struct vbc              *vbc;
475        struct object           *obj;
476        struct objcore          *objcore;
477        struct VCL_conf         *vcl;
478
479        /* The busy objhead we sleep on */
480        struct objhead          *hash_objhead;
481
482        /* Various internal stuff */
483        struct sessmem          *mem;
484
485        struct workreq          workreq;
486        struct acct             acct_tmp;
487        struct acct             acct_req;
488        struct acct             acct_ses;
489
490#if defined(HAVE_EPOLL_CTL)
491        struct epoll_event ev;
492#endif
493};
494
495/* -------------------------------------------------------------------*/
496
497/* Backend connection */
498struct vbc {
499        unsigned                magic;
500#define VBC_MAGIC               0x0c5e6592
501        VTAILQ_ENTRY(vbc)       list;
502        struct backend          *backend;
503        struct vdi_simple       *vdis;
504        int                     fd;
505
506        struct sockaddr_storage *addr;
507        socklen_t               addrlen;
508
509        uint8_t                 recycled;
510
511        /* Timeouts */
512        double                  first_byte_timeout;
513        double                  between_bytes_timeout;
514};
515
516/* Prototypes etc ----------------------------------------------------*/
517
518/* cache_acceptor.c */
519void vca_return_session(struct sess *sp);
520void vca_close_session(struct sess *sp, const char *why);
521void VCA_Prep(struct sess *sp);
522void VCA_Init(void);
523void VCA_Shutdown(void);
524const char *VCA_waiter_name(void);
525extern pthread_t VCA_thread;
526
527/* cache_backend.c */
528void VBE_UseHealth(const struct director *vdi);
529
530struct vbc *VDI_GetFd(const struct director *, struct sess *sp);
531int VDI_Healthy(const struct director *, const struct sess *sp);
532void VDI_CloseFd(struct sess *sp);
533void VDI_RecycleFd(struct sess *sp);
534void VDI_AddHostHeader(const struct sess *sp);
535void VBE_Poll(void);
536
537/* cache_backend_cfg.c */
538void VBE_Init(void);
539struct backend *VBE_AddBackend(struct cli *cli, const struct vrt_backend *vb);
540
541/* cache_backend_poll.c */
542void VBP_Init(void);
543
544/* cache_ban.c */
545struct ban *BAN_New(void);
546int BAN_AddTest(struct cli *, struct ban *, const char *, const char *,
547    const char *);
548void BAN_Free(struct ban *b);
549void BAN_Insert(struct ban *b);
550void BAN_Init(void);
551void BAN_NewObj(struct object *o);
552void BAN_DestroyObj(struct objcore *oc);
553int BAN_CheckObject(struct object *o, const struct sess *sp);
554void BAN_Reload(double t0, unsigned flags, const char *ban);
555struct ban *BAN_TailRef(void);
556void BAN_Compile(void);
557struct ban *BAN_RefBan(struct objcore *oc, double t0, const struct ban *tail);
558void BAN_Deref(struct ban **ban);
559
560/* cache_center.c [CNT] */
561void CNT_Session(struct sess *sp);
562void CNT_Init(void);
563
564/* cache_cli.c [CLI] */
565void CLI_Init(void);
566void CLI_Run(void);
567void CLI_AddFuncs(struct cli_proto *p);
568extern pthread_t cli_thread;
569#define ASSERT_CLI() do {assert(pthread_self() == cli_thread);} while (0)
570
571/* cache_expiry.c */
572void EXP_Insert(struct object *o);
573void EXP_Inject(struct objcore *oc, struct lru *lru, double ttl);
574void EXP_Init(void);
575void EXP_Rearm(const struct object *o);
576int EXP_Touch(const struct object *o);
577int EXP_NukeOne(const struct sess *sp, const struct lru *lru);
578
579/* cache_fetch.c */
580int FetchHdr(struct sess *sp);
581int FetchBody(struct sess *sp);
582int FetchReqBody(struct sess *sp);
583void Fetch_Init(void);
584
585/* cache_http.c */
586unsigned HTTP_estimate(unsigned nhttp);
587void HTTP_Copy(struct http *to, const struct http * const fm);
588struct http *HTTP_create(void *p, unsigned nhttp);
589const char *http_StatusMessage(unsigned);
590unsigned http_EstimateWS(const struct http *fm, unsigned how, unsigned *nhd);
591void HTTP_Init(void);
592void http_ClrHeader(struct http *to);
593unsigned http_Write(struct worker *w, const struct http *hp, int resp);
594void http_CopyResp(struct http *to, const struct http *fm);
595void http_SetResp(struct http *to, const char *proto, int status,
596    const char *response);
597void http_FilterFields(struct worker *w, int fd, struct http *to,
598    const struct http *fm, unsigned how);
599void http_FilterHeader(const struct sess *sp, unsigned how);
600void http_PutProtocol(struct worker *w, int fd, const struct http *to,
601    const char *protocol);
602void http_PutStatus(struct http *to, int status);
603void http_PutResponse(struct worker *w, int fd, const struct http *to,
604    const char *response);
605void http_PrintfHeader(struct worker *w, int fd, struct http *to,
606    const char *fmt, ...);
607void http_SetHeader(struct worker *w, int fd, struct http *to, const char *hdr);
608void http_SetH(const struct http *to, unsigned n, const char *fm);
609void http_ForceGet(const struct http *to);
610void http_Setup(struct http *ht, struct ws *ws);
611int http_GetHdr(const struct http *hp, const char *hdr, char **ptr);
612int http_GetHdrField(const struct http *hp, const char *hdr,
613    const char *field, char **ptr);
614int http_GetStatus(const struct http *hp);
615const char *http_GetReq(const struct http *hp);
616int http_HdrIs(const struct http *hp, const char *hdr, const char *val);
617int http_DissectRequest(struct sess *sp);
618int http_DissectResponse(struct worker *w, const struct http_conn *htc,
619    struct http *sp);
620const char *http_DoConnection(const struct http *hp);
621void http_CopyHome(struct worker *w, int fd, const struct http *hp);
622void http_Unset(struct http *hp, const char *hdr);
623void http_CollectHdr(struct http *hp, const char *hdr);
624
625/* cache_httpconn.c */
626void HTC_Init(struct http_conn *htc, struct ws *ws, int fd);
627int HTC_Reinit(struct http_conn *htc);
628int HTC_Rx(struct http_conn *htc);
629int HTC_Read(struct http_conn *htc, void *d, unsigned len);
630int HTC_Complete(struct http_conn *htc);
631
632#define HTTPH(a, b, c, d, e, f, g) extern char b[];
633#include "http_headers.h"
634#undef HTTPH
635
636/* cache_main.c */
637void THR_SetName(const char *name);
638const char* THR_GetName(void);
639void THR_SetSession(const struct sess *sp);
640const struct sess * THR_GetSession(void);
641
642/* cache_lck.c */
643
644/* Internal functions, call only through macros below */
645void Lck__Lock(struct lock *lck, const char *p, const char *f, int l);
646void Lck__Unlock(struct lock *lck, const char *p, const char *f, int l);
647int Lck__Trylock(struct lock *lck, const char *p, const char *f, int l);
648void Lck__New(struct lock *lck, struct vsc_lck *, const char *);
649void Lck__Assert(const struct lock *lck, int held);
650
651/* public interface: */
652void LCK_Init(void);
653void Lck_Delete(struct lock *lck);
654void Lck_CondWait(pthread_cond_t *cond, struct lock *lck);
655
656#define Lck_New(a, b) Lck__New(a, b, #b)
657#define Lck_Lock(a) Lck__Lock(a, __func__, __FILE__, __LINE__)
658#define Lck_Unlock(a) Lck__Unlock(a, __func__, __FILE__, __LINE__)
659#define Lck_Trylock(a) Lck__Trylock(a, __func__, __FILE__, __LINE__)
660#define Lck_AssertHeld(a) Lck__Assert(a, 1)
661#define Lck_AssertNotHeld(a) Lck__Assert(a, 0)
662
663#define LOCK(nam) extern struct vsc_lck *lck_##nam;
664#include "locks.h"
665#undef LOCK
666
667/* cache_panic.c */
668void PAN_Init(void);
669
670/* cache_pipe.c */
671void PipeSession(struct sess *sp);
672
673/* cache_pool.c */
674void WRK_Init(void);
675int WRK_Queue(struct workreq *wrq);
676int WRK_QueueSession(struct sess *sp);
677void WRK_SumStat(struct worker *w);
678
679void WRW_Reserve(struct worker *w, int *fd);
680unsigned WRW_Flush(struct worker *w);
681unsigned WRW_FlushRelease(struct worker *w);
682unsigned WRW_Write(struct worker *w, const void *ptr, int len);
683unsigned WRW_WriteH(struct worker *w, const txt *hh, const char *suf);
684#ifdef SENDFILE_WORKS
685void WRW_Sendfile(struct worker *w, int fd, off_t off, unsigned len);
686#endif  /* SENDFILE_WORKS */
687
688typedef void *bgthread_t(struct sess *, void *priv);
689void WRK_BgThread(pthread_t *thr, const char *name, bgthread_t *func,
690    void *priv);
691
692/* cache_session.c [SES] */
693void SES_Init(void);
694struct sess *SES_New(void);
695struct sess *SES_Alloc(void);
696void SES_Delete(struct sess *sp);
697void SES_Charge(struct sess *sp);
698
699/* cache_shmlog.c */
700void VSL_Init(void);
701#ifdef VSL_ENDMARKER
702void VSL(enum vsl_tag tag, int id, const char *fmt, ...);
703void WSLR(struct worker *w, enum vsl_tag tag, int id, txt t);
704void WSL(struct worker *w, enum vsl_tag tag, int id, const char *fmt, ...);
705void WSL_Flush(struct worker *w, int overflow);
706
707#define DSL(flag, tag, id, ...)                                 \
708        do {                                                    \
709                if (params->diag_bitmap & (flag))               \
710                        VSL((tag), (id), __VA_ARGS__);          \
711        } while (0)
712
713#define WSP(sess, tag, ...)                                     \
714        WSL((sess)->wrk, tag, (sess)->fd, __VA_ARGS__)
715
716#define WSPR(sess, tag, txt)                                    \
717        WSLR((sess)->wrk, tag, (sess)->fd, txt)
718
719#define INCOMPL() do {                                                  \
720        VSL(SLT_Debug, 0, "INCOMPLETE AT: %s(%d)", __func__, __LINE__); \
721        fprintf(stderr,                                                 \
722            "INCOMPLETE AT: %s(%d)\n",                                  \
723            (const char *)__func__, __LINE__);                          \
724        abort();                                                        \
725        } while (0)
726#endif
727
728/* cache_response.c */
729void RES_BuildHttp(struct sess *sp);
730void RES_WriteObj(struct sess *sp);
731
732/* cache_vary.c */
733struct vsb *VRY_Create(const struct sess *sp, const struct http *hp);
734int VRY_Match(const struct sess *sp, const unsigned char *vary);
735
736/* cache_vcl.c */
737void VCL_Init(void);
738void VCL_Refresh(struct VCL_conf **vcc);
739void VCL_Rel(struct VCL_conf **vcc);
740void VCL_Get(struct VCL_conf **vcc);
741void VCL_Poll(void);
742
743#define VCL_MET_MAC(l,u,b) void VCL_##l##_method(struct sess *);
744#include "vcl_returns.h"
745#undef VCL_MET_MAC
746
747/* cache_vrt.c */
748
749char *VRT_String(struct ws *ws, const char *h, const char *p, va_list ap);
750char *VRT_StringList(char *d, unsigned dl, const char *p, va_list ap);
751
752/* cache_vrt_esi.c */
753
754void ESI_Deliver(struct sess *);
755void ESI_Destroy(struct object *);
756void ESI_Parse(struct sess *);
757
758/* cache_vrt_vmod.c */
759void VMOD_Init(void);
760
761/* cache_ws.c */
762
763void WS_Init(struct ws *ws, const char *id, void *space, unsigned len);
764unsigned WS_Reserve(struct ws *ws, unsigned bytes);
765void WS_Release(struct ws *ws, unsigned bytes);
766void WS_ReleaseP(struct ws *ws, char *ptr);
767void WS_Assert(const struct ws *ws);
768void WS_Reset(struct ws *ws, char *p);
769char *WS_Alloc(struct ws *ws, unsigned bytes);
770char *WS_Dup(struct ws *ws, const char *);
771char *WS_Snapshot(struct ws *ws);
772unsigned WS_Free(const struct ws *ws);
773
774/* rfc2616.c */
775double RFC2616_Ttl(const struct sess *sp);
776enum body_status RFC2616_Body(const struct sess *sp);
777
778/* storage_synth.c */
779struct vsb *SMS_Makesynth(struct object *obj);
780void SMS_Finish(struct object *obj);
781
782/* storage_persistent.c */
783void SMP_Ready(void);
784void SMP_NewBan(double t0, const char *ban);
785
786/*
787 * A normal pointer difference is signed, but we never want a negative value
788 * so this little tool will make sure we don't get that.
789 */
790
791static inline unsigned
792pdiff(const void *b, const void *e)
793{
794
795        assert(b <= e);
796        return
797            ((unsigned)((const unsigned char *)e - (const unsigned char *)b));
798}
799
800static inline void
801Tcheck(const txt t)
802{
803
804        AN(t.b);
805        AN(t.e);
806        assert(t.b <= t.e);
807}
808
809/*
810 * unsigned length of a txt
811 */
812
813static inline unsigned
814Tlen(const txt t)
815{
816
817        Tcheck(t);
818        return ((unsigned)(t.e - t.b));
819}
820
821static inline void
822Tadd(txt *t, const char *p, int l)
823{
824        Tcheck(*t);
825
826        if (l <= 0) {
827        } if (t->b + l < t->e) {
828                memcpy(t->b, p, l);
829                t->b += l;
830        } else {
831                t->b = t->e;
832        }
833}
834
835static inline void
836AssertObjBusy(const struct object *o)
837{
838        AN(o->objcore);
839        AN (o->objcore->flags & OC_F_BUSY);
840}
841
842static inline void
843AssertObjPassOrBusy(const struct object *o)
844{
845        if (o->objcore != NULL)
846                AN (o->objcore->flags & OC_F_BUSY);
847}
Note: See TracBrowser for help on using the repository browser.