php 启动过程 - reqeust RSHUTDOWN 过程

2023-07-21 16:16:22

php 启动过程 - reqeust RSHUTDOWN 过程

概述

request RSHUTDOWN 过程在请求结束后调用

调用触发

同 request RINIT 过程一样, 先是用 apache 注册的钩子函数 php_handler 处理请求
执行 request RINIT 过程
执行 request execute 过程
调用 php_apache_request_dtor 开始进行 request RSHUTDOWN 过程

调用过程

php_handler 处理完请求后, 调用 php_apache_request_dtor 函数进行 request RSHUTDOWN 过程

static int php_handler(request_rec *r)

{

	// 省略 ...

	if (!parent_req) {

		// 销毁释放请求

		php_apache_request_dtor(r TSRMLS_CC);

		ctx->request_processed = 1;

		bucket = apr_bucket_eos_create(r->connection->bucket_alloc);

		APR_BRIGADE_INSERT_TAIL(brigade, bucket);

		rv = ap_pass_brigade(r->output_filters, brigade);

		if (rv != APR_SUCCESS || r->connection->aborted) {

zend_first_try {

			php_handle_aborted_connection();

} zend_end_try();

		}

		apr_brigade_cleanup(brigade);

		apr_pool_cleanup_run(r->pool, (void *)&SG(server_context), php_server_context_cleanup);

	} else {

		ctx->r = parent_req;

	}

	return OK;

}

调用 php_apache_request_dtor

static void php_apache_request_dtor(request_rec *r TSRMLS_DC)

{

	php_request_shutdown(NULL);

}

调用 php_request_shutdown 函数

void php_request_shutdown(void *dummy)

{

	zend_bool report_memleaks;

	TSRMLS_FETCH();

	// 内存泄漏信息

	report_memleaks = PG(report_memleaks);

	// 设置 opcode 执行相关变量为空

	EG(opline_ptr) = NULL;

	EG(active_op_array) = NULL;

	// 销毁 tick 相关

	php_deactivate_ticks(TSRMLS_C);

	// 调用 register_shutdown_function 注册的 shutdown 函数

	if (PG(modules_activated)) zend_try {

		php_call_shutdown_functions(TSRMLS_C);

	} zend_end_try();

	// 调用析构函数

	zend_try {

		zend_call_destructors(TSRMLS_C);

	} zend_end_try();

	// flush 输出缓冲区

	zend_try {

		zend_bool send_buffer = SG(request_info).headers_only ? 0 : 1;

		if (CG(unclean_shutdown) && PG(last_error_type) == E_ERROR &&

			(size_t)PG(memory_limit) < zend_memory_usage(1 TSRMLS_CC)

		) {

			send_buffer = 0;

		}

		if (!send_buffer) {

			php_output_discard_all(TSRMLS_C);

		} else {

			php_output_end_all(TSRMLS_C);

		}

	} zend_end_try();

	// 重置 max_execution_time

	zend_try {

		zend_unset_timeout(TSRMLS_C);

	} zend_end_try();

	// 调用各子模块的 RSHUTDOWN 函数

	if (PG(modules_activated)) {

		zend_deactivate_modules(TSRMLS_C);

		php_free_shutdown_functions(TSRMLS_C);

	}

	// 关闭 output

	zend_try {

		php_output_deactivate(TSRMLS_C);

	} zend_end_try();

	// 销毁 PG(http_globals)

	zend_try {

		int i;

		for (i=0; i<NUM_TRACK_VARS; i++) {

			if (PG(http_globals)[i]) {

				zval_ptr_dtor(&PG(http_globals)[i]);

			}

		}

	} zend_end_try();

	// 释放错误信息

	if (PG(last_error_message)) {

		free(PG(last_error_message));

		PG(last_error_message) = NULL;

	}

	if (PG(last_error_file)) {

		free(PG(last_error_file));

		PG(last_error_file) = NULL;

	}

	// 关闭临时目录

	php_shutdown_temporary_directory();

	// 关闭 扫描器, 执行器, 编译器, 初始化 ini_entries

	zend_deactivate(TSRMLS_C);

	// 调用各子模块的 post_deactivate_func 函数

	zend_try {

		zend_post_deactivate_modules(TSRMLS_C);

	} zend_end_try();

	// 关闭 sapi

	zend_try {

		sapi_deactivate(TSRMLS_C);

	} zend_end_try();

	/* 10. Destroy stream hashes */

	zend_try {

		php_shutdown_stream_hashes(TSRMLS_C);

	} zend_end_try();

	// 关闭内存管理器

	zend_try {

		shutdown_memory_manager(CG(unclean_shutdown) || !report_memleaks, 0 TSRMLS_CC);

	} zend_end_try();

	zend_interned_strings_restore(TSRMLS_C);

	// 重置 max_execution_time

	zend_try {

		zend_unset_timeout(TSRMLS_C);

	} zend_end_try();

#ifdef PHP_WIN32

	if (PG(com_initialized)) {

		CoUninitialize();

		PG(com_initialized) = 0;

	}

#endif

#ifdef HAVE_DTRACE

	DTRACE_REQUEST_SHUTDOWN(SAFE_FILENAME(SG(request_info).path_translated), SAFE_FILENAME(SG(request_info).request_uri), (char *)SAFE_FILENAME(SG(request_info).request_method));

#endif /* HAVE_DTRACE */

}

php_call_shutdown_functions, 调用 register_shutdown_function 注册的 shutdown 函数

void php_call_shutdown_functions(TSRMLS_D)

{

	if (BG(user_shutdown_function_names)) {

		zend_try {

			zend_hash_apply(BG(user_shutdown_function_names), (apply_func_t) user_shutdown_function_call TSRMLS_CC);

		}

		zend_end_try();

		php_free_shutdown_functions(TSRMLS_C);

	}

}

调用 zend_hash_apply, 实际上是对 BG(user_shutdown_function_names) 循环调用 user_shutdown_function_call 函数

ZEND_API void zend_hash_apply(HashTable *ht, apply_func_t apply_func TSRMLS_DC)

{

	Bucket *p;

	IS_CONSISTENT(ht);

	HASH_PROTECT_RECURSION(ht);

	p = ht->pListHead;

	while (p != NULL) {

		int result = apply_func(p->pData TSRMLS_CC);

		if (result & ZEND_HASH_APPLY_REMOVE) {

			p = zend_hash_apply_deleter(ht, p);

		} else {

			p = p->pListNext;

		}

		if (result & ZEND_HASH_APPLY_STOP) {

			break;

		}

	}

	HASH_UNPROTECT_RECURSION(ht);

}

user_shutdown_function_call 函数

static int user_shutdown_function_call(php_shutdown_function_entry *shutdown_function_entry TSRMLS_DC)

{

	zval retval;

	char *function_name;

	if (!zend_is_callable(shutdown_function_entry->arguments[0], 0, &function_name TSRMLS_CC)) {

		php_error(E_WARNING, "(Registered shutdown functions) Unable to call %s() - function does not exist", function_name);

		if (function_name) {

			efree(function_name);

		}

		return 0;

	}

	if (function_name) {

		efree(function_name);

	}

	if (call_user_function(EG(function_table), NULL,

				shutdown_function_entry->arguments[0],

				&retval,

				shutdown_function_entry->arg_count - 1,

				shutdown_function_entry->arguments + 1

				TSRMLS_CC ) == SUCCESS)

	{

		zval_dtor(&retval);

	}

	return 0;

}

zend_call_destructors, 调用各变量的析构函数 __destruct

void zend_call_destructors(TSRMLS_D)

{

	zend_try {

		shutdown_destructors(TSRMLS_C);

	} zend_end_try();

}

调用 shutdown_destructors 函数

void shutdown_destructors(TSRMLS_D) /* {{{ */

{

	zend_try {

		int symbols;

		do {

			symbols = zend_hash_num_elements(&EG(symbol_table));

			zend_hash_reverse_apply(&EG(symbol_table), (apply_func_t) zval_call_destructor TSRMLS_CC);

		} while (symbols != zend_hash_num_elements(&EG(symbol_table)));

		zend_objects_store_call_destructors(&EG(objects_store) TSRMLS_CC);

	} zend_catch {

		/* if we couldn't destruct cleanly, mark all objects as destructed anyway */

		zend_objects_store_mark_destructed(&EG(objects_store) TSRMLS_CC);

	} zend_end_try();

}

zend_hash_reverse_apply 对 EG(symbol_table) 循环调用 zval_call_destructor 函数

static int zval_call_destructor(zval **zv TSRMLS_DC)

{

	if (Z_TYPE_PP(zv) == IS_OBJECT && Z_REFCOUNT_PP(zv) == 1) {

		return ZEND_HASH_APPLY_REMOVE;

	} else {

		return ZEND_HASH_APPLY_KEEP;

	}

}

调用 zend_objects_store_call_destructors, 调用各变量的析构函数

ZEND_API void zend_objects_store_call_destructors(zend_objects_store *objects TSRMLS_DC)

{

	zend_uint i = 1;

	for (i = 1; i < objects->top ; i++) {

		if (objects->object_buckets[i].valid) {

			struct _store_object *obj = &objects->object_buckets[i].bucket.obj;

			if (!objects->object_buckets[i].destructor_called) {

				objects->object_buckets[i].destructor_called = 1;

				if (obj->dtor && obj->object) {

					obj->refcount++;

					// 调用析构函数

					obj->dtor(obj->object, i TSRMLS_CC);

					obj = &objects->object_buckets[i].bucket.obj;

					obj->refcount--;

					if (obj->refcount == 0) {

						GC_REMOVE_ZOBJ_FROM_BUFFER(obj);

					}

				}

			}

		}

	}

}

php_output_discard_all 或者 php_output_end_all, flush 输出缓冲区 (在后续对输出功能做讲解时在详细展开)

zend_deactivate_modules, 调用各子模块的 RSHUTDOWN 函数

void zend_deactivate_modules(TSRMLS_D)

{

	EG(opline_ptr) = NULL; /* we're no longer executing anything */

	zend_try {

		if (EG(full_tables_cleanup)) {

			// 若全部清除, 则对 module_registry 循环调用 module_registry_cleanup 来循环调用 各子模块的 request_shutdown_func 函数

			zend_hash_reverse_apply(&module_registry, (apply_func_t) module_registry_cleanup TSRMLS_CC);

		} else {

			zend_module_entry **p = module_request_shutdown_handlers;

			while (*p) {

				zend_module_entry *module = *p;

				// 循环调用各子模块的 request_shutdown_func 函数

				module->request_shutdown_func(module->type, module->module_number TSRMLS_CC);

				p++;

			}

		}

	} zend_end_try();

}

php_output_deactivate, 关闭 output, 释放所有 handler

PHPAPI void php_output_deactivate(TSRMLS_D)

{

	php_output_handler **handler = NULL;

	if ((OG(flags) & PHP_OUTPUT_ACTIVATED)) {

		php_output_header(TSRMLS_C);

		OG(flags) ^= PHP_OUTPUT_ACTIVATED;

		OG(active) = NULL;

		OG(running) = NULL;

		// 释放 handlers

		if (OG(handlers).elements) {

			while (SUCCESS == zend_stack_top(&OG(handlers), (void *) &handler)) {

				php_output_handler_free(handler TSRMLS_CC);

				zend_stack_del_top(&OG(handlers));

			}

			zend_stack_destroy(&OG(handlers));

		}

	}

}

销毁超全局变量

	zend_try {

		int i;

		// 循环释放 PG(http_globals)

		for (i=0; i<NUM_TRACK_VARS; i++) {

			if (PG(http_globals)[i]) {

				zval_ptr_dtor(&PG(http_globals)[i]);

			}

		}

	} zend_end_try();

zend_deactivate, 关闭扫描器, 执行器, 编译器, 重置 ini_entries

void zend_deactivate(TSRMLS_D)

{

	/* we're no longer executing anything */

	EG(opline_ptr) = NULL;

	EG(active_symbol_table) = NULL;

	zend_try {

		shutdown_scanner(TSRMLS_C);

	} zend_end_try();

	// 调用各扩展的 deactivate 方法

	shutdown_executor(TSRMLS_C);

	zend_try {

		// 销毁编译器

		shutdown_compiler(TSRMLS_C);

	} zend_end_try();

	zend_destroy_rsrc_list(&EG(regular_list) TSRMLS_CC);

#ifdef ZEND_DEBUG

	if (GC_G(gc_enabled) && !CG(unclean_shutdown)) {

		gc_collect_cycles(TSRMLS_C);

	}

#endif

#if GC_BENCH

	fprintf(stderr, "GC Statistics\n");

	fprintf(stderr, "-------------\n");

	fprintf(stderr, "Runs:               %d\n", GC_G(gc_runs));

	fprintf(stderr, "Collected:          %d\n", GC_G(collected));

	fprintf(stderr, "Root buffer length: %d\n", GC_G(root_buf_length));

	fprintf(stderr, "Root buffer peak:   %d\n\n", GC_G(root_buf_peak));

	fprintf(stderr, "      Possible            Remove from  Marked\n");

	fprintf(stderr, "        Root    Buffered     buffer     grey\n");

	fprintf(stderr, "      --------  --------  -----------  ------\n");

	fprintf(stderr, "ZVAL  %8d  %8d  %9d  %8d\n", GC_G(zval_possible_root), GC_G(zval_buffered), GC_G(zval_remove_from_buffer), GC_G(zval_marked_grey));

	fprintf(stderr, "ZOBJ  %8d  %8d  %9d  %8d\n", GC_G(zobj_possible_root), GC_G(zobj_buffered), GC_G(zobj_remove_from_buffer), GC_G(zobj_marked_grey));

#endif

	zend_try {

		// 调用 zend_ini_entry 的 on_modify 函数

		// 释放 ini_entry 的值

		zend_ini_deactivate(TSRMLS_C);

	} zend_end_try();

}

zend_post_deactivate_modules, 调用各子模块的 post_deactivate_func 函数

void zend_post_deactivate_modules(TSRMLS_D)

{

	if (EG(full_tables_cleanup)) {

		zend_hash_apply(&module_registry, (apply_func_t) exec_done_cb TSRMLS_CC);

		zend_hash_reverse_apply(&module_registry, (apply_func_t) module_registry_unload_temp TSRMLS_CC);

	} else {

		zend_module_entry **p = module_post_deactivate_handlers;

		// 循环调用各模块的 post_deactivate_func 函数

		while (*p) {

			zend_module_entry *module = *p;

			module->post_deactivate_func();

			p++;

		}

	}

}

sapi_deactivate, 关闭 sapi, 释放 sapi 相关的结构体
shutdown_memory_manager, 关闭内存管理器

总结

request RSHUTDOWN 过程在每次请求结束后均会调用

主要做的事情是销毁请求执行过程中的一些内存使用

调用 register_shutdown_function 注册的函数

调用 __destruction 函数

flush 输出缓存

调用各扩展的 RSHUTDOWN 函数

关闭 php 输出

销毁超全局数组

释放扫描器, 执行器, 编译器, ini_entries

调用各扩展的 post_deactivate_func 函数

关闭 sapi

关闭内存管理器

码农公寓