php-src/sapi/fpm/php-fpm.conf.in

;
; All relative paths in this config are relative to php's install prefix
;
;
; Include one or more files.
; If glob(3) exists, it's used to include a bunch of files from a glob(3) pattern
; This directive can be used everywhere in the file.
;
;include=@EXPANDED_SYSCONFDIR@/fpm.d/*.conf
;
;

[global]
; Pid file
; default: none
;
;pid = @EXPANDED_LOCALSTATEDIR@/run/php-fpm.pid

; Error log file
; default: @EXPANDED_LOCALSTATEDIR@/log/php-fpm.log
;
;error_log = @EXPANDED_LOCALSTATEDIR@/log/php-fpm.log

; Log level
; alert, error, warning, notice, debug
; default: notice
;
;log_level = notice

; When this amount of php processes exited with SIGSEGV or SIGBUS,
; php-fpm will restart
; 0 means 'Off'
; default: 0
;
;emergency_restart_threshold = 0

; ... in a less than this interval of time, a graceful restart will be initiated.
; Useful to work around accidental curruptions in accelerator's shared memory.
; available units are s(econd)(default), m(inute), h(hour), or d(day)
; default : 0
;
;emergency_restart_interval = 0

; Time limit on waiting child's reaction on signals from master
; available units are s(econd)(default), m(inute), h(hour), or d(day)
; default : 0
;
;process_control_timeout = 0

; send fpm to backgound
; set to 'no' to keep FPM in foreground for debugging
; default : yes
;
;daemonize = yes

; Start a new pool named 'www'
; The name is used in logs and stats
; There is no limitation on the number of pool FPM can handle. Your system will tell you anyway :)
[www]

; Address to accept fastcgi requests on.
; Valid syntaxes are:
; - 'ip.add.re.ss:port' to listen on a TCP scoket to the specific address on the specific port
; - 'port' to listen on a TCP socket to all addreses on the specific port
; - '/path/to/unix/socket' to listen on a unix socket
; it's mandatory
;
listen = 127.0.0.1:9000

; Set listen(2) backlog
; -1 means unlimited
; default : -1
;
;listen.backlog = -1
 
; List of ipv4 addresses of FastCGI clients which are allowed to connect.
; Equivalent to FCGI_WEB_SERVER_ADDRS environment in original php.fcgi (5.2.2+)
; Makes sense only with a tcp listening socket.
; Each addresses must be separated by a comma
; If it's left blank, it accept connection from any ip address
; default: any
;
;listen.allowed_clients = 127.0.0.1

; Set permissions for unix socket, if one used.
; In Linux read/write permissions must be set in order to allow connections from web server.
; Many BSD-derrived systems allow connections regardless of permissions. 
; default: user and group are set as the running user. Mode is set to 0666
;
;listen.owner = @php_fpm_user@
;listen.group = @php_fpm_group@
;listen.mode = 0666

; Unix user/group of processes
; The user is mandatory. If the group is not set, the default user's group
; will be used
user = @php_fpm_user@
group = @php_fpm_group@

; Choose the process manager which control how processes are managed
; Two choices:
; - static  : a fixed number (pm.max_children) of child processes
; - dynamic : The number of child processes are set up dynamically depending on the following directives
;             - pm.max_children      : the maximum number of children that can be alive at the same time
;             - pm.start_servers     : the number of children created on startup
;             - pm.min_spare_servers : the minimum number of children in 'idle' state (waiting to process).
;                                      If the number of 'idle' processes is less than this number,
;                                      some children will be created.
;             - pm.max_spare_servers : the maximum number of children in 'idle' state (waiting to process).
;                                      If the number of 'idle' processes is greater than this number,
;                                      some children will be killed;
; It's mandatory
pm = dynamic

; Sets the limit on the number of simultaneous requests (children processes will be forked) that will be served.
; Equivalent to Apache MaxClients directive (with mpm_prefork).
; Equivalent to PHP_FCGI_CHILDREN environment in original php.fcgi
; Used with any pm.style.
; It's mandatory
;
pm.max_children = 50

; Sets the number of server processes created on startup.
; Used only with 'dynamic' pm.style
; default : min_spare + (max_spare - min_spare) / 2
;
;pm.start_servers = 20

; Sets the desired minimum number of idle server processes.
; Used only with 'dynamic' pm.style
; It's mandatory when pm is set to dynamic
;
;pm.min_spare_servers = 5

; Sets the desired maximum number of idle server processes.
; Used only with 'dynamic' pm.style
; It's mandatory when pm is set to dynamic
;
;pm.max_spare_servers = 35
 
; How much requests each process should execute before respawn.
; Useful to work around memory leaks in 3rd party libraries.
; For endless request processing please specify 0
; Equivalent to PHP_FCGI_MAX_REQUESTS
; default : 0
;
;pm.max_requests = 500

; Sets the status URI to call to obtain php-fpm status page.
; If not set, no URI will be recognized as a status page.
; By default, it returns text/plain looking like:
; accepted conn:   12073
; pool:             www
; process manager:  static
; idle processes:   35
; active processes: 65
; total processes:  100
; "accepted conn" : the number of request accepted by the pool
; "pool" : the name of the pool
; "process manager": static or dynamic
; "idle processes": the number of idle processes
; "active processes": the number of active processes
; "total processes": idle + active
; The last three number are uptaded every second.
; The "accepted conn" is updated in real time
; *** Output ***
; By default it returns text/plain
; But passing as a query string html or json, it will returns
; the corresponding output syntax:
; http://www.foo.bar/status
; http://www.foo.bar/status?json
; http://www.foo.bar/status?html
; *** WARNING ***
; It has to start with a /. It could be named has you want.
; It's maybe not a good idea to use .php extension to be certain
; not to conflict with a real PHP file
;
; default: not set 
;
;pm.status_path = /status
 
; Set the ping URI to call the monitoring page of php-fpm
; If not set, no URI will be recognized as a ping page.
; This could be used to test from outside that php-fpm
; is alive and responding:
; - have a graph of php-fpm availability (rrd or such)
; - remove a server from a pool if it's not responding (load balancing systems)
; - trigger alerts for the operating team (24/7)
; *** WARNING ***
; It has to start with a /. It could be named has you want.
; It's maybe not a good idea to use .php extension to be certain
; not to conflict with a real PHP file
;
; default: not set
;
;ping.path = /ping

; Set the response to custom the response of a ping request
; If 'pong' is not set, the default is "pong".
; The response is text/plain with a 200 response code
;
; default: pong
;
;ping.response = pong
 
; The timeout for serving a single request after which the worker process will be killed
; Should be used when 'max_execution_time' ini option does not stop script execution for some reason
; '0' means 'off'
; available units are s(econd)(default), m(inute), h(hour), or d(day)
; default: 0
;
;request_terminate_timeout = 0
 
; The timeout for serving of single request after which a php backtrace will be dumped to slow.log file
; '0s' means 'off'
; available units are s(econd)(default), m(inute), h(hour), or d(day)
; default: 0
;
;request_slowlog_timeout = 0
 
; The log file for slow requests
; default: @EXPANDED_LOCALSTATEDIR@/log/php-fpm.log.slow
;
;slowlog = @EXPANDED_LOCALSTATEDIR@/log/php-fpm.log.slow
 
; Set open file descriptor rlimit
; default: system defined value
;
;rlimit_files = 1024
 
; Set max core size rlimit
; It could be
; - unlimited
; - an integer greater or equal to 0
; default: system defined value
;
;rlimit_core = 0
 
; Chroot to this directory at the start, absolute path
; *** WARNING ***
; chrooting is a great security features and should be used whenever it's possible.
; However, all php path will be related to the chroot (error_log, sessions.save_path, ...)
; When not set, chroot is not used
; default: not set
;
;chroot = 
 
; Chdir to this directory at the start, absolute path
; default: current directory or / when chroot
;
;chdir = /var/www
 
; Redirect workers' stdout and stderr into main error log.
; If not set, they will be redirected to /dev/null, according to FastCGI specs
; default: no
;
;catch_workers_output = yes
 
; Pass environment variables like LD_LIBRARY_PATH
; All $VARIABLEs are taken from current environment
; default: clean env
;
;env[HOSTNAME] = $HOSTNAME
;env[PATH] = /usr/local/bin:/usr/bin:/bin
;env[TMP] = /tmp
;env[TMPDIR] = /tmp
;env[TEMP] = /tmp

; Additional php.ini defines, specific to this pool of workers.
; These settings overwrite the values previously defined in the php.ini.
; The directives are the same as the php sapi:
; - php_value/php_flag: you can set classic ini defines which can be overwriten from PHP call 'ini_set'. 
; - php_admin_value/php_admin_flag: those directives won't be overwriten by PHP call 'ini_set'
; For php_*flag, valid values are on, off, 1, 0, true, false, yes or no
;
; Defining 'extension' will load the corresponding shared extension from extension_dir.
; Defining 'disable_functions' or 'disable_classes' won't overwrite previously defined
; php.ini value, but the new value will be append.
;
; default: nothing is defined but the ones in php.ini and at startup with the -d arguement
;
;php_admin_value[sendmail_path] = /usr/sbin/sendmail -t -i -fwww@my.domain.com
;php_flag[display_errors] = off
;php_admin_value[error_log] = /var/log/fpm-php.www.log
;php_admin_flag[log_errors] = on
;php_admin_value[memory_limit] = 32M