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(function) \
27 ZEND_OP_ARRAY_EXTENSION((&(function)->common), zend_observer_fcall_op_array_extension)
28
29 #define ZEND_OBSERVER_NOT_OBSERVED ((void *) 2)
30
31 #define ZEND_OBSERVABLE_FN(function) \
32 (ZEND_MAP_PTR(function->common.run_time_cache) && !(function->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE))
33
34 zend_llist zend_observers_fcall_list;
35 zend_llist zend_observer_function_declared_callbacks;
36 zend_llist zend_observer_class_linked_callbacks;
37 zend_llist zend_observer_error_callbacks;
38 zend_llist zend_observer_fiber_init;
39 zend_llist zend_observer_fiber_switch;
40 zend_llist zend_observer_fiber_destroy;
41
42 int zend_observer_fcall_op_array_extension;
43 bool zend_observer_errors_observed;
44 bool zend_observer_function_declared_observed;
45 bool zend_observer_class_linked_observed;
46
47 ZEND_TLS zend_execute_data *current_observed_frame;
48
49 // Call during minit/startup ONLY
zend_observer_fcall_register(zend_observer_fcall_init init)50 ZEND_API void zend_observer_fcall_register(zend_observer_fcall_init init)
51 {
52 zend_llist_add_element(&zend_observers_fcall_list, &init);
53 }
54
55 // Called by engine before MINITs
zend_observer_startup(void)56 ZEND_API void zend_observer_startup(void)
57 {
58 zend_llist_init(&zend_observers_fcall_list, sizeof(zend_observer_fcall_init), NULL, 1);
59 zend_llist_init(&zend_observer_function_declared_callbacks, sizeof(zend_observer_function_declared_cb), NULL, 1);
60 zend_llist_init(&zend_observer_class_linked_callbacks, sizeof(zend_observer_class_linked_cb), NULL, 1);
61 zend_llist_init(&zend_observer_error_callbacks, sizeof(zend_observer_error_cb), NULL, 1);
62 zend_llist_init(&zend_observer_fiber_init, sizeof(zend_observer_fiber_init_handler), NULL, 1);
63 zend_llist_init(&zend_observer_fiber_switch, sizeof(zend_observer_fiber_switch_handler), NULL, 1);
64 zend_llist_init(&zend_observer_fiber_destroy, sizeof(zend_observer_fiber_destroy_handler), NULL, 1);
65
66 zend_observer_fcall_op_array_extension = -1;
67 }
68
zend_observer_post_startup(void)69 ZEND_API void zend_observer_post_startup(void)
70 {
71 if (zend_observers_fcall_list.count) {
72 /* We don't want to get an extension handle unless an ext installs an observer
73 * Allocate each a begin and an end pointer */
74 zend_observer_fcall_op_array_extension =
75 zend_get_op_array_extension_handles("Zend Observer", (int) zend_observers_fcall_list.count * 2);
76
77 /* ZEND_CALL_TRAMPOLINE has SPEC(OBSERVER) but zend_init_call_trampoline_op()
78 * is called before any extensions have registered as an observer. So we
79 * adjust the offset to the observed handler when we know we need to observe. */
80 ZEND_VM_SET_OPCODE_HANDLER(&EG(call_trampoline_op));
81
82 /* ZEND_HANDLE_EXCEPTION also has SPEC(OBSERVER) and no observer extensions
83 * exist when zend_init_exception_op() is called. */
84 ZEND_VM_SET_OPCODE_HANDLER(EG(exception_op));
85 ZEND_VM_SET_OPCODE_HANDLER(EG(exception_op) + 1);
86 ZEND_VM_SET_OPCODE_HANDLER(EG(exception_op) + 2);
87
88 // Add an observer temporary to store previous observed frames
89 zend_internal_function *zif;
90 ZEND_HASH_FOREACH_PTR(CG(function_table), zif) {
91 ++zif->T;
92 } ZEND_HASH_FOREACH_END();
93 zend_class_entry *ce;
94 ZEND_HASH_MAP_FOREACH_PTR(CG(class_table), ce) {
95 ZEND_HASH_MAP_FOREACH_PTR(&ce->function_table, zif) {
96 ++zif->T;
97 } ZEND_HASH_FOREACH_END();
98 } ZEND_HASH_FOREACH_END();
99 }
100 }
101
zend_observer_activate(void)102 ZEND_API void zend_observer_activate(void)
103 {
104 current_observed_frame = NULL;
105 }
106
zend_observer_shutdown(void)107 ZEND_API void zend_observer_shutdown(void)
108 {
109 zend_llist_destroy(&zend_observers_fcall_list);
110 zend_llist_destroy(&zend_observer_function_declared_callbacks);
111 zend_llist_destroy(&zend_observer_class_linked_callbacks);
112 zend_llist_destroy(&zend_observer_error_callbacks);
113 zend_llist_destroy(&zend_observer_fiber_init);
114 zend_llist_destroy(&zend_observer_fiber_switch);
115 zend_llist_destroy(&zend_observer_fiber_destroy);
116 }
117
zend_observer_fcall_install(zend_execute_data * execute_data)118 static void zend_observer_fcall_install(zend_execute_data *execute_data)
119 {
120 zend_llist *list = &zend_observers_fcall_list;
121 zend_function *function = execute_data->func;
122
123 ZEND_ASSERT(RUN_TIME_CACHE(&function->common));
124 zend_observer_fcall_begin_handler *begin_handlers = (zend_observer_fcall_begin_handler *)&ZEND_OBSERVER_DATA(function);
125 zend_observer_fcall_end_handler *end_handlers = (zend_observer_fcall_end_handler *)begin_handlers + list->count, *end_handlers_start = end_handlers;
126
127 *begin_handlers = ZEND_OBSERVER_NOT_OBSERVED;
128 *end_handlers = ZEND_OBSERVER_NOT_OBSERVED;
129
130 for (zend_llist_element *element = list->head; element; element = element->next) {
131 zend_observer_fcall_init init;
132 memcpy(&init, element->data, sizeof init);
133 zend_observer_fcall_handlers handlers = init(execute_data);
134 if (handlers.begin) {
135 *(begin_handlers++) = handlers.begin;
136 }
137 if (handlers.end) {
138 *(end_handlers++) = handlers.end;
139 }
140 }
141
142 // end handlers are executed in reverse order
143 for (--end_handlers; end_handlers_start < end_handlers; --end_handlers, ++end_handlers_start) {
144 zend_observer_fcall_end_handler tmp = *end_handlers;
145 *end_handlers = *end_handlers_start;
146 *end_handlers_start = tmp;
147 }
148 }
149
150 /* We need to provide the ability to retrieve the handler which will move onto the position the current handler was.
151 * The fundamental problem is that, if a handler is removed while it's being executed, it will move handlers around:
152 * the previous next handler is now at the place where the current handler was.
153 * Hence, the next handler executed will be the one after the next handler.
154 * Callees must thus invoke the next handler themselves, with the same arguments they were passed. */
zend_observer_remove_handler(void ** first_handler,void * old_handler,void ** next_handler)155 static bool zend_observer_remove_handler(void **first_handler, void *old_handler, void **next_handler) {
156 size_t registered_observers = zend_observers_fcall_list.count;
157
158 void **last_handler = first_handler + registered_observers - 1;
159 for (void **cur_handler = first_handler; cur_handler <= last_handler; ++cur_handler) {
160 if (*cur_handler == old_handler) {
161 if (registered_observers == 1 || (cur_handler == first_handler && cur_handler[1] == NULL)) {
162 *cur_handler = ZEND_OBSERVER_NOT_OBSERVED;
163 *next_handler = NULL;
164 } else {
165 if (cur_handler != last_handler) {
166 memmove(cur_handler, cur_handler + 1, sizeof(cur_handler) * (last_handler - cur_handler));
167 }
168 *last_handler = NULL;
169 *next_handler = *cur_handler;
170 }
171 return true;
172 }
173 }
174 return false;
175 }
176
zend_observer_add_begin_handler(zend_function * function,zend_observer_fcall_begin_handler begin)177 ZEND_API void zend_observer_add_begin_handler(zend_function *function, zend_observer_fcall_begin_handler begin) {
178 size_t registered_observers = zend_observers_fcall_list.count;
179 zend_observer_fcall_begin_handler *first_handler = (void *)&ZEND_OBSERVER_DATA(function), *last_handler = first_handler + registered_observers - 1;
180 if (*first_handler == ZEND_OBSERVER_NOT_OBSERVED) {
181 *first_handler = begin;
182 } else {
183 for (zend_observer_fcall_begin_handler *cur_handler = first_handler + 1; cur_handler <= last_handler; ++cur_handler) {
184 if (*cur_handler == NULL) {
185 *cur_handler = begin;
186 return;
187 }
188 }
189 // there's no space for new handlers, then it's forbidden to call this function
190 ZEND_UNREACHABLE();
191 }
192 }
193
zend_observer_remove_begin_handler(zend_function * function,zend_observer_fcall_begin_handler begin,zend_observer_fcall_begin_handler * next)194 ZEND_API bool zend_observer_remove_begin_handler(zend_function *function, zend_observer_fcall_begin_handler begin, zend_observer_fcall_begin_handler *next) {
195 return zend_observer_remove_handler((void **)&ZEND_OBSERVER_DATA(function), begin, (void **)next);
196 }
197
zend_observer_add_end_handler(zend_function * function,zend_observer_fcall_end_handler end)198 ZEND_API void zend_observer_add_end_handler(zend_function *function, zend_observer_fcall_end_handler end) {
199 size_t registered_observers = zend_observers_fcall_list.count;
200 zend_observer_fcall_end_handler *end_handler = (zend_observer_fcall_end_handler *)&ZEND_OBSERVER_DATA(function) + registered_observers;
201 // to allow to preserve the invariant that end handlers are in reverse order of begin handlers, push the new end handler in front
202 if (*end_handler != ZEND_OBSERVER_NOT_OBSERVED) {
203 // there's no space for new handlers, then it's forbidden to call this function
204 ZEND_ASSERT(end_handler[registered_observers - 1] == NULL);
205 memmove(end_handler + 1, end_handler, sizeof(end_handler) * (registered_observers - 1));
206 }
207 *end_handler = end;
208 }
209
zend_observer_remove_end_handler(zend_function * function,zend_observer_fcall_end_handler end,zend_observer_fcall_end_handler * next)210 ZEND_API bool zend_observer_remove_end_handler(zend_function *function, zend_observer_fcall_end_handler end, zend_observer_fcall_end_handler *next) {
211 size_t registered_observers = zend_observers_fcall_list.count;
212 return zend_observer_remove_handler((void **)&ZEND_OBSERVER_DATA(function) + registered_observers, end, (void **)next);
213 }
214
prev_observed_frame(zend_execute_data * execute_data)215 static inline zend_execute_data **prev_observed_frame(zend_execute_data *execute_data) {
216 zend_function *func = EX(func);
217 ZEND_ASSERT(func);
218 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));
219 }
220
_zend_observe_fcall_begin(zend_execute_data * execute_data)221 static void ZEND_FASTCALL _zend_observe_fcall_begin(zend_execute_data *execute_data)
222 {
223 if (!ZEND_OBSERVER_ENABLED) {
224 return;
225 }
226
227 zend_function *function = execute_data->func;
228
229 if (!ZEND_OBSERVABLE_FN(function)) {
230 return;
231 }
232
233 zend_observer_fcall_begin_handler *handler = (zend_observer_fcall_begin_handler *)&ZEND_OBSERVER_DATA(function);
234 if (!*handler) {
235 zend_observer_fcall_install(execute_data);
236 }
237
238 zend_observer_fcall_begin_handler *possible_handlers_end = handler + zend_observers_fcall_list.count;
239
240 zend_observer_fcall_end_handler *end_handler = (zend_observer_fcall_end_handler *)possible_handlers_end;
241 if (*end_handler != ZEND_OBSERVER_NOT_OBSERVED) {
242 *prev_observed_frame(execute_data) = current_observed_frame;
243 current_observed_frame = execute_data;
244 }
245
246 if (*handler == ZEND_OBSERVER_NOT_OBSERVED) {
247 return;
248 }
249
250 do {
251 (*handler)(execute_data);
252 } while (++handler != possible_handlers_end && *handler != NULL);
253 }
254
zend_observer_generator_resume(zend_execute_data * execute_data)255 ZEND_API void ZEND_FASTCALL zend_observer_generator_resume(zend_execute_data *execute_data)
256 {
257 _zend_observe_fcall_begin(execute_data);
258 }
259
zend_observer_fcall_begin(zend_execute_data * execute_data)260 ZEND_API void ZEND_FASTCALL zend_observer_fcall_begin(zend_execute_data *execute_data)
261 {
262 ZEND_ASSUME(execute_data->func);
263 if (!(execute_data->func->common.fn_flags & ZEND_ACC_GENERATOR)) {
264 _zend_observe_fcall_begin(execute_data);
265 }
266 }
267
call_end_observers(zend_execute_data * execute_data,zval * return_value)268 static inline void call_end_observers(zend_execute_data *execute_data, zval *return_value) {
269 zend_function *func = execute_data->func;
270 ZEND_ASSERT(func);
271
272 zend_observer_fcall_end_handler *handler = (zend_observer_fcall_end_handler *)&ZEND_OBSERVER_DATA(func) + zend_observers_fcall_list.count;
273 // TODO: Fix exceptions from generators
274 // ZEND_ASSERT(fcall_data);
275 if (!*handler || *handler == ZEND_OBSERVER_NOT_OBSERVED) {
276 return;
277 }
278
279 zend_observer_fcall_end_handler *possible_handlers_end = handler + zend_observers_fcall_list.count;
280 do {
281 (*handler)(execute_data, return_value);
282 } while (++handler != possible_handlers_end && *handler != NULL);
283 }
284
zend_observer_fcall_end(zend_execute_data * execute_data,zval * return_value)285 ZEND_API void ZEND_FASTCALL zend_observer_fcall_end(zend_execute_data *execute_data, zval *return_value)
286 {
287 if (execute_data != current_observed_frame) {
288 return;
289 }
290 call_end_observers(execute_data, return_value);
291 current_observed_frame = *prev_observed_frame(execute_data);
292 }
293
zend_observer_fcall_end_all(void)294 ZEND_API void zend_observer_fcall_end_all(void)
295 {
296 zend_execute_data *execute_data = current_observed_frame, *original_execute_data = EG(current_execute_data);
297 current_observed_frame = NULL;
298 while (execute_data) {
299 EG(current_execute_data) = execute_data;
300 call_end_observers(execute_data, NULL);
301 execute_data = *prev_observed_frame(execute_data);
302 }
303 EG(current_execute_data) = original_execute_data;
304 }
305
zend_observer_function_declared_register(zend_observer_function_declared_cb cb)306 ZEND_API void zend_observer_function_declared_register(zend_observer_function_declared_cb cb)
307 {
308 zend_observer_function_declared_observed = true;
309 zend_llist_add_element(&zend_observer_function_declared_callbacks, &cb);
310 }
311
_zend_observer_function_declared_notify(zend_op_array * op_array,zend_string * name)312 ZEND_API void ZEND_FASTCALL _zend_observer_function_declared_notify(zend_op_array *op_array, zend_string *name)
313 {
314 if (CG(compiler_options) & ZEND_COMPILE_IGNORE_OBSERVER) {
315 return;
316 }
317
318 for (zend_llist_element *element = zend_observer_function_declared_callbacks.head; element; element = element->next) {
319 zend_observer_function_declared_cb callback = *(zend_observer_function_declared_cb *) (element->data);
320 callback(op_array, name);
321 }
322 }
323
zend_observer_class_linked_register(zend_observer_class_linked_cb cb)324 ZEND_API void zend_observer_class_linked_register(zend_observer_class_linked_cb cb)
325 {
326 zend_observer_class_linked_observed = true;
327 zend_llist_add_element(&zend_observer_class_linked_callbacks, &cb);
328 }
329
_zend_observer_class_linked_notify(zend_class_entry * ce,zend_string * name)330 ZEND_API void ZEND_FASTCALL _zend_observer_class_linked_notify(zend_class_entry *ce, zend_string *name)
331 {
332 if (CG(compiler_options) & ZEND_COMPILE_IGNORE_OBSERVER) {
333 return;
334 }
335
336 for (zend_llist_element *element = zend_observer_class_linked_callbacks.head; element; element = element->next) {
337 zend_observer_class_linked_cb callback = *(zend_observer_class_linked_cb *) (element->data);
338 callback(ce, name);
339 }
340 }
341
zend_observer_error_register(zend_observer_error_cb cb)342 ZEND_API void zend_observer_error_register(zend_observer_error_cb cb)
343 {
344 zend_observer_errors_observed = true;
345 zend_llist_add_element(&zend_observer_error_callbacks, &cb);
346 }
347
_zend_observer_error_notify(int type,zend_string * error_filename,uint32_t error_lineno,zend_string * message)348 ZEND_API void _zend_observer_error_notify(int type, zend_string *error_filename, uint32_t error_lineno, zend_string *message)
349 {
350 for (zend_llist_element *element = zend_observer_error_callbacks.head; element; element = element->next) {
351 zend_observer_error_cb callback = *(zend_observer_error_cb *) (element->data);
352 callback(type, error_filename, error_lineno, message);
353 }
354 }
355
zend_observer_fiber_init_register(zend_observer_fiber_init_handler handler)356 ZEND_API void zend_observer_fiber_init_register(zend_observer_fiber_init_handler handler)
357 {
358 zend_llist_add_element(&zend_observer_fiber_init, &handler);
359 }
360
zend_observer_fiber_switch_register(zend_observer_fiber_switch_handler handler)361 ZEND_API void zend_observer_fiber_switch_register(zend_observer_fiber_switch_handler handler)
362 {
363 zend_llist_add_element(&zend_observer_fiber_switch, &handler);
364 }
365
zend_observer_fiber_destroy_register(zend_observer_fiber_destroy_handler handler)366 ZEND_API void zend_observer_fiber_destroy_register(zend_observer_fiber_destroy_handler handler)
367 {
368 zend_llist_add_element(&zend_observer_fiber_destroy, &handler);
369 }
370
zend_observer_fiber_init_notify(zend_fiber_context * initializing)371 ZEND_API void ZEND_FASTCALL zend_observer_fiber_init_notify(zend_fiber_context *initializing)
372 {
373 zend_llist_element *element;
374 zend_observer_fiber_init_handler callback;
375
376 initializing->top_observed_frame = NULL;
377
378 for (element = zend_observer_fiber_init.head; element; element = element->next) {
379 callback = *(zend_observer_fiber_init_handler *) element->data;
380 callback(initializing);
381 }
382 }
383
zend_observer_fiber_switch_notify(zend_fiber_context * from,zend_fiber_context * to)384 ZEND_API void ZEND_FASTCALL zend_observer_fiber_switch_notify(zend_fiber_context *from, zend_fiber_context *to)
385 {
386 zend_llist_element *element;
387 zend_observer_fiber_switch_handler callback;
388
389 if (from->status == ZEND_FIBER_STATUS_DEAD) {
390 zend_observer_fcall_end_all(); // fiber is either finished (call will do nothing) or has bailed out
391 }
392
393 for (element = zend_observer_fiber_switch.head; element; element = element->next) {
394 callback = *(zend_observer_fiber_switch_handler *) element->data;
395 callback(from, to);
396 }
397
398 from->top_observed_frame = current_observed_frame;
399 current_observed_frame = to->top_observed_frame;
400 }
401
zend_observer_fiber_destroy_notify(zend_fiber_context * destroying)402 ZEND_API void ZEND_FASTCALL zend_observer_fiber_destroy_notify(zend_fiber_context *destroying)
403 {
404 zend_llist_element *element;
405 zend_observer_fiber_destroy_handler callback;
406
407 for (element = zend_observer_fiber_destroy.head; element; element = element->next) {
408 callback = *(zend_observer_fiber_destroy_handler *) element->data;
409 callback(destroying);
410 }
411 }
412