php 启动过程 - reqeust RSHUTDOWN 过程

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
• 关闭内存管理器