granicus.if.org Git - apache/blob - server/mpm_common.c

   1 /* Licensed to the Apache Software Foundation (ASF) under one or more
   2  * contributor license agreements.  See the NOTICE file distributed with
   3  * this work for additional information regarding copyright ownership.
   4  * The ASF licenses this file to You under the Apache License, Version 2.0
   5  * (the "License"); you may not use this file except in compliance with
   6  * the License.  You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /* The purpose of this file is to store the code that MOST mpm's will need
  18  * this does not mean a function only goes into this file if every MPM needs
  19  * it.  It means that if a function is needed by more than one MPM, and
  20  * future maintenance would be served by making the code common, then the
  21  * function belongs here.
  22  *
  23  * This is going in src/main because it is not platform specific, it is
  24  * specific to multi-process servers, but NOT to Unix.  Which is why it
  25  * does not belong in src/os/unix
  26  */
  27
  28 #include "apr.h"
  29 #include "apr_thread_proc.h"
  30 #include "apr_signal.h"
  31 #include "apr_strings.h"
  32 #define APR_WANT_STRFUNC
  33 #include "apr_want.h"
  34 #include "apr_getopt.h"
  35 #include "apr_optional.h"
  36 #include "apr_allocator.h"
  37
  38 #include "httpd.h"
  39 #include "http_config.h"
  40 #include "http_core.h"
  41 #include "http_log.h"
  42 #include "http_main.h"
  43 #include "mpm_common.h"
  44 #include "mod_core.h"
  45 #include "ap_mpm.h"
  46 #include "ap_listen.h"
  47 #include "util_mutex.h"
  48
  49 #include "scoreboard.h"
  50
  51 #ifdef HAVE_PWD_H
  52 #include <pwd.h>
  53 #endif
  54 #ifdef HAVE_GRP_H
  55 #include <grp.h>
  56 #endif
  57 #if APR_HAVE_UNISTD_H
  58 #include <unistd.h>
  59 #endif
  60
  61 /* we know core's module_index is 0 */
  62 #undef APLOG_MODULE_INDEX
  63 #define APLOG_MODULE_INDEX AP_CORE_MODULE_INDEX
  64
  65 #if AP_ENABLE_EXCEPTION_HOOK
  66 APR_HOOK_STRUCT(
  67     APR_HOOK_LINK(fatal_exception)
  68     APR_HOOK_LINK(monitor)
  69     APR_HOOK_LINK(drop_privileges)
  70     APR_HOOK_LINK(mpm)
  71     APR_HOOK_LINK(mpm_query)
  72     APR_HOOK_LINK(mpm_register_timed_callback)
  73     APR_HOOK_LINK(mpm_get_name)
  74     APR_HOOK_LINK(end_generation)
  75     APR_HOOK_LINK(child_status)
  76 )
  77 AP_IMPLEMENT_HOOK_RUN_ALL(int, fatal_exception,
  78                           (ap_exception_info_t *ei), (ei), OK, DECLINED)
  79 #else
  80 APR_HOOK_STRUCT(
  81     APR_HOOK_LINK(monitor)
  82     APR_HOOK_LINK(drop_privileges)
  83     APR_HOOK_LINK(mpm)
  84     APR_HOOK_LINK(mpm_query)
  85     APR_HOOK_LINK(mpm_register_timed_callback)
  86     APR_HOOK_LINK(mpm_get_name)
  87     APR_HOOK_LINK(end_generation)
  88     APR_HOOK_LINK(child_status)
  89 )
  90 #endif
  91 AP_IMPLEMENT_HOOK_RUN_ALL(int, monitor,
  92                           (apr_pool_t *p, server_rec *s), (p, s), OK, DECLINED)
  93 AP_IMPLEMENT_HOOK_RUN_ALL(int, drop_privileges,
  94                           (apr_pool_t * pchild, server_rec * s),
  95                           (pchild, s), OK, DECLINED)
  96 AP_IMPLEMENT_HOOK_RUN_FIRST(int, mpm,
  97                             (apr_pool_t *pconf, apr_pool_t *plog, server_rec *s),
  98                             (pconf, plog, s), DECLINED)
  99 AP_IMPLEMENT_HOOK_RUN_FIRST(int, mpm_query,
 100                             (int query_code, int *result, apr_status_t *_rv),
 101                             (query_code, result, _rv), DECLINED)
 102 AP_IMPLEMENT_HOOK_RUN_FIRST(apr_status_t, mpm_register_timed_callback,
 103                             (apr_time_t t, ap_mpm_callback_fn_t *cbfn, void *baton),
 104                             (t, cbfn, baton), APR_ENOTIMPL)
 105 AP_IMPLEMENT_HOOK_VOID(end_generation,
 106                        (server_rec *s, ap_generation_t gen),
 107                        (s, gen))
 108 AP_IMPLEMENT_HOOK_VOID(child_status,
 109                        (server_rec *s, pid_t pid, ap_generation_t gen, int slot, mpm_child_status status),
 110                        (s,pid,gen,slot,status))
 111
 112 /* hooks with no args are implemented last, after disabling APR hook probes */
 113 #if defined(APR_HOOK_PROBES_ENABLED)
 114 #undef APR_HOOK_PROBES_ENABLED
 115 #undef APR_HOOK_PROBE_ENTRY
 116 #define APR_HOOK_PROBE_ENTRY(ud,ns,name,args)
 117 #undef APR_HOOK_PROBE_RETURN
 118 #define APR_HOOK_PROBE_RETURN(ud,ns,name,rv,args)
 119 #undef APR_HOOK_PROBE_INVOKE
 120 #define APR_HOOK_PROBE_INVOKE(ud,ns,name,src,args)
 121 #undef APR_HOOK_PROBE_COMPLETE
 122 #define APR_HOOK_PROBE_COMPLETE(ud,ns,name,src,rv,args)
 123 #undef APR_HOOK_INT_DCL_UD
 124 #define APR_HOOK_INT_DCL_UD
 125 #endif
 126 AP_IMPLEMENT_HOOK_RUN_FIRST(const char *, mpm_get_name,
 127                             (void),
 128                             (), NULL)
 129
 130 typedef struct mpm_gen_info_t {
 131     APR_RING_ENTRY(mpm_gen_info_t) link;
 132     int gen;          /* which gen? */
 133     int active;       /* number of active processes */
 134     int done;         /* gen finished? (whether or not active processes) */
 135 } mpm_gen_info_t;
 136
 137 APR_RING_HEAD(mpm_gen_info_head_t, mpm_gen_info_t);
 138 static struct mpm_gen_info_head_t *geninfo, *unused_geninfo;
 139 static int gen_head_init; /* yuck */
 140
 141 /* variables representing config directives implemented here */
 142 const char *ap_pid_fname;
 143 int ap_max_requests_per_child;
 144 char ap_coredump_dir[MAX_STRING_LEN];
 145 int ap_coredumpdir_configured;
 146 int ap_graceful_shutdown_timeout;
 147 AP_DECLARE_DATA apr_uint32_t ap_max_mem_free;
 148 apr_size_t ap_thread_stacksize;
 149
 150 #define ALLOCATOR_MAX_FREE_DEFAULT (2048*1024)
 151
 152 /* Set defaults for config directives implemented here.  This is
 153  * called from core's pre-config hook, so MPMs which need to override
 154  * one of these should run their pre-config hook after that of core.
 155  */
 156 void mpm_common_pre_config(apr_pool_t *pconf)
 157 {
 158     ap_pid_fname = DEFAULT_PIDLOG;
 159     ap_max_requests_per_child = 0; /* unlimited */
 160     apr_cpystrn(ap_coredump_dir, ap_server_root, sizeof(ap_coredump_dir));
 161     ap_coredumpdir_configured = 0;
 162     ap_graceful_shutdown_timeout = 0; /* unlimited */
 163     ap_max_mem_free = ALLOCATOR_MAX_FREE_DEFAULT;
 164     ap_thread_stacksize = 0; /* use system default */
 165 }
 166
 167 /* number of calls to wait_or_timeout between writable probes */
 168 #ifndef INTERVAL_OF_WRITABLE_PROBES
 169 #define INTERVAL_OF_WRITABLE_PROBES 10
 170 #endif
 171 static int wait_or_timeout_counter;
 172
 173 void ap_wait_or_timeout(apr_exit_why_e *status, int *exitcode, apr_proc_t *ret,
 174                         apr_pool_t *p, server_rec *s)
 175 {
 176     apr_status_t rv;
 177
 178     ++wait_or_timeout_counter;
 179     if (wait_or_timeout_counter == INTERVAL_OF_WRITABLE_PROBES) {
 180         wait_or_timeout_counter = 0;
 181         ap_run_monitor(p, s);
 182     }
 183
 184     rv = apr_proc_wait_all_procs(ret, exitcode, status, APR_NOWAIT, p);
 185     if (APR_STATUS_IS_EINTR(rv)) {
 186         ret->pid = -1;
 187         return;
 188     }
 189
 190     if (APR_STATUS_IS_CHILD_DONE(rv)) {
 191         return;
 192     }
 193
 194     apr_sleep(apr_time_from_sec(1));
 195     ret->pid = -1;
 196     return;
 197 }
 198
 199 #if defined(TCP_NODELAY)
 200 void ap_sock_disable_nagle(apr_socket_t *s)
 201 {
 202     /* The Nagle algorithm says that we should delay sending partial
 203      * packets in hopes of getting more data.  We don't want to do
 204      * this; we are not telnet.  There are bad interactions between
 205      * persistent connections and Nagle's algorithm that have very severe
 206      * performance penalties.  (Failing to disable Nagle is not much of a
 207      * problem with simple HTTP.)
 208      *
 209      * In spite of these problems, failure here is not a shooting offense.
 210      */
 211     apr_status_t status = apr_socket_opt_set(s, APR_TCP_NODELAY, 1);
 212
 213     if (status != APR_SUCCESS) {
 214         ap_log_error(APLOG_MARK, APLOG_WARNING, status, ap_server_conf,
 215                      "apr_socket_opt_set: (TCP_NODELAY)");
 216     }
 217 }
 218 #endif
 219
 220 #ifdef HAVE_GETPWNAM
 221 AP_DECLARE(uid_t) ap_uname2id(const char *name)
 222 {
 223     struct passwd *ent;
 224
 225     if (name[0] == '#')
 226         return (atoi(&name[1]));
 227
 228     if (!(ent = getpwnam(name))) {
 229         ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
 230                      "%s: bad user name %s", ap_server_argv0, name);
 231         exit(1);
 232     }
 233
 234     return (ent->pw_uid);
 235 }
 236 #endif
 237
 238 #ifdef HAVE_GETGRNAM
 239 AP_DECLARE(gid_t) ap_gname2id(const char *name)
 240 {
 241     struct group *ent;
 242
 243     if (name[0] == '#')
 244         return (atoi(&name[1]));
 245
 246     if (!(ent = getgrnam(name))) {
 247         ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, NULL,
 248                      "%s: bad group name %s", ap_server_argv0, name);
 249         exit(1);
 250     }
 251
 252     return (ent->gr_gid);
 253 }
 254 #endif
 255
 256 #ifndef HAVE_INITGROUPS
 257 int initgroups(const char *name, gid_t basegid)
 258 {
 259 #if defined(_OSD_POSIX) || defined(OS2) || defined(WIN32) || defined(NETWARE)
 260     return 0;
 261 #else
 262     gid_t groups[NGROUPS_MAX];
 263     struct group *g;
 264     int index = 0;
 265
 266     setgrent();
 267
 268     groups[index++] = basegid;
 269
 270     while (index < NGROUPS_MAX && ((g = getgrent()) != NULL)) {
 271         if (g->gr_gid != basegid) {
 272             char **names;
 273
 274             for (names = g->gr_mem; *names != NULL; ++names) {
 275                 if (!strcmp(*names, name))
 276                     groups[index++] = g->gr_gid;
 277             }
 278         }
 279     }
 280
 281     endgrent();
 282
 283     return setgroups(index, groups);
 284 #endif
 285 }
 286 #endif /* def HAVE_INITGROUPS */
 287
 288 /* standard mpm configuration handling */
 289
 290 const char *ap_mpm_set_pidfile(cmd_parms *cmd, void *dummy,
 291                                const char *arg)
 292 {
 293     const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
 294     if (err != NULL) {
 295         return err;
 296     }
 297
 298     if (cmd->server->is_virtual) {
 299         return "PidFile directive not allowed in <VirtualHost>";
 300     }
 301
 302     ap_pid_fname = arg;
 303     return NULL;
 304 }
 305
 306 void ap_mpm_dump_pidfile(apr_pool_t *p, apr_file_t *out)
 307 {
 308     apr_file_printf(out, "PidFile: \"%s\"\n",
 309                     ap_server_root_relative(p, ap_pid_fname));
 310 }
 311
 312 const char *ap_mpm_set_max_requests(cmd_parms *cmd, void *dummy,
 313                                     const char *arg)
 314 {
 315     const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
 316     if (err != NULL) {
 317         return err;
 318     }
 319
 320     if (!strcasecmp(cmd->cmd->name, "MaxRequestsPerChild")) {
 321         ap_log_error(APLOG_MARK, APLOG_INFO, 0, NULL,
 322                      "MaxRequestsPerChild is deprecated, use "
 323                      "MaxConnectionsPerChild instead.");
 324     }
 325
 326     ap_max_requests_per_child = atoi(arg);
 327
 328     return NULL;
 329 }
 330
 331 const char *ap_mpm_set_coredumpdir(cmd_parms *cmd, void *dummy,
 332                                    const char *arg)
 333 {
 334     apr_finfo_t finfo;
 335     const char *fname;
 336     const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
 337     if (err != NULL) {
 338         return err;
 339     }
 340
 341     fname = ap_server_root_relative(cmd->pool, arg);
 342     if (!fname) {
 343         return apr_pstrcat(cmd->pool, "Invalid CoreDumpDirectory path ",
 344                            arg, NULL);
 345     }
 346     if (apr_stat(&finfo, fname, APR_FINFO_TYPE, cmd->pool) != APR_SUCCESS) {
 347         return apr_pstrcat(cmd->pool, "CoreDumpDirectory ", fname,
 348                            " does not exist", NULL);
 349     }
 350     if (finfo.filetype != APR_DIR) {
 351         return apr_pstrcat(cmd->pool, "CoreDumpDirectory ", fname,
 352                            " is not a directory", NULL);
 353     }
 354     apr_cpystrn(ap_coredump_dir, fname, sizeof(ap_coredump_dir));
 355     ap_coredumpdir_configured = 1;
 356     return NULL;
 357 }
 358
 359 const char * ap_mpm_set_graceful_shutdown(cmd_parms *cmd, void *dummy,
 360                                           const char *arg)
 361 {
 362     const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
 363     if (err != NULL) {
 364         return err;
 365     }
 366     ap_graceful_shutdown_timeout = atoi(arg);
 367     return NULL;
 368 }
 369
 370 const char *ap_mpm_set_max_mem_free(cmd_parms *cmd, void *dummy,
 371                                     const char *arg)
 372 {
 373     long value;
 374     const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
 375     if (err != NULL) {
 376         return err;
 377     }
 378
 379     value = strtol(arg, NULL, 10);
 380     if (value < 0 || errno == ERANGE)
 381         return apr_pstrcat(cmd->pool, "Invalid MaxMemFree value: ",
 382                            arg, NULL);
 383
 384     ap_max_mem_free = (apr_uint32_t)value * 1024;
 385
 386     return NULL;
 387 }
 388
 389 const char *ap_mpm_set_thread_stacksize(cmd_parms *cmd, void *dummy,
 390                                         const char *arg)
 391 {
 392     long value;
 393     const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
 394     if (err != NULL) {
 395         return err;
 396     }
 397
 398     value = strtol(arg, NULL, 10);
 399     if (value < 0 || errno == ERANGE)
 400         return apr_pstrcat(cmd->pool, "Invalid ThreadStackSize value: ",
 401                            arg, NULL);
 402
 403     ap_thread_stacksize = (apr_size_t)value;
 404
 405     return NULL;
 406 }
 407
 408 AP_DECLARE(apr_status_t) ap_mpm_query(int query_code, int *result)
 409 {
 410     apr_status_t rv;
 411
 412     if (ap_run_mpm_query(query_code, result, &rv) == DECLINED) {
 413         rv = APR_EGENERAL;
 414     }
 415
 416     return rv;
 417 }
 418
 419 static void end_gen(mpm_gen_info_t *gi)
 420 {
 421     ap_log_error(APLOG_MARK, APLOG_TRACE4, 0, ap_server_conf,
 422                  "end of generation %d", gi->gen);
 423     ap_run_end_generation(ap_server_conf, gi->gen);
 424     APR_RING_REMOVE(gi, link);
 425     APR_RING_INSERT_HEAD(unused_geninfo, gi, mpm_gen_info_t, link);
 426 }
 427
 428 apr_status_t ap_mpm_end_gen_helper(void *unused) /* cleanup on pconf */
 429 {
 430     int gen = ap_config_generation - 1; /* differs from MPM generation */
 431     mpm_gen_info_t *cur;
 432
 433     if (geninfo == NULL) {
 434         /* initial pconf teardown, MPM hasn't run */
 435         return APR_SUCCESS;
 436     }
 437
 438     cur = APR_RING_FIRST(geninfo);
 439     while (cur != APR_RING_SENTINEL(geninfo, mpm_gen_info_t, link) &&
 440            cur->gen != gen) {
 441         cur = APR_RING_NEXT(cur, link);
 442     }
 443
 444     if (cur == APR_RING_SENTINEL(geninfo, mpm_gen_info_t, link)) {
 445         /* last child of generation already exited */
 446         ap_log_error(APLOG_MARK, APLOG_TRACE4, 0, ap_server_conf,
 447                      "no record of generation %d", gen);
 448     }
 449     else {
 450         cur->done = 1;
 451         if (cur->active == 0) {
 452             end_gen(cur);
 453         }
 454     }
 455
 456     return APR_SUCCESS;
 457 }
 458
 459 /* core's child-status hook
 460  * tracks number of remaining children per generation and
 461  * runs the end-generation hook when the last child of
 462  * a generation exits
 463  */
 464 void ap_core_child_status(server_rec *s, pid_t pid,
 465                           ap_generation_t gen, int slot,
 466                           mpm_child_status status)
 467 {
 468     mpm_gen_info_t *cur;
 469     const char *status_msg = "unknown status";
 470
 471     if (!gen_head_init) { /* where to run this? */
 472         gen_head_init = 1;
 473         geninfo = apr_pcalloc(s->process->pool, sizeof *geninfo);
 474         unused_geninfo = apr_pcalloc(s->process->pool, sizeof *unused_geninfo);
 475         APR_RING_INIT(geninfo, mpm_gen_info_t, link);
 476         APR_RING_INIT(unused_geninfo, mpm_gen_info_t, link);
 477     }
 478
 479     cur = APR_RING_FIRST(geninfo);
 480     while (cur != APR_RING_SENTINEL(geninfo, mpm_gen_info_t, link) &&
 481            cur->gen != gen) {
 482         cur = APR_RING_NEXT(cur, link);
 483     }
 484
 485     switch(status) {
 486     case MPM_CHILD_STARTED:
 487         status_msg = "started";
 488         if (cur == APR_RING_SENTINEL(geninfo, mpm_gen_info_t, link)) {
 489             /* first child for this generation */
 490             if (!APR_RING_EMPTY(unused_geninfo, mpm_gen_info_t, link)) {
 491                 cur = APR_RING_FIRST(unused_geninfo);
 492                 APR_RING_REMOVE(cur, link);
 493                 cur->active = cur->done = 0;
 494             }
 495             else {
 496                 cur = apr_pcalloc(s->process->pool, sizeof *cur);
 497             }
 498             cur->gen = gen;
 499             APR_RING_ELEM_INIT(cur, link);
 500             APR_RING_INSERT_HEAD(geninfo, cur, mpm_gen_info_t, link);
 501         }
 502         ap_random_parent_after_fork();
 503         ++cur->active;
 504         break;
 505     case MPM_CHILD_EXITED:
 506         status_msg = "exited";
 507         if (cur == APR_RING_SENTINEL(geninfo, mpm_gen_info_t, link)) {
 508             ap_log_error(APLOG_MARK, APLOG_ERR, 0, s,
 509                          "no record of generation %d of exiting child %" APR_PID_T_FMT,
 510                          gen, pid);
 511         }
 512         else {
 513             --cur->active;
 514             if (!cur->active && cur->done) { /* no children, server has stopped/restarted */
 515                 end_gen(cur);
 516             }
 517         }
 518         break;
 519     case MPM_CHILD_LOST_SLOT:
 520         status_msg = "lost slot";
 521         /* we don't track by slot, so it doesn't matter */
 522         break;
 523     }
 524     ap_log_error(APLOG_MARK, APLOG_TRACE4, 0, s,
 525                  "mpm child %" APR_PID_T_FMT " (gen %d/slot %d) %s",
 526                  pid, gen, slot, status_msg);
 527 }
 528
 529 AP_DECLARE(apr_status_t) ap_mpm_register_timed_callback(apr_time_t t, ap_mpm_callback_fn_t *cbfn, void *baton)
 530 {
 531     return ap_run_mpm_register_timed_callback(t, cbfn, baton);
 532 }
 533
 534 AP_DECLARE(const char *)ap_show_mpm(void)
 535 {
 536     const char *name = ap_run_mpm_get_name();
 537
 538     if (!name) {
 539         name = "";
 540     }
 541
 542     return name;
 543 }
 544
 545 AP_DECLARE(const char *)ap_check_mpm(void)
 546 {
 547     static const char *last_mpm_name = NULL;
 548
 549     if (!_hooks.link_mpm || _hooks.link_mpm->nelts == 0)
 550         return "No MPM loaded.";
 551     else if (_hooks.link_mpm->nelts > 1)
 552         return "More than one MPM loaded.";
 553
 554     if (last_mpm_name) {
 555         if (strcmp(last_mpm_name, ap_show_mpm())) {
 556             return "The MPM cannot be changed during restart.";
 557         }
 558     }
 559     else {
 560         last_mpm_name = apr_pstrdup(ap_pglobal, ap_show_mpm());
 561     }
 562
 563     return NULL;
 564 }