php 启动过程 - reqeust RINIT 过程

php 启动过程 - reqeust RINIT 过程

概述

apache 接收到请求之后, 交给 php 处理

php 模块在接收到请求后, 会对请求进行初始化, 及 RINIT 过程

调用触发

• apache 启动时注册的钩子函数 ap_hook_handler 在接收请求时触发, 实际调用的是 php_handler 函数

  • ap_hook_handler(php_handler, NULL, NULL, APR_HOOK_MIDDLE);
    

调用过程

• 调用 php_handler

  • static int php_handler(request_rec *r)
    {
    	// 省略 ...
    	
    #define PHPAP_INI_OFF php_apache_ini_dtor(r, parent_req TSRMLS_CC);
    	// 获取 php 模块配置
    	conf = ap_get_module_config(r->per_dir_config, &php5_module);
    	// 设置 server_context
    	ctx = SG(server_context);
    	if (ctx == NULL || (ctx && ctx->request_processed && !strcmp(r->protocol, "INCLUDED"))) {
    normal:
    		ctx = SG(server_context) = apr_pcalloc(r->pool, sizeof(*ctx));
    		apr_pool_cleanup_register(r->pool, (void *)&SG(server_context), php_server_context_cleanup, apr_pool_cleanup_null);
    		ctx->r = r;
    		ctx = NULL; /* May look weird to null it here, but it is to catch the right case in the first_try later on */
    	} else {
    		parent_req = ctx->r;
    		ctx->r = r;
    	}
    	// 应用配置
    	apply_config(conf);
    	
    	// 省略 ...
    	
    	// php 层面对请求进行检查, 若发现问题, 返回相应错误
    	if (r->used_path_info == AP_REQ_REJECT_PATH_INFO
    		&& r->path_info && r->path_info[0]) {
    		PHPAP_INI_OFF;
    		return HTTP_NOT_FOUND;
    	}
    
    	// 省略 ...
    	
    	// 构造请求
        if (php_apache_request_ctor(r, ctx TSRMLS_CC)!=SUCCESS) {
        	zend_bailout();
        }
    
    	// 省略 ...
    
    	if (AP2(last_modified)) {
    		ap_update_mtime(r, r->finfo.mtime);
    		ap_set_last_modified(r);
    	}
    
    	// 判断是解析文件, 还是不经解析展示源码
    	if (strncmp(r->handler, PHP_SOURCE_MAGIC_TYPE, sizeof(PHP_SOURCE_MAGIC_TYPE) - 1) == 0) {
    		zend_syntax_highlighter_ini syntax_highlighter_ini;
    		php_get_highlight_struct(&syntax_highlighter_ini);
    		highlight_file((char *)r->filename, &syntax_highlighter_ini TSRMLS_CC);
    	} else {
    		zend_file_handle zfd;
    		zfd.type = ZEND_HANDLE_FILENAME;
    		zfd.filename = (char *) r->filename;
    		zfd.free_filename = 0;
    		zfd.opened_path = NULL;
    
    		if (!parent_req) {
    			// 执行 php 脚本
    			php_execute_script(&zfd TSRMLS_CC);
    		} else {
    			zend_execute_scripts(ZEND_INCLUDE TSRMLS_CC, NULL, 1, &zfd);
    		}
    
    		apr_table_set(r->notes, "mod_php_memory_usage",
    			apr_psprintf(ctx->r->pool, "%" APR_SIZE_T_FMT, zend_memory_peak_usage(1 TSRMLS_CC)));
    	}
    } zend_end_try();
    
    	if (!parent_req) {
    		// 清除请求结构
    		php_apache_request_dtor(r TSRMLS_CC);
    		ctx->request_processed = 1;
    		
    		// 省略 ...
    		
    		apr_pool_cleanup_run(r->pool, (void *)&SG(server_context), php_server_context_cleanup);
    	} else {
    		ctx->r = parent_req;
    	}
    
    	return OK;
    }
    

  • 设置 server 上下文 server_context

  • 加载配置

  • 对请求进行检查, 若出现问题, 返回对应错误

  • 构造请求 php_apache_request_ctor

    // 构造请求
    static int php_apache_request_ctor(request_rec *r, php_struct *ctx TSRMLS_DC)
    {
    	char *content_length;
    	const char *auth;
    	// 设置全局变量的值
    	SG(sapi_headers).http_response_code = !r->status ? HTTP_OK : r->status;
    	SG(request_info).content_type = apr_table_get(r->headers_in, "Content-Type");
    	SG(request_info).query_string = apr_pstrdup(r->pool, r->args);
    	SG(request_info).request_method = r->method;
    	SG(request_info).proto_num = r->proto_num;
    	SG(request_info).request_uri = apr_pstrdup(r->pool, r->uri);
    	SG(request_info).path_translated = apr_pstrdup(r->pool, r->filename);
    	r->no_local_copy = 1;
    
    	content_length = (char *) apr_table_get(r->headers_in, "Content-Length");
    	SG(request_info).content_length = (content_length ? atol(content_length) : 0);
    
    	apr_table_unset(r->headers_out, "Content-Length");
    	apr_table_unset(r->headers_out, "Last-Modified");
    	apr_table_unset(r->headers_out, "Expires");
    	apr_table_unset(r->headers_out, "ETag");
    
    	auth = apr_table_get(r->headers_in, "Authorization");
    	// 验证 auth
    	php_handle_auth_data(auth TSRMLS_CC);
    
    	if (SG(request_info).auth_user == NULL && r->user) {
    		SG(request_info).auth_user = estrdup(r->user);
    	}
    
    	ctx->r->user = apr_pstrdup(ctx->r->pool, SG(request_info).auth_user);
    	// 调用 php_request_startup 构造请求
    	return php_request_startup(TSRMLS_C);
    }
    

    • 调用 php_request_startup, 初始化请求, 在这里, 程序对于是否定义了 APACHE_HOOKS 定义不同的 php_request_startup 函数, 但是主体内容基本是一致, 以下仅针对定义过 APACHE_HOOKS 常量的 php_request_startup

      • int php_request_startup(TSRMLS_D)
        {
        	int retval = SUCCESS;
        
        #if PHP_SIGCHILD
        	signal(SIGCHLD, sigchld_handler);
        #endif
        	// 启动 sapi, php 处理请求 sapi 是第一步
        	if (php_start_sapi() == FAILURE) {
        		return FAILURE;
        	}
        
        	php_output_activate(TSRMLS_C);
        	sapi_activate(TSRMLS_C);
        	php_hash_environment(TSRMLS_C);
        
        	zend_try {
        		PG(during_request_startup) = 1;
        		if (PG(expose_php)) {
        			sapi_add_header(SAPI_PHP_VERSION_HEADER, sizeof(SAPI_PHP_VERSION_HEADER)-1, 1);
        		}
        	} zend_catch {
        		retval = FAILURE;
        	} zend_end_try();
        
        	return retval;
        }
        

      • php_start_sapi 启动 sapi, sapi 是处理 php 请求的入口, 第一步

        // 启动 sapi
        static int php_start_sapi(TSRMLS_D)
        {
        	int retval = SUCCESS;
        
        	if(!SG(sapi_started)) {
        		zend_try {
        			PG(during_request_startup) = 1;
        			// 初始化变量
        			PG(modules_activated) = 0;
        			PG(header_is_being_sent) = 0;
        			PG(connection_status) = PHP_CONNECTION_NORMAL;
        			// zend 引擎激活
        			zend_activate(TSRMLS_C);
        			// 设置超时时间
        			zend_set_timeout(EG(timeout_seconds), 1);
        			// 激活各子模块
        			zend_activate_modules(TSRMLS_C);
        			// 设置模块激活标识
        			PG(modules_activated)=1;
        		} zend_catch {
        			retval = FAILURE;
        		} zend_end_try();
        
        		SG(sapi_started) = 1;
        	}
        	return retval;
        }
        

        • 调用 zend_activate, 激活 zend 引擎

          • // 激活 zend 引擎
            void zend_activate(TSRMLS_D) /* {{{ */
            {
            	// 重置垃圾回收
            	gc_reset(TSRMLS_C);
            	// 初始化编译器
            	init_compiler(TSRMLS_C);
            	// 初始化执行器
            	init_executor(TSRMLS_C);
            	startup_scanner(TSRMLS_C);
            }
            

          • gc_reset, 重置 gc 垃圾回收全局结构

            ZEND_API void gc_reset(TSRMLS_D)
            {
            	GC_G(gc_runs) = 0;
            	GC_G(collected) = 0;
            
            #if GC_BENCH
            	GC_G(root_buf_length) = 0;
            	GC_G(root_buf_peak) = 0;
            	GC_G(zval_possible_root) = 0;
            	GC_G(zobj_possible_root) = 0;
            	GC_G(zval_buffered) = 0;
            	GC_G(zobj_buffered) = 0;
            	GC_G(zval_remove_from_buffer) = 0;
            	GC_G(zobj_remove_from_buffer) = 0;
            	GC_G(zval_marked_grey) = 0;
            	GC_G(zobj_marked_grey) = 0;
            #endif
            
            	GC_G(roots).next = &GC_G(roots);
            	GC_G(roots).prev = &GC_G(roots);
            
            	if (GC_G(buf)) {
            		GC_G(unused) = NULL;
            		GC_G(first_unused) = GC_G(buf);
            
            		GC_G(zval_to_free) = NULL;
            	} else {
            		GC_G(unused) = NULL;
            		GC_G(first_unused) = NULL;
            		GC_G(last_unused) = NULL;
            	}
            }
            

          • init_compiler, 初始化编译器, 主要指的是初始化 compiler_globals 全局结构体的值以及初始化资源列表

            void init_compiler(TSRMLS_D)
            {
            	// 设置 opcode 命令数组为空
            	CG(active_op_array) = NULL;
            	memset(&CG(context), 0, sizeof(CG(context)));
            	// 初始化全局编译结构
            	zend_init_compiler_data_structures(TSRMLS_C);
            	// 初始化资源列表
            	zend_init_rsrc_list(TSRMLS_C);
            	zend_hash_init(&CG(filenames_table), 5, NULL, (dtor_func_t) free_estring, 0);
            	zend_llist_init(&CG(open_files), sizeof(zend_file_handle), (void (*)(void *)) file_handle_dtor, 0);
            	CG(unclean_shutdown) = 0;
            }
            

          • init_executor, 初始化执行器, 主要是设置 executor_globals 全局执行器结构的值

            // 初始化全局执行器
            void init_executor(TSRMLS_D) /* {{{ */
            {
            	// 初始化浮点运算单元
            	zend_init_fpu(TSRMLS_C);
            	// 初始化 zval 结构
            	INIT_ZVAL(EG(uninitialized_zval));
            	// 将 zval 结构的 refcount__gc 自增 1
            	Z_ADDREF(EG(uninitialized_zval));
            	INIT_ZVAL(EG(error_zval));
            	EG(uninitialized_zval_ptr)=&EG(uninitialized_zval);
            	EG(error_zval_ptr)=&EG(error_zval);
            /* destroys stack frame, therefore makes core dumps worthless */
            #if 0&&ZEND_DEBUG
            	original_sigsegv_handler = signal(SIGSEGV, zend_handle_sigsegv);
            #endif
            	EG(return_value_ptr_ptr) = NULL;
            
            	EG(symtable_cache_ptr) = EG(symtable_cache) - 1;
            	EG(symtable_cache_limit) = EG(symtable_cache) + SYMTABLE_CACHE_SIZE - 1;
            	EG(no_extensions) = 0;
            
            	EG(function_table) = CG(function_table);
            	EG(class_table) = CG(class_table);
            
            	EG(in_execution) = 0;
            	EG(in_autoload) = NULL;
            	EG(autoload_func) = NULL;
            	EG(error_handling) = EH_NORMAL;
            
            	zend_vm_stack_init(TSRMLS_C);
            	zend_vm_stack_push((void *) NULL TSRMLS_CC);
            
            	zend_hash_init(&EG(symbol_table), 50, NULL, ZVAL_PTR_DTOR, 0);
            	EG(active_symbol_table) = &EG(symbol_table);
            
            	zend_llist_apply(&zend_extensions, (llist_apply_func_t) zend_extension_activator TSRMLS_CC);
            	EG(opline_ptr) = NULL;
            
            	zend_hash_init(&EG(included_files), 5, NULL, NULL, 0);
            
            	EG(ticks_count) = 0;
            
            	EG(user_error_handler) = NULL;
            
            	EG(current_execute_data) = NULL;
            
            	zend_stack_init(&EG(user_error_handlers_error_reporting));
            	zend_ptr_stack_init(&EG(user_error_handlers));
            	zend_ptr_stack_init(&EG(user_exception_handlers));
            	// 初始化对象池
            	zend_objects_store_init(&EG(objects_store), 1024);
            
            	EG(full_tables_cleanup) = 0;
            #ifdef ZEND_WIN32
            	EG(timed_out) = 0;
            #endif
            
            	EG(exception) = NULL;
            	EG(prev_exception) = NULL;
            
            	EG(scope) = NULL;
            	EG(called_scope) = NULL;
            
            	EG(This) = NULL;
            
            	EG(active_op_array) = NULL;
            
            	EG(active) = 1;
            	EG(start_op) = NULL;
            }
            

          • startup_scanner, 启动扫描器, 初始化扫描器

            void startup_scanner(TSRMLS_D)
            {
            	CG(parse_error) = 0;
            	CG(doc_comment) = NULL;
            	CG(doc_comment_len) = 0;
            	zend_stack_init(&SCNG(state_stack));
            	zend_ptr_stack_init(&SCNG(heredoc_label_stack));
            }
            

            • 扫描器结构

              • // 扫描器
                struct _zend_php_scanner_globals {
                	zend_file_handle *yy_in;
                	zend_file_handle *yy_out;
                
                	unsigned int yy_leng;
                	unsigned char *yy_start;
                	unsigned char *yy_text;
                	unsigned char *yy_cursor;
                	unsigned char *yy_marker;
                	unsigned char *yy_limit;
                	int yy_state;
                	zend_stack state_stack;
                	zend_ptr_stack heredoc_label_stack;
                	
                	/* original (unfiltered) script */
                	unsigned char *script_org;
                	size_t script_org_size;
                
                	/* filtered script */
                	unsigned char *script_filtered;
                	size_t script_filtered_size;
                
                	/* input/output filters */
                	zend_encoding_filter input_filter;
                	zend_encoding_filter output_filter;
                	const zend_encoding *script_encoding;
                };
                

        • 调用 zend_activate_modules, 调用各子模块的 request_startup_func 函数, 各子模块结构在 sapi MINIT 时被记录下来

          • void zend_activate_modules(TSRMLS_D)
            {
            	// module_request_startup_handlers 在 sapi MINIT 的 zend_collect_module_handlers 时被记录下来
            	zend_module_entry **p = module_request_startup_handlers;
            	// 循环遍历, 调用各模块的 request_startup_func 函数
            	while (*p) {
            		zend_module_entry *module = *p;
            
            		if (module->request_startup_func(module->type, module->module_number TSRMLS_CC)==FAILURE) {
            			zend_error(E_WARNING, "request_startup() for %s module failed", module->name);
            			exit(1);
            		}
            		p++;
            	}
            }
            

  • 判断是否解析文件

  • 执行 php 脚本

  • 清除请求结构

总结

request RINIT 是每个请求传给 php 时均需要执行的

RINIT 过程主要是为每个请求设置服务器环境以及相关的各种配置, 以便后续执行

RINIT 过程的主要部分在于 php_request_startup 函数, 该函数的主要作用如下:

• 启动 sapi
• 激活 zend 引擎
• 重置垃圾回收
• 初始化编译器
• 初始化执行器
• 初始化扫描器