1VARNISHD(1) VARNISHD(1)
2
6 varnishd - HTTP accelerator daemon
7
9 varnishd [-a
10 [name=][address][:port][,PROTO][,user=<user>][,group=<group>][,mode=<mode>]]
11 [-b [host[:port]|path]] [-C] [-d] [-F] [-f config] [-h type[,options]]
12 [-I clifile] [-i identity] [-j jail[,jailoptions]] [-l vsl] [-M
13 address:port] [-n name] [-P file] [-p param=value] [-r
14 param[,param...]] [-S secret-file] [-s [name=]kind[,options]] [-T
15 address[:port]] [-t TTL] [-V] [-W waiter]
16 varnishd [-x parameter|vsl|cli|builtin|optstring]
18 varnishd [-?]
20
22 The varnishd daemon accepts HTTP requests from clients, passes them on
23 to a backend server and caches the returned documents to better satisfy
24 future requests for the same document.
25
27 Basic options
28 -a
29 <[name=][address][:port][,PROTO][,user=<user>][,group=<group>][,mode=<mode>]>
30 Listen for client requests on the specified address and port. The
31 address can be a host name ("localhost"), an IPv4 dotted-quad
32 ("127.0.0.1"), an IPv6 address enclosed in square brackets
33 ("[::1]"), or a path beginning with a '/' for a Unix domain socket
34 ("/path/to/listen.sock"). If address is not specified, varnishd will
35 listen on all available IPv4 and IPv6 interfaces. If port is not
36 specified, port 80 (http) is used. At least one of address or port
37 is required.
38 If a Unix domain socket is specified as the listen address, then the
40 user, group and mode sub-arguments may be used to specify the per‐
41 missions of the socket file -- use names for user and group, and a
42 3-digit octal value for mode. These sub-arguments are not permitted
43 if an IP address is specified. When Unix domain socket listeners are
44 in use, all VCL configurations must have version >= 4.1.
45 Name is referenced in logs. If name is not specified, "a0", "a1",
47 etc. is used. An additional protocol type can be set for the listen‐
48 ing socket with PROTO. Valid protocol types are: HTTP (default), and
49 PROXY.
50 Multiple listening addresses can be specified by using different -a
52 arguments.
53 -b <[host[:port]|path]>
55 Use the specified host as backend server. If port is not speci‐
56 fied, the default is 8080.
57 If the value of -b begins with /, it is interpreted as the abso‐
59 lute path of a Unix domain socket to which Varnish connects. In
60 that case, the value of -b must satisfy the conditions required
61 for the .path field of a backend declaration, see vcl(7). Back‐
62 ends with Unix socket addresses may only be used with VCL ver‐
63 sions >= 4.1.
64 -b can be used only once, and not together with f.
66 -f config
68 Use the specified VCL configuration file instead of the builtin
69 default. See vcl(7) for details on VCL syntax.
70 If a single -f option is used, then the VCL instance loaded from
72 the file is named "boot" and immediately becomes active. If more
73 than one -f option is used, the VCL instances are named "boot0",
74 "boot1" and so forth, in the order corresponding to the -f argu‐
75 ments, and the last one is named "boot", which becomes active.
76 Either -b or one or more -f options must be specified, but not
78 both, and they cannot both be left out, unless -d is used to
79 start varnishd in debugging mode. If the empty string is speci‐
80 fied as the sole -f option, then varnishd starts without start‐
81 ing the worker process, and the management process will accept
82 CLI commands. You can also combine an empty -f option with an
83 initialization script (-I option) and the child process will be
84 started if there is an active VCL at the end of the initializa‐
85 tion.
86 When used with a relative file name, config is searched in the
88 vcl_path. It is possible to set this path prior to using -f
89 options with a -p option. During startup, varnishd doesn't com‐
90 plain about unsafe VCL paths: unlike the varnish-cli(7) that
91 could later be accessed remotely, starting varnishd requires
92 local privileges.
93 -n name
95 Specify the name for this instance. This name is used to con‐
96 struct the name of the directory in which varnishd keeps tempo‐
97 rary files and persistent state. If the specified name begins
98 with a forward slash, it is interpreted as the absolute path to
99 the directory.
100 Documentation options
102 For these options, varnishd prints information to standard output and
103 exits. When a -x option is used, it must be the only option (it outputs
104 documentation in reStructuredText, aka RST).
105 -?
107 Print the usage message.
108 -x parameter
110 Print documentation of the runtime parameters (-p options), see
111 List of Parameters.
112 -x vsl Print documentation of the tags used in the Varnish shared mem‐
114 ory log, see vsl(7).
115 -x cli Print documentation of the command line interface, see var‐
117 nish-cli(7).
118 -x builtin
120 Print the contents of the default VCL program builtin.vcl.
121 -x optstring
123 Print the optstring parameter to getopt(3) to help writing wrap‐
124 per scripts.
125 Operations options
127 -F Do not fork, run in the foreground. Only one of -F or -d can be
128 specified, and -F cannot be used together with -C.
129 -T <address[:port]>
131 Offer a management interface on the specified address and port.
132 See varnish-cli(7) for documentation of the management commands.
133 To disable the management interface use none.
134 -M <address:port>
136 Connect to this port and offer the command line interface.
137 Think of it as a reverse shell. When running with -M and there
138 is no backend defined the child process (the cache) will not
139 start initially.
140 -P file
142 Write the PID of the process to the specified file.
143 -i identity
145 Specify the identity of the Varnish server. This can be accessed
146 using server.identity from VCL and with VSM_Name() from utili‐
147 ties. If not specified the output of gethostname(3) is used.
148 -I clifile
150 Execute the management commands in the file given as clifile
151 before the the worker process starts, see CLI Command File.
152 Tuning options
154 -t TTL Specifies the default time to live (TTL) for cached objects.
155 This is a shortcut for specifying the default_ttl run-time
156 parameter.
157 -p <param=value>
159 Set the parameter specified by param to the specified value, see
160 List of Parameters for details. This option can be used multiple
161 times to specify multiple parameters.
162 -s <[name=]type[,options]>
164 Use the specified storage backend. See Storage Backend section.
165 This option can be used multiple times to specify multiple stor‐
167 age files. Name is referenced in logs, VCL, statistics, etc. If
168 name is not specified, "s0", "s1" and so forth is used.
169 -l <vsl>
171 Specifies size of the space for the VSL records, shorthand for
172 -p vsl_space=<vsl>. Scaling suffixes like 'K' and 'M' can be
173 used up to (G)igabytes. See vsl_space for more information.
174 Security options
176 -r <param[,param...]>
177 Make the listed parameters read only. This gives the system
178 administrator a way to limit what the Varnish CLI can do. Con‐
179 sider making parameters such as cc_command, vcc_allow_inline_c
180 and vmod_path read only as these can potentially be used to
181 escalate privileges from the CLI.
182 -S secret-file
184 Path to a file containing a secret used for authorizing access
185 to the management port. To disable authentication use none.
186 If this argument is not provided, a secret drawn from the system
188 PRNG will be written to a file called _.secret in the working
189 directory (see opt_n) with default ownership and permissions of
190 the user having started varnish.
191 Thus, users wishing to delegate control over varnish will proba‐
193 bly want to create a custom secret file with appropriate permis‐
194 sions (ie. readable by a unix group to delegate control to).
195 -j <jail[,jailoptions]>
197 Specify the jailing mechanism to use. See Jail section.
198 Advanced, development and debugging options
200 -d Enables debugging mode: The parent process runs in the fore‐
201 ground with a CLI connection on stdin/stdout, and the child
202 process must be started explicitly with a CLI command. Terminat‐
203 ing the parent process will also terminate the child.
204 Only one of -d or -F can be specified, and -d cannot be used
206 together with -C.
207 -C Print VCL code compiled to C language and exit. Specify the VCL
209 file to compile with the -f option. Either -f or -b must be used
210 with -C, and -C cannot be used with -F or -d.
211 -V Display the version number and exit. This must be the only
213 option.
214 -h <type[,options]>
216 Specifies the hash algorithm. See Hash Algorithm section for a
217 list of supported algorithms.
218 -W waiter
220 Specifies the waiter type to use.
221 Hash Algorithm
223 The following hash algorithms are available:
224 -h critbit
226 self-scaling tree structure. The default hash algorithm in Var‐
227 nish Cache 2.1 and onwards. In comparison to a more traditional
228 B tree the critbit tree is almost completely lockless. Do not
229 change this unless you are certain what you're doing.
230 -h simple_list
232 A simple doubly-linked list. Not recommended for production
233 use.
234 -h <classic[,buckets]>
236 A standard hash table. The hash key is the CRC32 of the object's
237 URL modulo the size of the hash table. Each table entry points
238 to a list of elements which share the same hash key. The buckets
239 parameter specifies the number of entries in the hash table.
240 The default is 16383.
241 Storage Backend
243 The argument format to define storage backends is:
244 -s <[name]=kind[,options]>
246 If name is omitted, Varnish will name storages sN, starting with
247 s0 and incrementing N for every new storage.
248 For kind and options see details below.
250 Storages can be used in vcl as storage.name, so, for example if myStor‐
252 age was defined by -s myStorage=malloc,5G, it could be used in VCL like
253 so:
254 set beresp.storage = storage.myStorage;
256 A special name is Transient which is the default storage for
258 uncacheable objects as resulting from a pass, hit-for-miss or
259 hit-for-pass.
260 If no -s options are given, the default is:
262 -s malloc=100m
264 If no Transient storage is defined, the default is an unbound malloc
266 storage as if defined as:
267 -s Transient=malloc
269 The following storage types and options are available:
271 -s <default[,size]>
273 The default storage type resolves to umem where available and
274 malloc otherwise.
275 -s <malloc[,size]>
277 malloc is a memory based backend.
278 -s <umem[,size]>
280 umem is a storage backend which is more efficient than malloc on
281 platforms where it is available.
282 See the section on umem in chapter Storage backends of The Var‐
284 nish Users Guide for details.
285 -s <file,path[,size[,granularity[,advice]]]>
287 The file backend stores data in a file on disk. The file will be
288 accessed using mmap. Note that this storage provide no cache
289 persistence.
290 The path is mandatory. If path points to a directory, a tempo‐
292 rary file will be created in that directory and immediately
293 unlinked. If path points to a non-existing file, the file will
294 be created.
295 If size is omitted, and path points to an existing file with a
297 size greater than zero, the size of that file will be used. If
298 not, an error is reported.
299 Granularity sets the allocation block size. Defaults to the sys‐
301 tem page size or the filesystem block size, whichever is larger.
302 Advice tells the kernel how varnishd expects to use this mapped
304 region so that the kernel can choose the appropriate read-ahead
305 and caching techniques. Possible values are normal, random and
306 sequential, corresponding to MADV_NORMAL, MADV_RANDOM and
307 MADV_SEQUENTIAL madvise() advice argument, respectively.
308 Defaults to random.
309 -s <persistent,path,size>
311 Persistent storage. Varnish will store objects in a file in a
312 manner that will secure the survival of most of the objects in
313 the event of a planned or unplanned shutdown of Varnish. The
314 persistent storage backend has multiple issues with it and will
315 likely be removed from a future version of Varnish.
316 Jail
318 Varnish jails are a generalization over various platform specific meth‐
319 ods to reduce the privileges of varnish processes. They may have spe‐
320 cific options. Available jails are:
321 -j solaris
323 Reduce privileges(5) for varnishd and sub-process to the mini‐
324 mally required set. Only available on platforms which have the
325 setppriv(2) call.
326 -j <unix[,user=`user`][,ccgroup=`group`][,workuser=`user`]>
328 Default on all other platforms when varnishd is started with an
329 effective uid of 0 ("as root").
330 With the unix jail mechanism activated, varnish will switch to
332 an alternative user for subprocesses and change the effective
333 uid of the master process whenever possible.
334 The optional user argument specifies which alternative user to
336 use. It defaults to varnish.
337 The optional ccgroup argument specifies a group to add to var‐
339 nish subprocesses requiring access to a c-compiler. There is no
340 default.
341 The optional workuser argument specifies an alternative user to
343 use for the worker process. It defaults to vcache.
344 -j none
346 last resort jail choice: With jail mechanism none, varnish will
347 run all processes with the privileges it was started with.
348 Management Interface
350 If the -T option was specified, varnishd will offer a command-line man‐
351 agement interface on the specified address and port. The recommended
352 way of connecting to the command-line management interface is through
353 varnishadm(1).
354 The commands available are documented in varnish-cli(7).
356 CLI Command File
358 The -I option makes it possible to run arbitrary management commands
359 when varnishd is launched, before the worker process is started. In
360 particular, this is the way to load configurations, apply labels to
361 them, and make a VCL instance active that uses those labels on startup:
362 vcl.load panic /etc/varnish_panic.vcl
364 vcl.load siteA0 /etc/varnish_siteA.vcl
365 vcl.load siteB0 /etc/varnish_siteB.vcl
366 vcl.load siteC0 /etc/varnish_siteC.vcl
367 vcl.label siteA siteA0
368 vcl.label siteB siteB0
369 vcl.label siteC siteC0
370 vcl.load main /etc/varnish_main.vcl
371 vcl.use main
372 Every line in the file, including the last line, must be terminated by
374 a newline or carriage return.
375 If a command in the file is prefixed with '-', failure will not abort
377 the startup.
378
380 Run Time Parameter Flags
381 Runtime parameters are marked with shorthand flags to avoid repeating
382 the same text over and over in the table below. The meaning of the
383 flags are:
384 · experimental
386 We have no solid information about good/bad/optimal values for this
388 parameter. Feedback with experience and observations are most wel‐
389 come.
390 · delayed
392 This parameter can be changed on the fly, but will not take effect
394 immediately.
395 · restart
397 The worker process must be stopped and restarted, before this parame‐
399 ter takes effect.
400 · reload
402 The VCL programs must be reloaded for this parameter to take effect.
404 · experimental
406 We're not really sure about this parameter, tell us what you find.
408 · wizard
410 Do not touch unless you really know what you're doing.
412 · only_root
414 Only works if varnishd is running as root.
416 Default Value Exceptions on 32 bit Systems
418 Be aware that on 32 bit systems, certain default or maximum values are
419 reduced relative to the values listed below, in order to conserve VM
420 space:
421 · workspace_client: 24k
423 · workspace_backend: 20k
425 · http_resp_size: 8k
427 · http_req_size: 12k
429 · gzip_buffer: 4k
431 · vsl_space: 1G (maximum)
433 · thread_pool_stack: 52k
435 List of Parameters
437 This text is produced from the same text you will find in the CLI if
438 you use the param.show command:
439 accept_filter
441 NB: This parameter depends on a feature which is not available on all
442 platforms.
443 · Units: bool
445 · Default: on (if your platform supports accept filters)
447 Enable kernel accept-filters. This may require a kernel module to be
449 loaded to have an effect when enabled.
450 Enabling accept_filter may prevent some requests to reach Varnish in
452 the first place. Malformed requests may go unnoticed and not increase
453 the client_req_400 counter. GET or HEAD requests with a body may be
454 blocked altogether.
455 acceptor_sleep_decay
457 · Default: 0.9
458 · Minimum: 0
460 · Maximum: 1
462 · Flags: experimental
464 If we run out of resources, such as file descriptors or worker threads,
466 the acceptor will sleep between accepts. This parameter (multiplica‐
467 tively) reduce the sleep duration for each successful accept. (ie: 0.9
468 = reduce by 10%)
469 acceptor_sleep_incr
471 · Units: seconds
472 · Default: 0.000
474 · Minimum: 0.000
476 · Maximum: 1.000
478 · Flags: experimental
480 If we run out of resources, such as file descriptors or worker threads,
482 the acceptor will sleep between accepts. This parameter control how
483 much longer we sleep, each time we fail to accept a new connection.
484 acceptor_sleep_max
486 · Units: seconds
487 · Default: 0.050
489 · Minimum: 0.000
491 · Maximum: 10.000
493 · Flags: experimental
495 If we run out of resources, such as file descriptors or worker threads,
497 the acceptor will sleep between accepts. This parameter limits how
498 long it can sleep between attempts to accept new connections.
499 auto_restart
501 · Units: bool
502 · Default: on
504 Automatically restart the child/worker process if it dies.
506 backend_idle_timeout
508 · Units: seconds
509 · Default: 60.000
511 · Minimum: 1.000
513 Timeout before we close unused backend connections.
515 backend_local_error_holddown
517 · Units: seconds
518 · Default: 10.000
520 · Minimum: 0.000
522 · Flags: experimental
524 When connecting to backends, certain error codes (EADDRNOTAVAIL, EAC‐
526 CESS, EPERM) signal a local resource shortage or configuration issue
527 for which retrying connection attempts may worsen the situation due to
528 the complexity of the operations involved in the kernel. This parame‐
529 ter prevents repeated connection attempts for the configured duration.
530 backend_remote_error_holddown
532 · Units: seconds
533 · Default: 0.250
535 · Minimum: 0.000
537 · Flags: experimental
539 When connecting to backends, certain error codes (ECONNREFUSED, ENETUN‐
541 REACH) signal fundamental connection issues such as the backend not
542 accepting connections or routing problems for which repeated connection
543 attempts are considered useless This parameter prevents repeated con‐
544 nection attempts for the configured duration.
545 ban_cutoff
547 · Units: bans
548 · Default: 0
550 · Minimum: 0
552 · Flags: experimental
554 Expurge long tail content from the cache to keep the number of bans
556 below this value. 0 disables.
557 When this parameter is set to a non-zero value, the ban lurker contin‐
559 ues to work the ban list as usual top to bottom, but when it reaches
560 the ban_cutoff-th ban, it treats all objects as if they matched a ban
561 and expurges them from cache. As actively used objects get tested
562 against the ban list at request time and thus are likely to be associ‐
563 ated with bans near the top of the ban list, with ban_cutoff, least
564 recently accessed objects (the "long tail") are removed.
565 This parameter is a safety net to avoid bad response times due to bans
567 being tested at lookup time. Setting a cutoff trades response time for
568 cache efficiency. The recommended value is proportional to
569 rate(bans_lurker_tests_tested) / n_objects while the ban lurker is
570 working, which is the number of bans the system can sustain. The addi‐
571 tional latency due to request ban testing is in the order of ban_cutoff
572 / rate(bans_lurker_tests_tested). For example, for
573 rate(bans_lurker_tests_tested) = 2M/s and a tolerable latency of 100ms,
574 a good value for ban_cutoff may be 200K.
575 ban_dups
577 · Units: bool
578 · Default: on
580 Eliminate older identical bans when a new ban is added. This saves CPU
582 cycles by not comparing objects to identical bans. This is a waste of
583 time if you have many bans which are never identical.
584 ban_lurker_age
586 · Units: seconds
587 · Default: 60.000
589 · Minimum: 0.000
591 The ban lurker will ignore bans until they are this old. When a ban is
593 added, the active traffic will be tested against it as part of object
594 lookup. Because many applications issue bans in bursts, this parameter
595 holds the ban-lurker off until the rush is over. This should be set to
596 the approximate time which a ban-burst takes.
597 ban_lurker_batch
599 · Default: 1000
600 · Minimum: 1
602 The ban lurker sleeps ${ban_lurker_sleep} after examining this many
604 objects. Use this to pace the ban-lurker if it eats too many
605 resources.
606 ban_lurker_holdoff
608 · Units: seconds
609 · Default: 0.010
611 · Minimum: 0.000
613 · Flags: experimental
615 How long the ban lurker sleeps when giving way to lookup due to lock
617 contention.
618 ban_lurker_sleep
620 · Units: seconds
621 · Default: 0.010
623 · Minimum: 0.000
625 How long the ban lurker sleeps after examining ${ban_lurker_batch}
627 objects. Use this to pace the ban-lurker if it eats too many
628 resources. A value of zero will disable the ban lurker entirely.
629 between_bytes_timeout
631 · Units: seconds
632 · Default: 60.000
634 · Minimum: 0.000
636 We only wait for this many seconds between bytes received from the
638 backend before giving up the fetch. VCL values, per backend or per
639 backend request take precedence. This parameter does not apply to
640 pipe'ed requests.
641 cc_command
643 · Default: defined when Varnish is built
644 · Flags: must_reload
646 Command used for compiling the C source code to a dlopen(3) loadable
648 object. Any occurrence of %s in the string will be replaced with the
649 source file name, and %o will be replaced with the output file name.
650 cli_limit
652 · Units: bytes
653 · Default: 48k
655 · Minimum: 128b
657 · Maximum: 99999999b
659 Maximum size of CLI response. If the response exceeds this limit, the
661 response code will be 201 instead of 200 and the last line will indi‐
662 cate the truncation.
663 cli_timeout
665 · Units: seconds
666 · Default: 60.000
668 · Minimum: 0.000
670 Timeout for the childs replies to CLI requests from the mgt_param.
672 clock_skew
674 · Units: seconds
675 · Default: 10
677 · Minimum: 0
679 How much clockskew we are willing to accept between the backend and our
681 own clock.
682 clock_step
684 · Units: seconds
685 · Default: 1.000
687 · Minimum: 0.000
689 How much observed clock step we are willing to accept before we panic.
691 connect_timeout
693 · Units: seconds
694 · Default: 3.500
696 · Minimum: 0.000
698 Default connection timeout for backend connections. We only try to con‐
700 nect to the backend for this many seconds before giving up. VCL can
701 override this default value for each backend and backend request.
702 critbit_cooloff
704 · Units: seconds
705 · Default: 180.000
707 · Minimum: 60.000
709 · Maximum: 254.000
711 · Flags: wizard
713 How long the critbit hasher keeps deleted objheads on the cooloff list.
715 debug
717 · Default: none
718 Enable/Disable various kinds of debugging.
720 none Disable all debugging
722 Use +/- prefix to set/reset individual bits:
724 req_state
726 VSL Request state engine
727 workspace
729 VSL Workspace operations
730 waitinglist
732 VSL Waitinglist events
733 syncvsl
735 Make VSL synchronous
736 hashedge
738 Edge cases in Hash
739 vclrel Rapid VCL release
741 lurker VSL Ban lurker
743 esi_chop
745 Chop ESI fetch to bits
746 flush_head
748 Flush after http1 head
749 vtc_mode
751 Varnishtest Mode
752 witness
754 Emit WITNESS lock records
755 vsm_keep
757 Keep the VSM file on restart
758 drop_pools
760 Drop thread pools (testing)
761 slow_acceptor
763 Slow down Acceptor
764 h2_nocheck
766 Disable various H2 checks
767 vmod_so_keep
769 Keep copied VMOD libraries
770 processors
772 Fetch/Deliver processors
773 protocol
775 Protocol debugging
776 vcl_keep
778 Keep VCL C and so files
779 lck Additional lock statistics
781 default_grace
783 · Units: seconds
784 · Default: 10.000
786 · Minimum: 0.000
788 · Flags: obj_sticky
790 Default grace period. We will deliver an object this long after it has
792 expired, provided another thread is attempting to get a new copy.
793 default_keep
795 · Units: seconds
796 · Default: 0.000
798 · Minimum: 0.000
800 · Flags: obj_sticky
802 Default keep period. We will keep a useless object around this long,
804 making it available for conditional backend fetches. That means that
805 the object will be removed from the cache at the end of ttl+grace+keep.
806 default_ttl
808 · Units: seconds
809 · Default: 120.000
811 · Minimum: 0.000
813 · Flags: obj_sticky
815 The TTL assigned to objects if neither the backend nor the VCL code
817 assigns one.
818 feature
820 · Default: none
821 Enable/Disable various minor features.
823 none Disable all features.
825 Use +/- prefix to enable/disable individual feature:
827 short_panic
829 Short panic message.
830 wait_silo
832 Wait for persistent silo.
833 no_coredump
835 No coredumps.
836 esi_ignore_https
838 Treat HTTPS as HTTP in ESI:includes
839 esi_disable_xml_check
841 Don't check of body looks like XML
842 esi_ignore_other_elements
844 Ignore non-esi XML-elements
845 esi_remove_bom
847 Remove UTF-8 BOM
848 https_scheme
850 Also split https URIs
851 http2 Support HTTP/2 protocol
853 http_date_postel
855 Relax parsing of timestamps in HTTP headers
856 fetch_chunksize
858 · Units: bytes
859 · Default: 16k
861 · Minimum: 4k
863 · Flags: experimental
865 The default chunksize used by fetcher. This should be bigger than the
867 majority of objects with short TTLs. Internal limits in the stor‐
868 age_file module makes increases above 128kb a dubious idea.
869 fetch_maxchunksize
871 · Units: bytes
872 · Default: 0.25G
874 · Minimum: 64k
876 · Flags: experimental
878 The maximum chunksize we attempt to allocate from storage. Making this
880 too large may cause delays and storage fragmentation.
881 first_byte_timeout
883 · Units: seconds
884 · Default: 60.000
886 · Minimum: 0.000
888 Default timeout for receiving first byte from backend. We only wait for
890 this many seconds for the first byte before giving up. VCL can over‐
891 ride this default value for each backend and backend request. This
892 parameter does not apply to pipe'ed requests.
893 gzip_buffer
895 · Units: bytes
896 · Default: 32k
898 · Minimum: 2k
900 · Flags: experimental
902 Size of malloc buffer used for gzip processing. These buffers are used
904 for in-transit data, for instance gunzip'ed data being sent to a
905 client.Making this space to small results in more overhead, writes to
906 sockets etc, making it too big is probably just a waste of memory.
907 gzip_level
909 · Default: 6
910 · Minimum: 0
912 · Maximum: 9
914 Gzip compression level: 0=debug, 1=fast, 9=best
916 gzip_memlevel
918 · Default: 8
919 · Minimum: 1
921 · Maximum: 9
923 Gzip memory level 1=slow/least, 9=fast/most compression. Memory impact
925 is 1=1k, 2=2k, ... 9=256k.
926 h2_header_table_size
928 · Units: bytes
929 · Default: 4k
931 · Minimum: 0b
933 HTTP2 header table size. This is the size that will be used for the
935 HPACK dynamic decoding table.
936 h2_initial_window_size
938 · Units: bytes
939 · Default: 65535b
941 · Minimum: 0b
943 · Maximum: 2147483647b
945 HTTP2 initial flow control window size.
947 h2_max_concurrent_streams
949 · Units: streams
950 · Default: 100
952 · Minimum: 0
954 HTTP2 Maximum number of concurrent streams. This is the number of
956 requests that can be active at the same time for a single HTTP2 connec‐
957 tion.
958 h2_max_frame_size
960 · Units: bytes
961 · Default: 16k
963 · Minimum: 16k
965 · Maximum: 16777215b
967 HTTP2 maximum per frame payload size we are willing to accept.
969 h2_max_header_list_size
971 · Units: bytes
972 · Default: 2147483647b
974 · Minimum: 0b
976 HTTP2 maximum size of an uncompressed header list.
978 h2_rx_window_increment
980 · Units: bytes
981 · Default: 1M
983 · Minimum: 1M
985 · Maximum: 1G
987 · Flags: wizard
989 HTTP2 Receive Window Increments. How big credits we send in WIN‐
991 DOW_UPDATE frames Only affects incoming request bodies (ie: POST, PUT
992 etc.)
993 h2_rx_window_low_water
995 · Units: bytes
996 · Default: 10M
998 · Minimum: 65535b
1000 · Maximum: 1G
1002 · Flags: wizard
1004 HTTP2 Receive Window low water mark. We try to keep the window at
1006 least this big Only affects incoming request bodies (ie: POST, PUT
1007 etc.)
1008 http1_iovs
1010 · Units: struct iovec (=16 bytes)
1011 · Default: 64
1013 · Minimum: 5
1015 · Maximum: 1024
1017 · Flags: wizard
1019 Number of io vectors to allocate for HTTP1 protocol transmission. A
1021 HTTP1 header needs 7 + 2 per HTTP header field. Allocated from
1022 workspace_thread.
1023 http_gzip_support
1025 · Units: bool
1026 · Default: on
1028 Enable gzip support. When enabled Varnish request compressed objects
1030 from the backend and store them compressed. If a client does not sup‐
1031 port gzip encoding Varnish will uncompress compressed objects on
1032 demand. Varnish will also rewrite the Accept-Encoding header of clients
1033 indicating support for gzip to:
1034 Accept-Encoding: gzip
1035 Clients that do not support gzip will have their Accept-Encoding header
1037 removed. For more information on how gzip is implemented please see the
1038 chapter on gzip in the Varnish reference.
1039 When gzip support is disabled the variables beresp.do_gzip and
1041 beresp.do_gunzip have no effect in VCL.
1042 http_max_hdr
1044 · Units: header lines
1045 · Default: 64
1047 · Minimum: 32
1049 · Maximum: 65535
1051 Maximum number of HTTP header lines we allow in
1053 {req|resp|bereq|beresp}.http (obj.http is autosized to the exact number
1054 of headers). Cheap, ~20 bytes, in terms of workspace memory. Note
1055 that the first line occupies five header lines.
1056 http_range_support
1058 · Units: bool
1059 · Default: on
1061 Enable support for HTTP Range headers.
1063 http_req_hdr_len
1065 · Units: bytes
1066 · Default: 8k
1068 · Minimum: 40b
1070 Maximum length of any HTTP client request header we will allow. The
1072 limit is inclusive its continuation lines.
1073 http_req_size
1075 · Units: bytes
1076 · Default: 32k
1078 · Minimum: 0.25k
1080 Maximum number of bytes of HTTP client request we will deal with. This
1082 is a limit on all bytes up to the double blank line which ends the HTTP
1083 request. The memory for the request is allocated from the client
1084 workspace (param: workspace_client) and this parameter limits how much
1085 of that the request is allowed to take up.
1086 http_resp_hdr_len
1088 · Units: bytes
1089 · Default: 8k
1091 · Minimum: 40b
1093 Maximum length of any HTTP backend response header we will allow. The
1095 limit is inclusive its continuation lines.
1096 http_resp_size
1098 · Units: bytes
1099 · Default: 32k
1101 · Minimum: 0.25k
1103 Maximum number of bytes of HTTP backend response we will deal with.
1105 This is a limit on all bytes up to the double blank line which ends the
1106 HTTP response. The memory for the response is allocated from the back‐
1107 end workspace (param: workspace_backend) and this parameter limits how
1108 much of that the response is allowed to take up.
1109 idle_send_timeout
1111 · Units: seconds
1112 · Default: 60.000
1114 · Minimum: 0.000
1116 · Flags: delayed
1118 Send timeout for individual pieces of data on client connections. May
1120 get extended if 'send_timeout' applies.
1121 When this timeout is hit, the session is closed.
1123 See the man page for setsockopt(2) or socket(7) under SO_SNDTIMEO for
1125 more information.
1126 listen_depth
1128 · Units: connections
1129 · Default: 1024
1131 · Minimum: 0
1133 · Flags: must_restart
1135 Listen queue depth.
1137 lru_interval
1139 · Units: seconds
1140 · Default: 2.000
1142 · Minimum: 0.000
1144 · Flags: experimental
1146 Grace period before object moves on LRU list. Objects are only moved
1148 to the front of the LRU list if they have not been moved there already
1149 inside this timeout period. This reduces the amount of lock operations
1150 necessary for LRU list access.
1151 max_esi_depth
1153 · Units: levels
1154 · Default: 5
1156 · Minimum: 0
1158 Maximum depth of esi:include processing.
1160 max_restarts
1162 · Units: restarts
1163 · Default: 4
1165 · Minimum: 0
1167 Upper limit on how many times a request can restart.
1169 max_retries
1171 · Units: retries
1172 · Default: 4
1174 · Minimum: 0
1176 Upper limit on how many times a backend fetch can retry.
1178 max_vcl
1180 · Default: 100
1181 · Minimum: 0
1183 Threshold of loaded VCL programs. (VCL labels are not counted.)
1185 Parameter max_vcl_handling determines behaviour.
1186 max_vcl_handling
1188 · Default: 1
1189 · Minimum: 0
1191 · Maximum: 2
1193 Behaviour when attempting to exceed max_vcl loaded VCL.
1195 · 0 - Ignore max_vcl parameter.
1197 · 1 - Issue warning.
1199 · 2 - Refuse loading VCLs.
1201 nuke_limit
1203 · Units: allocations
1204 · Default: 50
1206 · Minimum: 0
1208 · Flags: experimental
1210 Maximum number of objects we attempt to nuke in order to make space for
1212 a object body.
1213 pcre_match_limit
1215 · Default: 10000
1216 · Minimum: 1
1218 The limit for the number of calls to the internal match() function in
1220 pcre_exec().
1221 (See: PCRE_EXTRA_MATCH_LIMIT in pcre docs.)
1223 This parameter limits how much CPU time regular expression matching can
1225 soak up.
1226 pcre_match_limit_recursion
1228 · Default: 20
1229 · Minimum: 1
1231 The recursion depth-limit for the internal match() function in a
1233 pcre_exec().
1234 (See: PCRE_EXTRA_MATCH_LIMIT_RECURSION in pcre docs.)
1236 This puts an upper limit on the amount of stack used by PCRE for cer‐
1238 tain classes of regular expressions.
1239 We have set the default value low in order to prevent crashes, at the
1241 cost of possible regexp matching failures.
1242 Matching failures will show up in the log as VCL_Error messages with
1244 regexp errors -27 or -21.
1245 Testcase r01576 can be useful when tuning this parameter.
1247 ping_interval
1249 · Units: seconds
1250 · Default: 3
1252 · Minimum: 0
1254 · Flags: must_restart
1256 Interval between pings from parent to child. Zero will disable pinging
1258 entirely, which makes it possible to attach a debugger to the child.
1259 pipe_sess_max
1261 · Units: connections
1262 · Default: 0
1264 · Minimum: 0
1266 Maximum number of sessions dedicated to pipe transactions.
1268 pipe_timeout
1270 · Units: seconds
1271 · Default: 60.000
1273 · Minimum: 0.000
1275 Idle timeout for PIPE sessions. If nothing have been received in either
1277 direction for this many seconds, the session is closed.
1278 pool_req
1280 · Default: 10,100,10
1281 Parameters for per worker pool request memory pool.
1283 The three numbers are:
1285 min_pool
1287 minimum size of free pool.
1288 max_pool
1290 maximum size of free pool.
1291 max_age
1293 max age of free element.
1294 pool_sess
1296 · Default: 10,100,10
1297 Parameters for per worker pool session memory pool.
1299 The three numbers are:
1301 min_pool
1303 minimum size of free pool.
1304 max_pool
1306 maximum size of free pool.
1307 max_age
1309 max age of free element.
1310 pool_vbo
1312 · Default: 10,100,10
1313 Parameters for backend object fetch memory pool.
1315 The three numbers are:
1317 min_pool
1319 minimum size of free pool.
1320 max_pool
1322 maximum size of free pool.
1323 max_age
1325 max age of free element.
1326 prefer_ipv6
1328 · Units: bool
1329 · Default: off
1331 Prefer IPv6 address when connecting to backends which have both IPv4
1333 and IPv6 addresses.
1334 rush_exponent
1336 · Units: requests per request
1337 · Default: 3
1339 · Minimum: 2
1341 · Flags: experimental
1343 How many parked request we start for each completed request on the
1345 object. NB: Even with the implict delay of delivery, this parameter
1346 controls an exponential increase in number of worker threads.
1347 send_timeout
1349 · Units: seconds
1350 · Default: 600.000
1352 · Minimum: 0.000
1354 · Flags: delayed
1356 Total timeout for ordinary HTTP1 responses. Does not apply to some
1358 internally generated errors and pipe mode.
1359 When 'idle_send_timeout' is hit while sending an HTTP1 response, the
1361 timeout is extended unless the total time already taken for sending the
1362 response in its entirety exceeds this many seconds.
1363 When this timeout is hit, the session is closed
1365 shortlived
1367 · Units: seconds
1368 · Default: 10.000
1370 · Minimum: 0.000
1372 Objects created with (ttl+grace+keep) shorter than this are always put
1374 in transient storage.
1375 sigsegv_handler
1377 · Units: bool
1378 · Default: on
1380 · Flags: must_restart
1382 Install a signal handler which tries to dump debug information on seg‐
1384 mentation faults, bus errors and abort signals.
1385 syslog_cli_traffic
1387 · Units: bool
1388 · Default: on
1390 Log all CLI traffic to syslog(LOG_INFO).
1392 tcp_fastopen
1394 · Units: bool
1395 · Default: off
1397 · Flags: must_restart
1399 Enable TCP Fast Open extension.
1401 tcp_keepalive_intvl
1403 · Units: seconds
1404 · Default: platform dependent
1406 · Minimum: 1.000
1408 · Maximum: 100.000
1410 · Flags: experimental
1412 The number of seconds between TCP keep-alive probes. Ignored for Unix
1414 domain sockets.
1415 tcp_keepalive_probes
1417 · Units: probes
1418 · Default: platform dependent
1420 · Minimum: 1
1422 · Maximum: 100
1424 · Flags: experimental
1426 The maximum number of TCP keep-alive probes to send before giving up
1428 and killing the connection if no response is obtained from the other
1429 end. Ignored for Unix domain sockets.
1430 tcp_keepalive_time
1432 · Units: seconds
1433 · Default: platform dependent
1435 · Minimum: 1.000
1437 · Maximum: 7200.000
1439 · Flags: experimental
1441 The number of seconds a connection needs to be idle before TCP begins
1443 sending out keep-alive probes. Ignored for Unix domain sockets.
1444 thread_pool_add_delay
1446 · Units: seconds
1447 · Default: 0.000
1449 · Minimum: 0.000
1451 · Flags: experimental
1453 Wait at least this long after creating a thread.
1455 Some (buggy) systems may need a short (sub-second) delay between creat‐
1457 ing threads. Set this to a few milliseconds if you see the
1458 'threads_failed' counter grow too much.
1459 Setting this too high results in insufficient worker threads.
1461 thread_pool_destroy_delay
1463 · Units: seconds
1464 · Default: 1.000
1466 · Minimum: 0.010
1468 · Flags: delayed, experimental
1470 Wait this long after destroying a thread.
1472 This controls the decay of thread pools when idle(-ish).
1474 thread_pool_fail_delay
1476 · Units: seconds
1477 · Default: 0.200
1479 · Minimum: 0.010
1481 · Flags: experimental
1483 Wait at least this long after a failed thread creation before trying to
1485 create another thread.
1486 Failure to create a worker thread is often a sign that the end is
1488 near, because the process is running out of some resource. This delay
1489 tries to not rush the end on needlessly.
1490 If thread creation failures are a problem, check that thread_pool_max
1492 is not too high.
1493 It may also help to increase thread_pool_timeout and thread_pool_min,
1495 to reduce the rate at which treads are destroyed and later recreated.
1496 thread_pool_max
1498 · Units: threads
1499 · Default: 5000
1501 · Minimum: thread_pool_min
1503 · Flags: delayed
1505 The maximum number of worker threads in each pool.
1507 Do not set this higher than you have to, since excess worker threads
1509 soak up RAM and CPU and generally just get in the way of getting work
1510 done.
1511 thread_pool_min
1513 · Units: threads
1514 · Default: 100
1516 · Minimum: 5
1518 · Maximum: thread_pool_max
1520 · Flags: delayed
1522 The minimum number of worker threads in each pool.
1524 Increasing this may help ramp up faster from low load situations or
1526 when threads have expired.
1527 Technical minimum is 5 threads, but this parameter is strongly recom‐
1529 mended to be at least 10
1530 thread_pool_reserve
1532 · Units: threads
1533 · Default: 0
1535 · Maximum: 95% of thread_pool_min
1537 · Flags: delayed
1539 The number of worker threads reserved for vital tasks in each pool.
1541 Tasks may require other tasks to complete (for example, client requests
1543 may require backend requests, http2 sessions require streams, which
1544 require requests). This reserve is to ensure that lower priority tasks
1545 do not prevent higher priority tasks from running even under high load.
1546 The effective value is at least 5 (the number of internal priority
1548 classes), irrespective of this parameter. Default is 0 to auto-tune
1549 (5% of thread_pool_min). Minimum is 1 otherwise, maximum is 95% of
1550 thread_pool_min.
1551 thread_pool_stack
1553 · Units: bytes
1554 · Default: sysconf(_SC_THREAD_STACK_MIN)
1556 · Minimum: 16k
1558 · Flags: delayed
1560 Worker thread stack size. This will likely be rounded up to a multiple
1562 of 4k (or whatever the page_size might be) by the kernel.
1563 The required stack size is primarily driven by the depth of the
1565 call-tree. The most common relevant determining factors in varnish core
1566 code are GZIP (un)compression, ESI processing and regular expression
1567 matches. VMODs may also require significant amounts of additional
1568 stack. The nesting depth of VCL subs is another factor, although typi‐
1569 cally not predominant.
1570 The stack size is per thread, so the maximum total memory required for
1572 worker thread stacks is in the order of size = thread_pools x
1573 thread_pool_max x thread_pool_stack.
1574 Thus, in particular for setups with many threads, keeping the stack
1576 size at a minimum helps reduce the amount of memory required by Var‐
1577 nish.
1578 On the other hand, thread_pool_stack must be large enough under all
1580 circumstances, otherwise varnish will crash due to a stack overflow.
1581 Usually, a stack overflow manifests itself as a segmentation fault (aka
1582 segfault / SIGSEGV) with the faulting address being near the stack
1583 pointer (sp).
1584 Unless stack usage can be reduced, thread_pool_stack must be increased
1586 when a stack overflow occurs. Setting it in 150%-200% increments is
1587 recommended until stack overflows cease to occur.
1588 thread_pool_timeout
1590 · Units: seconds
1591 · Default: 300.000
1593 · Minimum: 10.000
1595 · Flags: delayed, experimental
1597 Thread idle threshold.
1599 Threads in excess of thread_pool_min, which have been idle for at least
1601 this long, will be destroyed.
1602 thread_pool_watchdog
1604 · Units: seconds
1605 · Default: 60.000
1607 · Minimum: 0.100
1609 · Flags: experimental
1611 Thread queue stuck watchdog.
1613 If no queued work have been released for this long, the worker process
1615 panics itself.
1616 thread_pools
1618 · Units: pools
1619 · Default: 2
1621 · Minimum: 1
1623 · Maximum: defined when Varnish is built
1625 · Flags: delayed, experimental
1627 Number of worker thread pools.
1629 Increasing the number of worker pools decreases lock contention. Each
1631 worker pool also has a thread accepting new connections, so for very
1632 high rates of incoming new connections on systems with many cores,
1633 increasing the worker pools may be required.
1634 Too many pools waste CPU and RAM resources, and more than one pool for
1636 each CPU is most likely detrimental to performance.
1637 Can be increased on the fly, but decreases require a restart to take
1639 effect.
1640 thread_queue_limit
1642 · Default: 20
1643 · Minimum: 0
1645 · Flags: experimental
1647 Permitted request queue length per thread-pool.
1649 This sets the number of requests we will queue, waiting for an avail‐
1651 able thread. Above this limit sessions will be dropped instead of
1652 queued.
1653 thread_stats_rate
1655 · Units: requests
1656 · Default: 10
1658 · Minimum: 0
1660 · Flags: experimental
1662 Worker threads accumulate statistics, and dump these into the global
1664 stats counters if the lock is free when they finish a job
1665 (request/fetch etc.) This parameters defines the maximum number of
1666 jobs a worker thread may handle, before it is forced to dump its accu‐
1667 mulated stats into the global counters.
1668 timeout_idle
1670 · Units: seconds
1671 · Default: 5.000
1673 · Minimum: 0.000
1675 Idle timeout for client connections.
1677 A connection is considered idle until we have received the full request
1679 headers.
1680 This parameter is particularly relevant for HTTP1 keepalive connec‐
1682 tions which are closed unless the next request is received before this
1683 timeout is reached.
1684 timeout_linger
1686 · Units: seconds
1687 · Default: 0.050
1689 · Minimum: 0.000
1691 · Flags: experimental
1693 How long the worker thread lingers on an idle session before handing it
1695 over to the waiter. When sessions are reused, as much as half of all
1696 reuses happen within the first 100 msec of the previous request com‐
1697 pleting. Setting this too high results in worker threads not doing
1698 anything for their keep, setting it too low just means that more ses‐
1699 sions take a detour around the waiter.
1700 vcc_allow_inline_c
1702 · Units: bool
1703 · Default: off
1705 Allow inline C code in VCL.
1707 vcc_err_unref
1709 · Units: bool
1710 · Default: on
1712 Unreferenced VCL objects result in error.
1714 vcc_unsafe_path
1716 · Units: bool
1717 · Default: on
1719 Allow '/' in vmod & include paths. Allow 'import ... from ...'.
1721 vcl_cooldown
1723 · Units: seconds
1724 · Default: 600.000
1726 · Minimum: 1.000
1728 How long a VCL is kept warm after being replaced as the active VCL
1730 (granularity approximately 30 seconds).
1731 vcl_path
1733 · Default: /usr/local/etc/varnish:/usr/local/share/varnish/vcl
1734 Directory (or colon separated list of directories) from which relative
1736 VCL filenames (vcl.load and include) are to be found. By default Var‐
1737 nish searches VCL files in both the system configuration and shared
1738 data directories to allow packages to drop their VCL files in a stan‐
1739 dard location where relative includes would work.
1740 vmod_path
1742 · Default: /usr/local/lib/varnish/vmods
1743 Directory (or colon separated list of directories) where VMODs are to
1745 be found.
1746 vsl_buffer
1748 · Units: bytes
1749 · Default: 4k
1751 · Minimum: vsl_reclen + 12 bytes
1753 Bytes of (req-/backend-)workspace dedicated to buffering VSL records.
1755 When this parameter is adjusted, most likely workspace_client and
1756 workspace_backend will have to be adjusted by the same amount.
1757 Setting this too high costs memory, setting it too low will cause more
1759 VSL flushes and likely increase lock-contention on the VSL mutex.
1760 vsl_mask
1762 · Default: -Debug,-ObjProtocol,-ObjStatus,-ObjReason,-Obj‐
1763 Header,-VCL_trace,-Work‐
1764 Thread,-Hash,-VfpAcct,-H2RxHdr,-H2RxBody,-H2TxHdr,-H2TxBody
1765 Mask individual VSL messages from being logged.
1767 default
1769 Set default value
1770 Use +/- prefix in front of VSL tag name to unmask/mask individual VSL
1772 messages.
1773 vsl_reclen
1775 · Units: bytes
1776 · Default: 255b
1778 · Minimum: 16b
1780 · Maximum: vsl_buffer - 12 bytes
1782 Maximum number of bytes in SHM log record.
1784 vsl_space
1786 · Units: bytes
1787 · Default: 80M
1789 · Minimum: 1M
1791 · Maximum: 4G
1793 · Flags: must_restart
1795 The amount of space to allocate for the VSL fifo buffer in the VSM mem‐
1797 ory segment. If you make this too small, varnish{ncsa|log} etc will
1798 not be able to keep up. Making it too large just costs memory
1799 resources.
1800 vsm_free_cooldown
1802 · Units: seconds
1803 · Default: 60.000
1805 · Minimum: 10.000
1807 · Maximum: 600.000
1809 How long VSM memory is kept warm after a deallocation (granularity
1811 approximately 2 seconds).
1812 vsm_space
1814 · Units: bytes
1815 · Default: 1M
1817 · Minimum: 1M
1819 · Maximum: 1G
1821 DEPRECATED: This parameter is ignored. There is no global limit on
1823 amount of shared memory now.
1824 workspace_backend
1826 · Units: bytes
1827 · Default: 64k
1829 · Minimum: 1k
1831 · Flags: delayed
1833 Bytes of HTTP protocol workspace for backend HTTP req/resp. If larger
1835 than 4k, use a multiple of 4k for VM efficiency.
1836 workspace_client
1838 · Units: bytes
1839 · Default: 64k
1841 · Minimum: 9k
1843 · Flags: delayed
1845 Bytes of HTTP protocol workspace for clients HTTP req/resp. Use a mul‐
1847 tiple of 4k for VM efficiency. For HTTP/2 compliance this must be at
1848 least 20k, in order to receive fullsize (=16k) frames from the client.
1849 That usually happens only in POST/PUT bodies. For other traffic-pat‐
1850 terns smaller values work just fine.
1851 workspace_session
1853 · Units: bytes
1854 · Default: 0.75k
1856 · Minimum: 0.25k
1858 · Flags: delayed
1860 Allocation size for session structure and workspace. The workspace
1862 is primarily used for TCP connection addresses. If larger than 4k, use
1863 a multiple of 4k for VM efficiency.
1864 workspace_thread
1866 · Units: bytes
1867 · Default: 2k
1869 · Minimum: 0.25k
1871 · Maximum: 8k
1873 · Flags: delayed
1875 Bytes of auxiliary workspace per thread. This workspace is used for
1877 certain temporary data structures during the operation of a worker
1878 thread. One use is for the IO-vectors used during delivery. Setting
1879 this parameter too low may increase the number of writev() syscalls,
1880 setting it too high just wastes space. ~0.1k + UIO_MAXIOV *
1881 sizeof(struct iovec) (typically = ~16k for 64bit) is considered the
1882 maximum sensible value under any known circumstances (excluding exotic
1883 vmod use).
1884
1886 Varnish and bundled tools will, in most cases, exit with one of the
1887 following codes
1888 · 0 OK
1890 · 1 Some error which could be system-dependent and/or transient
1892 · 2 Serious configuration / parameter error - retrying with the same
1894 configuration / parameters is most likely useless
1895 The varnishd master process may also OR its exit code
1897 · with 0x20 when the varnishd child process died,
1899 · with 0x40 when the varnishd child process was terminated by a signal
1901 and
1902 · with 0x80 when a core was dumped.
1904
1906 · varnishlog(1)
1907 · varnishhist(1)
1909 · varnishncsa(1)
1911 · varnishstat(1)
1913 · varnishtop(1)
1915 · varnish-cli(7)
1917 · vcl(7)
1919
1921 The varnishd daemon was developed by Poul-Henning Kamp in cooperation
1922 with Verdens Gang AS and Varnish Software.
1923 This manual page was written by Dag-Erling Smørgrav with updates by
1925 Stig Sandbeck Mathisen <ssm@debian.org>, Nils Goroll and others.
1926
1928 This document is licensed under the same licence as Varnish itself. See
1929 LICENCE for details.
1930 · Copyright (c) 2007-2015 Varnish Software AS
1932 VARNISHD(1)