1 /*
2 +----------------------------------------------------------------------+
3 | Zend Engine |
4 +----------------------------------------------------------------------+
5 | Copyright (c) Zend Technologies Ltd. (http://www.zend.com) |
6 +----------------------------------------------------------------------+
7 | This source file is subject to version 2.00 of the Zend license, |
8 | that is bundled with this package in the file LICENSE, and is |
9 | available through the world-wide-web at the following url: |
10 | http://www.zend.com/license/2_00.txt. |
11 | If you did not receive a copy of the Zend license and are unable to |
12 | obtain it through the world-wide-web, please send a note to |
13 | license@zend.com so we can mail you a copy immediately. |
14 +----------------------------------------------------------------------+
15 | Authors: Levi Morrison <levim@php.net> |
16 | Sammy Kaye Powers <sammyk@php.net> |
17 +----------------------------------------------------------------------+
18 */
19
20 #include "zend_observer.h"
21
22 #include "zend_extensions.h"
23 #include "zend_llist.h"
24 #include "zend_vm.h"
25
26 #define ZEND_OBSERVER_DATA(op_array) \
27 ZEND_OP_ARRAY_EXTENSION(op_array, zend_observer_fcall_op_array_extension)
28
29 #define ZEND_OBSERVER_NOT_OBSERVED ((void *) 2)
30
31 #define ZEND_OBSERVABLE_FN(fn_flags) \
32 (!(fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE))
33
34 zend_llist zend_observers_fcall_list;
35 zend_llist zend_observer_error_callbacks;
36
37 int zend_observer_fcall_op_array_extension;
38
39 ZEND_TLS zend_execute_data *first_observed_frame;
40 ZEND_TLS zend_execute_data *current_observed_frame;
41
42 // Call during minit/startup ONLY
zend_observer_fcall_register(zend_observer_fcall_init init)43 ZEND_API void zend_observer_fcall_register(zend_observer_fcall_init init)
44 {
45 zend_llist_add_element(&zend_observers_fcall_list, &init);
46 }
47
48 // Called by engine before MINITs
zend_observer_startup(void)49 ZEND_API void zend_observer_startup(void)
50 {
51 zend_llist_init(&zend_observers_fcall_list, sizeof(zend_observer_fcall_init), NULL, 1);
52 zend_llist_init(&zend_observer_error_callbacks, sizeof(zend_observer_error_cb), NULL, 1);
53
54 zend_observer_fcall_op_array_extension = -1;
55 }
56
zend_observer_post_startup(void)57 ZEND_API void zend_observer_post_startup(void)
58 {
59 if (zend_observers_fcall_list.count) {
60 /* We don't want to get an extension handle unless an ext installs an observer
61 * Allocate each a begin and an end pointer */
62 zend_observer_fcall_op_array_extension =
63 zend_get_op_array_extension_handles("Zend Observer", (int) zend_observers_fcall_list.count * 2);
64
65 /* ZEND_CALL_TRAMPOLINE has SPEC(OBSERVER) but zend_init_call_trampoline_op()
66 * is called before any extensions have registered as an observer. So we
67 * adjust the offset to the observed handler when we know we need to observe. */
68 ZEND_VM_SET_OPCODE_HANDLER(&EG(call_trampoline_op));
69
70 /* ZEND_HANDLE_EXCEPTION also has SPEC(OBSERVER) and no observer extensions
71 * exist when zend_init_exception_op() is called. */
72 ZEND_VM_SET_OPCODE_HANDLER(EG(exception_op));
73 ZEND_VM_SET_OPCODE_HANDLER(EG(exception_op) + 1);
74 ZEND_VM_SET_OPCODE_HANDLER(EG(exception_op) + 2);
75 }
76 }
77
zend_observer_activate(void)78 ZEND_API void zend_observer_activate(void)
79 {
80 first_observed_frame = NULL;
81 current_observed_frame = NULL;
82 }
83
zend_observer_deactivate(void)84 ZEND_API void zend_observer_deactivate(void)
85 {
86 // now empty and unused, but kept for ABI compatibility
87 }
88
zend_observer_shutdown(void)89 ZEND_API void zend_observer_shutdown(void)
90 {
91 zend_llist_destroy(&zend_observers_fcall_list);
92 zend_llist_destroy(&zend_observer_error_callbacks);
93 }
94
zend_observer_fcall_install(zend_execute_data * execute_data)95 static void zend_observer_fcall_install(zend_execute_data *execute_data)
96 {
97 zend_llist *list = &zend_observers_fcall_list;
98 zend_function *function = execute_data->func;
99 zend_op_array *op_array = &function->op_array;
100
101 ZEND_ASSERT(function->type != ZEND_INTERNAL_FUNCTION);
102
103 ZEND_ASSERT(RUN_TIME_CACHE(op_array));
104 zend_observer_fcall_begin_handler *begin_handlers = (zend_observer_fcall_begin_handler *)&ZEND_OBSERVER_DATA(op_array);
105 zend_observer_fcall_end_handler *end_handlers = (zend_observer_fcall_end_handler *)begin_handlers + list->count, *end_handlers_start = end_handlers;
106
107 *begin_handlers = ZEND_OBSERVER_NOT_OBSERVED;
108 *end_handlers = ZEND_OBSERVER_NOT_OBSERVED;
109
110 for (zend_llist_element *element = list->head; element; element = element->next) {
111 zend_observer_fcall_init init;
112 memcpy(&init, element->data, sizeof init);
113 zend_observer_fcall_handlers handlers = init(execute_data);
114 if (handlers.begin) {
115 *(begin_handlers++) = handlers.begin;
116 }
117 if (handlers.end) {
118 *(end_handlers++) = handlers.end;
119 }
120 }
121
122 // end handlers are executed in reverse order
123 for (--end_handlers; end_handlers_start < end_handlers; --end_handlers, ++end_handlers_start) {
124 zend_observer_fcall_end_handler tmp = *end_handlers;
125 *end_handlers = *end_handlers_start;
126 *end_handlers_start = tmp;
127 }
128 }
129
_zend_observe_fcall_begin(zend_execute_data * execute_data)130 static void ZEND_FASTCALL _zend_observe_fcall_begin(zend_execute_data *execute_data)
131 {
132 if (!ZEND_OBSERVER_ENABLED) {
133 return;
134 }
135
136 zend_op_array *op_array = &execute_data->func->op_array;
137 uint32_t fn_flags = op_array->fn_flags;
138
139 if (!ZEND_OBSERVABLE_FN(fn_flags)) {
140 return;
141 }
142
143 zend_observer_fcall_begin_handler *handler = (zend_observer_fcall_begin_handler *)&ZEND_OBSERVER_DATA(op_array);
144 if (!*handler) {
145 zend_observer_fcall_install(execute_data);
146 }
147
148 zend_observer_fcall_begin_handler *possible_handlers_end = handler + zend_observers_fcall_list.count;
149
150 zend_observer_fcall_end_handler *end_handler = (zend_observer_fcall_end_handler *)possible_handlers_end;
151 if (*end_handler != ZEND_OBSERVER_NOT_OBSERVED) {
152 if (first_observed_frame == NULL) {
153 first_observed_frame = execute_data;
154 }
155 current_observed_frame = execute_data;
156 }
157
158 if (*handler == ZEND_OBSERVER_NOT_OBSERVED) {
159 return;
160 }
161
162 do {
163 (*handler)(execute_data);
164 } while (++handler != possible_handlers_end && *handler != NULL);
165 }
166
zend_observer_generator_resume(zend_execute_data * execute_data)167 ZEND_API void ZEND_FASTCALL zend_observer_generator_resume(zend_execute_data *execute_data)
168 {
169 _zend_observe_fcall_begin(execute_data);
170 }
171
zend_observer_fcall_begin(zend_execute_data * execute_data)172 ZEND_API void ZEND_FASTCALL zend_observer_fcall_begin(zend_execute_data *execute_data)
173 {
174 ZEND_ASSUME(execute_data->func);
175 if (!(execute_data->func->common.fn_flags & ZEND_ACC_GENERATOR)) {
176 _zend_observe_fcall_begin(execute_data);
177 }
178 }
179
zend_observer_is_skipped_frame(zend_execute_data * execute_data)180 static inline bool zend_observer_is_skipped_frame(zend_execute_data *execute_data) {
181 zend_function *func = execute_data->func;
182
183 if (!func || func->type == ZEND_INTERNAL_FUNCTION || !ZEND_OBSERVABLE_FN(func->common.fn_flags)) {
184 return true;
185 }
186
187 zend_observer_fcall_end_handler end_handler = (&ZEND_OBSERVER_DATA(&func->op_array))[zend_observers_fcall_list.count];
188 if (end_handler == NULL || end_handler == ZEND_OBSERVER_NOT_OBSERVED) {
189 return true;
190 }
191
192 return false;
193 }
194
zend_observer_fcall_end(zend_execute_data * execute_data,zval * return_value)195 ZEND_API void ZEND_FASTCALL zend_observer_fcall_end(zend_execute_data *execute_data, zval *return_value)
196 {
197 zend_function *func = execute_data->func;
198
199 if (!ZEND_OBSERVER_ENABLED
200 || !ZEND_OBSERVABLE_FN(func->common.fn_flags)) {
201 return;
202 }
203
204 zend_observer_fcall_end_handler *handler = (zend_observer_fcall_end_handler *)&ZEND_OBSERVER_DATA(&func->op_array) + zend_observers_fcall_list.count;
205 // TODO: Fix exceptions from generators
206 // ZEND_ASSERT(fcall_data);
207 if (!*handler || *handler == ZEND_OBSERVER_NOT_OBSERVED) {
208 return;
209 }
210
211 zend_observer_fcall_end_handler *possible_handlers_end = handler + zend_observers_fcall_list.count;
212 do {
213 (*handler)(execute_data, return_value);
214 } while (++handler != possible_handlers_end && *handler != NULL);
215
216 if (first_observed_frame == execute_data) {
217 first_observed_frame = NULL;
218 current_observed_frame = NULL;
219 } else {
220 zend_execute_data *ex = execute_data->prev_execute_data;
221 while (ex && zend_observer_is_skipped_frame(ex)) {
222 ex = ex->prev_execute_data;
223 }
224 current_observed_frame = ex;
225 }
226 }
227
zend_observer_fcall_end_all(void)228 ZEND_API void zend_observer_fcall_end_all(void)
229 {
230 zend_execute_data *ex = current_observed_frame;
231 while (ex != NULL) {
232 if (ex->func && ex->func->type != ZEND_INTERNAL_FUNCTION) {
233 zend_observer_fcall_end(ex, NULL);
234 }
235 ex = ex->prev_execute_data;
236 }
237 }
238
zend_observer_error_register(zend_observer_error_cb cb)239 ZEND_API void zend_observer_error_register(zend_observer_error_cb cb)
240 {
241 zend_llist_add_element(&zend_observer_error_callbacks, &cb);
242 }
243
zend_observer_error_notify(int type,const char * error_filename,uint32_t error_lineno,zend_string * message)244 void zend_observer_error_notify(int type, const char *error_filename, uint32_t error_lineno, zend_string *message)
245 {
246 for (zend_llist_element *element = zend_observer_error_callbacks.head; element; element = element->next) {
247 zend_observer_error_cb callback = *(zend_observer_error_cb *) (element->data);
248 callback(type, error_filename, error_lineno, message);
249 }
250 }
251
