Commit 42591f0c authored by Paul Querna's avatar Paul Querna
Browse files

Import the core parts of the DTrace patch. This is a modified and updated 

version of what was submited by Theo before:
 <http://mail-archives.apache.org/mod_mbox/httpd-dev/200805.mbox/%3C6AFBCFE8-4CCA-4A02-8A43-F9170689695D@omniti.com%3E>

Note, this does not hook it up into the build system at this time, because
the original patch was a little too creative there.

Submitted By: Theo Schlossnagle <jesus omniti.com>


git-svn-id: https://svn.apache.org/repos/asf/httpd/httpd/trunk@723565 13f79535-47bb-0310-9956-ffa450edef68
parent e987e86d

ap.d

0 → 100644
+102 −0
Original line number Diff line number Diff line 
#pragma D depends_on provider io

typedef struct request_rec {

    uintptr_t pool;

    uintptr_t connection;

    uintptr_t server;

    uintptr_t next;

    uintptr_t prev;

    uintptr_t main;

    char *the_request;

    int assbackwards;

    int proxyreq;

    int header_only;

    char *protocol;

    int proto_num;

    char *hostname;

    int64_t request_time;

    char *status_line;

    int status;

    const char *method;

    int method_number;

    int64_t allowed;

    uintptr_t allowed_xmethods;

    uintptr_t allowed_methods;

    offset_t sent_bodyct;

    offset_t bytes_sent;

    int64_t mtime;

    int chunked;

    char *range;

    offset_t clength;

    offset_t remaining;

    offset_t read_length;

    int read_body;

    int read_chunked;

    unsigned expecting_100;

    uintptr_t headers_in;

    uintptr_t headers_out;

    uintptr_t err_headers_out;

    uintptr_t subprocess_env;

    uintptr_t notes;

    char *content_type;   /* Break these out --- we dispatch on 'em */

    char *handler;        /* What we *really* dispatch on */

    char *content_encoding;

    uintptr_t content_languages;

    char *vlist_validator;

    char *user;

    char *ap_auth_type;

    int no_cache;

    int no_local_copy;

    char *unparsed_uri;

    char *uri;

    char *filename;

    char *canonical_filename;

    char *path_info;

    char *args;

    /* finfo */

    uintptr_t finfo_pool;

    int32_t finfo_valid;

    int32_t finfo_protection;

    int32_t finfo_filetype;

    int finfo_user;

    int finfo_group;

    uint64_t finfo_inode;

    uint64_t finfo_device;

    int32_t finfo_nlink;

    offset_t finfo_size;

    offset_t finfo_csize;

    int64_t finfo_atime;

    int64_t finfo_mtime;

    int64_t finfo_ctime;

    char *finfo_fname;

    char *finfo_name;

    uintptr_t finfo_ffilehand;

    /* parsed_uri */

    char *uri_scheme;

    char *uri_hostinfo;

    char *uri_user;

    char *uri_password;

    char *uri_hostname;

    char *uri_port_str;

    char *uri_path;

    char *uri_query;

    char *uri_fragment;

    uintptr_t uri_hostent;

    uint16_t uri_port;

    unsigned uri_is_initialized:1;

    unsigned uri_dns_looked_up:1;

    unsigned uri_dns_resolved:1;



    /* back to request_rec */

    int used_path_info;

    uintptr_t per_dir_config;

    uintptr_t request_config;

    uintptr_t htaccess;

    uintptr_t output_filters;

    uintptr_t input_filters;

    uintptr_t proto_output_filters;

    uintptr_t proto_input_filters;

    int eos_sent;

    uintptr_t kept_body;

    uintptr_t invoke_mtx;

} request_rec;

apache_probes.d

0 → 100644
+172 −0
Original line number Diff line number Diff line 
provider ap {

  /* Explicit, core */

  probe internal__redirect(char *, char *);

  probe process__request__entry(uintptr_t, char *);

  probe process__request__return(uintptr_t, char *, uint32_t);

  probe read__request__entry(uintptr_t, uintptr_t);

  probe read__request__success(uintptr_t, char *, char *, char *, uint32_t);

  probe read__request__failure(uintptr_t);



  /* Explicit, modules */

  probe rewrite__log(uintptr_t, int, int, char *, char *);

  probe proxy__run(uintptr_t);

  probe proxy__run__finished(uintptr_t);



  /* Implicit, APR hooks */

  probe translate_name__entry();

  probe translate_name__dispatch__invoke(char *);

  probe translate_name__dispatch__complete(char *, uint32_t);

  probe translate_name__return(uint32_t);

  probe map_to_storage__entry();

  probe map_to_storage__dispatch__invoke(char *);

  probe map_to_storage__dispatch__complete(char *, uint32_t);

  probe map_to_storage__return(uint32_t);

  probe check_user_id__entry();

  probe check_user_id__dispatch__invoke(char *);

  probe check_user_id__dispatch__complete(char *, uint32_t);

  probe check_user_id__return(uint32_t);

  probe fixups__entry();

  probe fixups__dispatch__invoke(char *);

  probe fixups__dispatch__complete(char *, uint32_t);

  probe fixups__return(uint32_t);

  probe type_checker__entry();

  probe type_checker__dispatch__invoke(char *);

  probe type_checker__dispatch__complete(char *, uint32_t);

  probe type_checker__return(uint32_t);

  probe access_checker__entry();

  probe access_checker__dispatch__invoke(char *);

  probe access_checker__dispatch__complete(char *, uint32_t);

  probe access_checker__return(uint32_t);

  probe auth_checker__entry();

  probe auth_checker__dispatch__invoke(char *);

  probe auth_checker__dispatch__complete(char *, uint32_t);

  probe auth_checker__return(uint32_t);

  probe insert_filter__entry();

  probe insert_filter__dispatch__invoke(char *);

  probe insert_filter__dispatch__complete(char *, uint32_t);

  probe insert_filter__return(uint32_t);

  probe create_connection__entry();

  probe create_connection__dispatch__invoke(char *);

  probe create_connection__dispatch__complete(char *, uint32_t);

  probe create_connection__return(uint32_t);

  probe pre_connection__entry();

  probe pre_connection__dispatch__invoke(char *);

  probe pre_connection__dispatch__complete(char *, uint32_t);

  probe pre_connection__return(uint32_t);

  probe process_connection__entry();

  probe process_connection__dispatch__invoke(char *);

  probe process_connection__dispatch__complete(char *, uint32_t);

  probe process_connection__return(uint32_t);

  probe create_request__entry();

  probe create_request__dispatch__invoke(char *);

  probe create_request__dispatch__complete(char *, uint32_t);

  probe create_request__return(uint32_t);

  probe header_parser__entry();

  probe header_parser__dispatch__invoke(char *);

  probe header_parser__dispatch__complete(char *, uint32_t);

  probe header_parser__return(uint32_t);

  probe pre_config__entry();

  probe pre_config__dispatch__invoke(char *);

  probe pre_config__dispatch__complete(char *, uint32_t);

  probe pre_config__return(uint32_t);

  probe test_config__entry();

  probe test_config__dispatch__invoke(char *);

  probe test_config__dispatch__complete(char *, uint32_t);

  probe test_config__return(uint32_t);

  probe post_config__entry();

  probe post_config__dispatch__invoke(char *);

  probe post_config__dispatch__complete(char *, uint32_t);

  probe post_config__return(uint32_t);

  probe open_logs__entry();

  probe open_logs__dispatch__invoke(char *);

  probe open_logs__dispatch__complete(char *, uint32_t);

  probe open_logs__return(uint32_t);

  probe child_init__entry();

  probe child_init__dispatch__invoke(char *);

  probe child_init__dispatch__complete(char *, uint32_t);

  probe child_init__return(uint32_t);

  probe handler__entry();

  probe handler__dispatch__invoke(char *);

  probe handler__dispatch__complete(char *, uint32_t);

  probe handler__return(uint32_t);

  probe quick_handler__entry();

  probe quick_handler__dispatch__invoke(char *);

  probe quick_handler__dispatch__complete(char *, uint32_t);

  probe quick_handler__return(uint32_t);

  probe optional_fn_retrieve__entry();

  probe optional_fn_retrieve__dispatch__invoke(char *);

  probe optional_fn_retrieve__dispatch__complete(char *, uint32_t);

  probe optional_fn_retrieve__return(uint32_t);

  probe get_mgmt_items__entry();

  probe get_mgmt_items__dispatch__invoke(char *);

  probe get_mgmt_items__dispatch__complete(char *, uint32_t);

  probe get_mgmt_items__return(uint32_t);

  probe pre_mpm__entry();

  probe pre_mpm__dispatch__invoke(char *);

  probe pre_mpm__dispatch__complete(char *, uint32_t);

  probe pre_mpm__return(uint32_t);

  probe default_port__entry();

  probe default_port__dispatch__invoke(char *);

  probe default_port__dispatch__complete(char *, uint32_t);

  probe default_port__return(uint32_t);

  probe http_scheme__entry();

  probe http_scheme__dispatch__invoke(char *);

  probe http_scheme__dispatch__complete(char *, uint32_t);

  probe http_scheme__return(uint32_t);

  probe error_log__entry();

  probe error_log__dispatch__invoke(char *);

  probe error_log__dispatch__complete(char *, uint32_t);

  probe error_log__return(uint32_t);

  probe log_transaction__entry();

  probe log_transaction__dispatch__invoke(char *);

  probe log_transaction__dispatch__complete(char *, uint32_t);

  probe log_transaction__return(uint32_t);

  probe monitor__entry();

  probe monitor__dispatch__invoke(char *);

  probe monitor__dispatch__complete(char *, uint32_t);

  probe monitor__return(uint32_t);

  probe post_read_request__entry();

  probe post_read_request__dispatch__invoke(char *);

  probe post_read_request__dispatch__complete(char *, uint32_t);

  probe post_read_request__return(uint32_t);

  probe get_suexec_identity__entry();

  probe get_suexec_identity__dispatch__invoke(char *);

  probe get_suexec_identity__dispatch__complete(char *, uint32_t);

  probe get_suexec_identity__return(uint32_t);

  probe insert_error_filter__entry();

  probe insert_error_filter__dispatch__invoke(char *);

  probe insert_error_filter__dispatch__complete(char *, uint32_t);

  probe insert_error_filter__return(uint32_t);



  /* Implicit, APR hooks for proxy */

  probe scheme_handler__entry();

  probe scheme_handler__dispatch__invoke(char *);

  probe scheme_handler__dispatch__complete(char *, uint32_t);

  probe scheme_handler__return(uint32_t);

  probe canon_handler__entry();

  probe canon_handler__dispatch__invoke(char *);

  probe canon_handler__dispatch__complete(char *, uint32_t);

  probe canon_handler__return(uint32_t);

  probe pre_request__entry();

  probe pre_request__dispatch__invoke(char *);

  probe pre_request__dispatch__complete(char *, uint32_t);

  probe pre_request__return(uint32_t);

  probe post_request__entry();

  probe post_request__dispatch__invoke(char *);

  probe post_request__dispatch__complete(char *, uint32_t);

  probe post_request__return(uint32_t);



  /* Implicit, APR hooks for dav */

  probe gather_propsets__entry();

  probe gather_propsets__dispatch__invoke(char *);

  probe gather_propsets__dispatch__complete(char *, uint32_t);

  probe gather_propsets__return(uint32_t);

  probe find_liveprop__entry();

  probe find_liveprop__dispatch__invoke(char *);

  probe find_liveprop__dispatch__complete(char *, uint32_t);

  probe find_liveprop__return(uint32_t);

  probe insert_all_liveprops__entry();

  probe insert_all_liveprops__dispatch__invoke(char *);

  probe insert_all_liveprops__dispatch__complete(char *, uint32_t);

  probe insert_all_liveprops__return(uint32_t);

};

configure.in

+29 −1
Original line number Diff line number Diff line
@@ -380,7 +380,8 @@ grp.h \ 
strings.h \

sys/prctl.h \

sys/processor.h \

sys/sem.h

sys/sem.h \

sys/sdt.h

)

AC_HEADER_SYS_WAIT
@@ -446,6 +447,33 @@ AC_ARG_WITH(sslport,APACHE_HELP_STRING(--with-sslport=SSLPORT,Port on which to s 
        [if test "$withval" = "yes"; then AC_MSG_ERROR('option --with-sslport requires a value (the SSL TCP port number)'); else SSLPORT="$withval"; fi],

	[SSLPORT=443])



DTRACE=true

AC_ARG_ENABLE(dtrace,APACHE_HELP_STRING(--enable-dtrace,Enable DTrace probes),

[

  enable_dtrace=$enableval

  APR_ADDTO(CPPFLAGS, -DAPR_DTRACE_PROVIDER)

  AC_MSG_ERROR('DTrace Support in the build system is not complete. Patches Welcome!')

],

[

  enable_dtrace=no

])



dnl Disabled dtrace build for now.

enable_dtrace=no



case $host in

  *-solaris2*)

    if test $enable_dtrace = "yes" -a "$ac_cv_header_sys_sdt_h" = "yes"; then

        AC_DEFINE(AP_ENABLE_DTRACE, 1,

                  [Enable DTrace probes])

        DTRACE="/usr/sbin/dtrace $DTRACEFLAGS"

        test -f include/apache_probes.h || $DTRACE -h -s apache_probes.d -o include/apache_probes.h

    fi

    ;;

esac



APACHE_SUBST(DTRACE)



APR_CHECK_APR_DEFINE(APR_HAVE_IPV6)



AC_ARG_ENABLE(v4-mapped,APACHE_HELP_STRING(--enable-v4-mapped,Allow IPv6 sockets to handle IPv4 connections),

include/ap_config.h

+7 −0
Original line number Diff line number Diff line
@@ -238,6 +238,13 @@ 
#define AP_NONBLOCK_WHEN_MULTI_LISTEN 1

#endif



#if AP_ENABLE_DTRACE && HAVE_SYS_SDT_H

#include <sys/sdt.h>

#else

#undef _DTRACE_VERSION

#endif

#include "apache_probes.h"



/* TODO - We need to put OS detection back to make all the following work */



#if defined(SUNOS4) || defined(IRIX) || defined(NEXT) || defined(AUX3) \

modules/http/http_request.c

+8 −0
Original line number Diff line number Diff line
@@ -260,6 +260,7 @@ void ap_process_request_after_handler(request_rec *r) 
    

    c->cs->state = CONN_STATE_WRITE_COMPLETION;

    check_pipeline(c);

    AP_PROCESS_REQUEST_RETURN((uintptr_t)r, r->uri, r->status);

    if (ap_extended_status) {

        ap_time_process_request(c->sbh, STOP_PREQUEST);

    }
@@ -284,6 +285,7 @@ void ap_process_async_request(request_rec *r) 
     * Use this hook with extreme care and only if you know what you are

     * doing.

     */

    AP_PROCESS_REQUEST_ENTRY((uintptr_t)r, r->uri);

    if (ap_extended_status) {

        ap_time_process_request(r->connection->sbh, START_PREQUEST);

    }
@@ -299,6 +301,10 @@ void ap_process_async_request(request_rec *r) 
    }



    if (access_status == SUSPENDED) {

        /* TODO: Should move these steps into a generic function, so modules

         * working on a suspended request can also call _ENTRY again.

         */

        AP_PROCESS_REQUEST_RETURN((uintptr_t)r, r->uri, access_status);

        if (ap_extended_status) {

            ap_time_process_request(c->sbh, STOP_PREQUEST);

        }
@@ -536,6 +542,8 @@ AP_DECLARE(void) ap_internal_redirect(const char *new_uri, request_rec *r) 
    request_rec *new = internal_internal_redirect(new_uri, r);

    int access_status;



    AP_INTERNAL_REDIRECT(r->uri, new_uri);



    /* ap_die was already called, if an error occured */

    if (!new) {

        return;