zend_observer.c

Go to the documentation of this file.

/*
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
   | Copyright (c) Zend Technologies Ltd. (http://www.zend.com)           |
   +----------------------------------------------------------------------+
   | This source file is subject to version 2.00 of the Zend license,     |
   | that is bundled with this package in the file LICENSE, and is        |
   | available through the world-wide-web at the following url:           |
   | http://www.zend.com/license/2_00.txt.                                |
   | If you did not receive a copy of the Zend license and are unable to  |
   | obtain it through the world-wide-web, please send a note to          |
   | license@zend.com so we can mail you a copy immediately.              |
   +----------------------------------------------------------------------+
   | Authors: Levi Morrison <levim@php.net>                               |
   |          Sammy Kaye Powers <sammyk@php.net>                          |
   |          Bob Weinand <bobwei9@hotmail.com>                           |
   +----------------------------------------------------------------------+
*/
 
#include "zend_observer.h"
 
#include "zend_extensions.h"
#include "zend_llist.h"
#include "zend_vm.h"
 
#define ZEND_OBSERVER_NOT_OBSERVED ((void *) 2)
 
static zend_llist zend_observers_fcall_list;
static zend_llist zend_observer_function_declared_callbacks;
static zend_llist zend_observer_class_linked_callbacks;
static zend_llist zend_observer_error_callbacks;
static zend_llist zend_observer_fiber_init;
static zend_llist zend_observer_fiber_switch;
static zend_llist zend_observer_fiber_destroy;
 
int zend_observer_fcall_op_array_extension;
int zend_observer_fcall_internal_function_extension;
bool zend_observer_errors_observed;
bool zend_observer_function_declared_observed;
bool zend_observer_class_linked_observed;
 
// Call during minit/startup ONLY
ZEND_API void zend_observer_fcall_register(zend_observer_fcall_init init)
{
    zend_llist_add_element(&zend_observers_fcall_list, &init);
}
 
// Called by engine before MINITs
ZEND_API void zend_observer_startup(void)
{
    zend_llist_init(&zend_observers_fcall_list, sizeof(zend_observer_fcall_init), NULL, 1);
    zend_llist_init(&zend_observer_function_declared_callbacks, sizeof(zend_observer_function_declared_cb), NULL, 1);
    zend_llist_init(&zend_observer_class_linked_callbacks, sizeof(zend_observer_class_linked_cb), NULL, 1);
    zend_llist_init(&zend_observer_error_callbacks, sizeof(zend_observer_error_cb), NULL, 1);
    zend_llist_init(&zend_observer_fiber_init, sizeof(zend_observer_fiber_init_handler), NULL, 1);
    zend_llist_init(&zend_observer_fiber_switch, sizeof(zend_observer_fiber_switch_handler), NULL, 1);
    zend_llist_init(&zend_observer_fiber_destroy, sizeof(zend_observer_fiber_destroy_handler), NULL, 1);
 
    zend_observer_fcall_op_array_extension = -1;
    zend_observer_fcall_internal_function_extension = -1;
}
 
ZEND_API void zend_observer_post_startup(void)
{
    if (zend_observers_fcall_list.count) {
        /* We don't want to get an extension handle unless an ext installs an observer
         * Allocate each a begin and an end pointer */
        zend_observer_fcall_op_array_extension =
            zend_get_op_array_extension_handles("Zend Observer", (int) zend_observers_fcall_list.count * 2);
 
        zend_observer_fcall_internal_function_extension =
            zend_get_internal_function_extension_handles("Zend Observer", (int) zend_observers_fcall_list.count * 2);
 
        /* ZEND_CALL_TRAMPOLINE has SPEC(OBSERVER) but zend_init_call_trampoline_op()
         * is called before any extensions have registered as an observer. So we
         * adjust the offset to the observed handler when we know we need to observe. */
        ZEND_VM_SET_OPCODE_HANDLER(&EG(call_trampoline_op));
 
        /* ZEND_HANDLE_EXCEPTION also has SPEC(OBSERVER) and no observer extensions
         * exist when zend_init_exception_op() is called. */
        ZEND_VM_SET_OPCODE_HANDLER(EG(exception_op));
        ZEND_VM_SET_OPCODE_HANDLER(EG(exception_op) + 1);
        ZEND_VM_SET_OPCODE_HANDLER(EG(exception_op) + 2);
 
        // Add an observer temporary to store previous observed frames
        zend_internal_function *zif;
        ZEND_HASH_FOREACH_PTR(CG(function_table), zif) {
            ++zif->T;
        } ZEND_HASH_FOREACH_END();
        zend_class_entry *ce;
        ZEND_HASH_MAP_FOREACH_PTR(CG(class_table), ce) {
            ZEND_HASH_MAP_FOREACH_PTR(&ce->function_table, zif) {
                ++zif->T;
            } ZEND_HASH_FOREACH_END();
        } ZEND_HASH_FOREACH_END();
    }
}
 
ZEND_API void zend_observer_activate(void)
{
    EG(current_observed_frame) = NULL;
}
 
ZEND_API void zend_observer_shutdown(void)
{
    zend_llist_destroy(&zend_observers_fcall_list);
    zend_llist_destroy(&zend_observer_function_declared_callbacks);
    zend_llist_destroy(&zend_observer_class_linked_callbacks);
    zend_llist_destroy(&zend_observer_error_callbacks);
    zend_llist_destroy(&zend_observer_fiber_init);
    zend_llist_destroy(&zend_observer_fiber_switch);
    zend_llist_destroy(&zend_observer_fiber_destroy);
}
 
static void zend_observer_fcall_install(zend_execute_data *execute_data)
{
    zend_llist *list = &zend_observers_fcall_list;
    zend_function *function = execute_data->func;
 
    ZEND_ASSERT(RUN_TIME_CACHE(&function->common));
    zend_observer_fcall_begin_handler *begin_handlers = ZEND_OBSERVER_DATA(function), *begin_handlers_start = begin_handlers;
    zend_observer_fcall_end_handler *end_handlers = (zend_observer_fcall_end_handler *)begin_handlers + list->count, *end_handlers_start = end_handlers;
 
    *begin_handlers = ZEND_OBSERVER_NOT_OBSERVED;
    *end_handlers = ZEND_OBSERVER_NOT_OBSERVED;
    bool has_handlers = false;
 
    for (zend_llist_element *element = list->head; element; element = element->next) {
        zend_observer_fcall_init init;
        memcpy(&init, element->data, sizeof init);
        zend_observer_fcall_handlers handlers = init(execute_data);
        if (handlers.begin) {
            *(begin_handlers++) = handlers.begin;
            has_handlers = true;
        }
        if (handlers.end) {
            *(end_handlers++) = handlers.end;
            has_handlers = true;
        }
    }
 
    // end handlers are executed in reverse order
    for (--end_handlers; end_handlers_start < end_handlers; --end_handlers, ++end_handlers_start) {
        zend_observer_fcall_end_handler tmp = *end_handlers;
        *end_handlers = *end_handlers_start;
        *end_handlers_start = tmp;
    }
 
    if (!has_handlers) {
        *begin_handlers_start = ZEND_OBSERVER_NONE_OBSERVED;
    }
}
 
/* We need to provide the ability to retrieve the handler which will move onto the position the current handler was.
 * The fundamental problem is that, if a handler is removed while it's being executed, it will move handlers around:
 * the previous next handler is now at the place where the current handler was.
 * Hence, the next handler executed will be the one after the next handler.
 * Callees must thus invoke the next handler themselves, with the same arguments they were passed. */
static bool zend_observer_remove_handler(void **first_handler, void *old_handler, void **next_handler) {
    size_t registered_observers = zend_observers_fcall_list.count;
 
    void **last_handler = first_handler + registered_observers - 1;
    for (void **cur_handler = first_handler; cur_handler <= last_handler; ++cur_handler) {
        if (*cur_handler == old_handler) {
            if (registered_observers == 1 || (cur_handler == first_handler && cur_handler[1] == NULL)) {
                *cur_handler = ZEND_OBSERVER_NOT_OBSERVED;
                *next_handler = NULL;
            } else {
                if (cur_handler != last_handler) {
                    memmove(cur_handler, cur_handler + 1, sizeof(cur_handler) * (last_handler - cur_handler));
                }
                *last_handler = NULL;
                *next_handler = *cur_handler;
            }
            return true;
        }
    }
    return false;
}
 
ZEND_API void zend_observer_add_begin_handler(zend_function *function, zend_observer_fcall_begin_handler begin) {
    size_t registered_observers = zend_observers_fcall_list.count;
    zend_observer_fcall_begin_handler *first_handler = ZEND_OBSERVER_DATA(function), *last_handler = first_handler + registered_observers - 1;
    if (*first_handler == ZEND_OBSERVER_NOT_OBSERVED || *first_handler == ZEND_OBSERVER_NONE_OBSERVED) {
        *first_handler = begin;
    } else {
        for (zend_observer_fcall_begin_handler *cur_handler = first_handler + 1; cur_handler <= last_handler; ++cur_handler) {
            if (*cur_handler == NULL) {
                *cur_handler = begin;
                return;
            }
        }
        // there's no space for new handlers, then it's forbidden to call this function
        ZEND_UNREACHABLE();
    }
}
 
ZEND_API bool zend_observer_remove_begin_handler(zend_function *function, zend_observer_fcall_begin_handler begin, zend_observer_fcall_begin_handler *next) {
    void **begin_handlers = (void **)ZEND_OBSERVER_DATA(function);
    if (zend_observer_remove_handler(begin_handlers, begin, (void**)next)) {
        // Ensure invariant: ZEND_OBSERVER_NONE_OBSERVED in begin_handlers if both are not observed
        if (*begin_handlers == ZEND_OBSERVER_NOT_OBSERVED) {
            size_t registered_observers = zend_observers_fcall_list.count;
            if (begin_handlers[registered_observers] /* first end handler */ == ZEND_OBSERVER_NOT_OBSERVED) {
                *begin_handlers = ZEND_OBSERVER_NONE_OBSERVED;
            }
        }
        return true;
    }
    return false;
}
 
ZEND_API void zend_observer_add_end_handler(zend_function *function, zend_observer_fcall_end_handler end) {
    size_t registered_observers = zend_observers_fcall_list.count;
    void **begin_handler = (void **)ZEND_OBSERVER_DATA(function);
    zend_observer_fcall_end_handler *end_handler = (zend_observer_fcall_end_handler *)begin_handler + registered_observers;
    // to allow to preserve the invariant that end handlers are in reverse order of begin handlers, push the new end handler in front
    if (*end_handler != ZEND_OBSERVER_NOT_OBSERVED) {
        // there's no space for new handlers, then it's forbidden to call this function
        ZEND_ASSERT(end_handler[registered_observers - 1] == NULL);
        memmove(end_handler + 1, end_handler, sizeof(end_handler) * (registered_observers - 1));
    } else if (*begin_handler == ZEND_OBSERVER_NONE_OBSERVED) {
        *begin_handler = ZEND_OBSERVER_NOT_OBSERVED;
    }
    *end_handler = end;
}
 
ZEND_API bool zend_observer_remove_end_handler(zend_function *function, zend_observer_fcall_end_handler end, zend_observer_fcall_end_handler *next) {
    size_t registered_observers = zend_observers_fcall_list.count;
    void **begin_handlers = (void **)ZEND_OBSERVER_DATA(function);
    void **end_handlers = begin_handlers + registered_observers;
    if (zend_observer_remove_handler(end_handlers, end, (void**)next)) {
        // Ensure invariant: ZEND_OBSERVER_NONE_OBSERVED in begin_handlers if both are not observed
        if (*begin_handlers == ZEND_OBSERVER_NOT_OBSERVED && *end_handlers == ZEND_OBSERVER_NOT_OBSERVED) {
            *begin_handlers = ZEND_OBSERVER_NONE_OBSERVED;
        }
        return true;
    }
    return false;
}
 
static inline zend_execute_data **prev_observed_frame(zend_execute_data *execute_data) {
    zend_function *func = EX(func);
    ZEND_ASSERT(func);
    return (zend_execute_data **)&Z_PTR_P(EX_VAR_NUM((ZEND_USER_CODE(func->type) ? func->op_array.last_var : ZEND_CALL_NUM_ARGS(execute_data)) + func->common.T - 1));
}
 
static void ZEND_FASTCALL _zend_observe_fcall_begin(zend_execute_data *execute_data) {
    if (!ZEND_OBSERVER_ENABLED) {
        return;
    }
 
    zend_observer_fcall_begin_specialized(execute_data, true);
}
 
ZEND_API void ZEND_FASTCALL zend_observer_fcall_begin_prechecked(zend_execute_data *execute_data, zend_observer_fcall_begin_handler *handler)
{
    zend_observer_fcall_begin_handler *possible_handlers_end = handler + zend_observers_fcall_list.count;
 
    if (!*handler) {
        zend_observer_fcall_install(execute_data);
        if (zend_observer_handler_is_unobserved(handler)) {
            return;
        }
    }
 
    zend_observer_fcall_end_handler *end_handler = (zend_observer_fcall_end_handler *)possible_handlers_end;
    if (*end_handler != ZEND_OBSERVER_NOT_OBSERVED) {
        *prev_observed_frame(execute_data) = EG(current_observed_frame);
        EG(current_observed_frame) = execute_data;
 
        if (*handler == ZEND_OBSERVER_NOT_OBSERVED) { // this function must not be called if ZEND_OBSERVER_NONE_OBSERVED, hence sufficient to check
            return;
        }
    }
 
    do {
        (*handler)(execute_data);
    } while (++handler != possible_handlers_end && *handler != NULL);
}
 
ZEND_API void ZEND_FASTCALL zend_observer_generator_resume(zend_execute_data *execute_data)
{
    _zend_observe_fcall_begin(execute_data);
}
 
ZEND_API void ZEND_FASTCALL zend_observer_fcall_begin(zend_execute_data *execute_data)
{
    ZEND_ASSUME(EX(func));
    if (!(EX(func)->common.fn_flags & ZEND_ACC_GENERATOR)) {
        _zend_observe_fcall_begin(execute_data);
    }
}
 
static inline void call_end_observers(zend_execute_data *execute_data, zval *return_value) {
    zend_function *func = EX(func);
    ZEND_ASSERT(func);
 
    zend_observer_fcall_end_handler *handler = (zend_observer_fcall_end_handler *)ZEND_OBSERVER_DATA(func) + zend_observers_fcall_list.count;
    // TODO: Fix exceptions from generators
    // ZEND_ASSERT(fcall_data);
    if (!*handler || *handler == ZEND_OBSERVER_NOT_OBSERVED) {
        return;
    }
 
    zend_observer_fcall_end_handler *possible_handlers_end = handler + zend_observers_fcall_list.count;
    do {
        (*handler)(execute_data, return_value);
    } while (++handler != possible_handlers_end && *handler != NULL);
}
 
ZEND_API void ZEND_FASTCALL zend_observer_fcall_end_prechecked(zend_execute_data *execute_data, zval *return_value)
{
    call_end_observers(execute_data, return_value);
    EG(current_observed_frame) = *prev_observed_frame(execute_data);
}
 
ZEND_API void zend_observer_fcall_end_all(void)
{
    zend_execute_data *execute_data = EG(current_observed_frame), *original_execute_data = EG(current_execute_data);
    EG(current_observed_frame) = NULL;
    while (execute_data) {
        EG(current_execute_data) = execute_data;
        call_end_observers(execute_data, NULL);
        execute_data = *prev_observed_frame(execute_data);
    }
    EG(current_execute_data) = original_execute_data;
}
 
ZEND_API void zend_observer_function_declared_register(zend_observer_function_declared_cb cb)
{
    zend_observer_function_declared_observed = true;
    zend_llist_add_element(&zend_observer_function_declared_callbacks, &cb);
}
 
ZEND_API void ZEND_FASTCALL _zend_observer_function_declared_notify(zend_op_array *op_array, zend_string *name)
{
    if (CG(compiler_options) & ZEND_COMPILE_IGNORE_OBSERVER) {
        return;
    }
 
    for (zend_llist_element *element = zend_observer_function_declared_callbacks.head; element; element = element->next) {
        zend_observer_function_declared_cb callback = *(zend_observer_function_declared_cb *) (element->data);
        callback(op_array, name);
    }
}
 
ZEND_API void zend_observer_class_linked_register(zend_observer_class_linked_cb cb)
{
    zend_observer_class_linked_observed = true;
    zend_llist_add_element(&zend_observer_class_linked_callbacks, &cb);
}
 
ZEND_API void ZEND_FASTCALL _zend_observer_class_linked_notify(zend_class_entry *ce, zend_string *name)
{
    if (CG(compiler_options) & ZEND_COMPILE_IGNORE_OBSERVER) {
        return;
    }
 
    for (zend_llist_element *element = zend_observer_class_linked_callbacks.head; element; element = element->next) {
        zend_observer_class_linked_cb callback = *(zend_observer_class_linked_cb *) (element->data);
        callback(ce, name);
    }
}
 
ZEND_API void zend_observer_error_register(zend_observer_error_cb cb)
{
    zend_observer_errors_observed = true;
    zend_llist_add_element(&zend_observer_error_callbacks, &cb);
}
 
ZEND_API void _zend_observer_error_notify(int type, zend_string *error_filename, uint32_t error_lineno, zend_string *message)
{
    for (zend_llist_element *element = zend_observer_error_callbacks.head; element; element = element->next) {
        zend_observer_error_cb callback = *(zend_observer_error_cb *) (element->data);
        callback(type, error_filename, error_lineno, message);
    }
}
 
ZEND_API void zend_observer_fiber_init_register(zend_observer_fiber_init_handler handler)
{
    zend_llist_add_element(&zend_observer_fiber_init, &handler);
}
 
ZEND_API void zend_observer_fiber_switch_register(zend_observer_fiber_switch_handler handler)
{
    zend_llist_add_element(&zend_observer_fiber_switch, &handler);
}
 
ZEND_API void zend_observer_fiber_destroy_register(zend_observer_fiber_destroy_handler handler)
{
    zend_llist_add_element(&zend_observer_fiber_destroy, &handler);
}
 
ZEND_API void ZEND_FASTCALL zend_observer_fiber_init_notify(zend_fiber_context *initializing)
{
    zend_llist_element *element;
    zend_observer_fiber_init_handler callback;
 
    initializing->top_observed_frame = NULL;
 
    for (element = zend_observer_fiber_init.head; element; element = element->next) {
        callback = *(zend_observer_fiber_init_handler *) element->data;
        callback(initializing);
    }
}
 
ZEND_API void ZEND_FASTCALL zend_observer_fiber_switch_notify(zend_fiber_context *from, zend_fiber_context *to)
{
    zend_llist_element *element;
    zend_observer_fiber_switch_handler callback;
 
    if (from->status == ZEND_FIBER_STATUS_DEAD) {
        zend_observer_fcall_end_all(); // fiber is either finished (call will do nothing) or has bailed out
    }
 
    for (element = zend_observer_fiber_switch.head; element; element = element->next) {
        callback = *(zend_observer_fiber_switch_handler *) element->data;
        callback(from, to);
    }
 
    from->top_observed_frame = EG(current_observed_frame);
    EG(current_observed_frame) = to->top_observed_frame;
}
 
ZEND_API void ZEND_FASTCALL zend_observer_fiber_destroy_notify(zend_fiber_context *destroying)
{
    zend_llist_element *element;
    zend_observer_fiber_destroy_handler callback;
 
    for (element = zend_observer_fiber_destroy.head; element; element = element->next) {
        callback = *(zend_observer_fiber_destroy_handler *) element->data;
        callback(destroying);
    }
}