Use zend_accel_error_noreturn in more places

nikic · nikic · commit 2dc228040a82 · 2020-10-19T16:59:00.000+02:00
Missed the place in accelerator_blacklist that was the actual
motivation here...
diff --git a/ext/opcache/zend_accelerator_blacklist.c b/ext/opcache/zend_accelerator_blacklist.c
@@ -60,15 +60,15 @@ void zend_accel_blacklist_init(zend_blacklist *blacklist)
 
 	blacklist->entries = (zend_blacklist_entry *) calloc(sizeof(zend_blacklist_entry), blacklist->size);
 	if (!blacklist->entries) {
-		zend_accel_error(ACCEL_LOG_FATAL, "Blacklist initialization: no memory\n");
+		zend_accel_error_noreturn(ACCEL_LOG_FATAL, "Blacklist initialization: no memory\n");
 		return;
 	}
 	blacklist->regexp_list = NULL;
 }
 
 static void blacklist_report_regexp_error(const char *pcre_error, int pcre_error_offset)
 {
-	zend_accel_error(ACCEL_LOG_ERROR, "Blacklist compilation failed (offset: %d), %s\n", pcre_error_offset, pcre_error);
+	zend_accel_error_noreturn(ACCEL_LOG_ERROR, "Blacklist compilation failed (offset: %d), %s\n", pcre_error_offset, pcre_error);
 }
 
 static void zend_accel_blacklist_update_regexp(zend_blacklist *blacklist)
@@ -163,7 +163,7 @@ static void zend_accel_blacklist_update_regexp(zend_blacklist *blacklist)
 		if (*c || i == blacklist->pos - 1) {
 			if (*c) {
 				if (!backtrack) {
-					zend_accel_error(ACCEL_LOG_ERROR, "Too long blacklist entry\n");
+					zend_accel_error_noreturn(ACCEL_LOG_ERROR, "Too long blacklist entry\n");
 				}
 				p = backtrack;
 			} else {
@@ -173,7 +173,7 @@ static void zend_accel_blacklist_update_regexp(zend_blacklist *blacklist)
 
 			it = (zend_regexp_list*)malloc(sizeof(zend_regexp_list));
 			if (!it) {
-				zend_accel_error(ACCEL_LOG_ERROR, "malloc() failed\n");
+				zend_accel_error_noreturn(ACCEL_LOG_ERROR, "malloc() failed\n");
 				return;
 			}
 			it->next = NULL;
@@ -302,7 +302,7 @@ static void zend_accel_blacklist_loadone(zend_blacklist *blacklist, char *filena
 		blacklist->entries[blacklist->pos].path_length = path_length;
 		blacklist->entries[blacklist->pos].path = (char *)malloc(path_length + 1);
 		if (!blacklist->entries[blacklist->pos].path) {
-			zend_accel_error(ACCEL_LOG_ERROR, "malloc() failed\n");
+			zend_accel_error_noreturn(ACCEL_LOG_ERROR, "malloc() failed\n");
 			fclose(fp);
 			return;
 		}
diff --git a/ext/opcache/zend_accelerator_hash.c b/ext/opcache/zend_accelerator_hash.c
@@ -54,14 +54,14 @@ void zend_accel_hash_init(zend_accel_hash *accel_hash, uint32_t hash_size)
 	/* set up hash pointers table */
 	accel_hash->hash_table = zend_shared_alloc(sizeof(zend_accel_hash_entry *)*accel_hash->max_num_entries);
 	if (!accel_hash->hash_table) {
-		zend_accel_error(ACCEL_LOG_FATAL, "Insufficient shared memory!");
+		zend_accel_error_noreturn(ACCEL_LOG_FATAL, "Insufficient shared memory!");
 		return;
 	}
 
 	/* set up hash values table */
 	accel_hash->hash_entries = zend_shared_alloc(sizeof(zend_accel_hash_entry)*accel_hash->max_num_entries);
 	if (!accel_hash->hash_entries) {
-		zend_accel_error(ACCEL_LOG_FATAL, "Insufficient shared memory!");
+		zend_accel_error_noreturn(ACCEL_LOG_FATAL, "Insufficient shared memory!");
 		return;
 	}
 	memset(accel_hash->hash_table, 0, sizeof(zend_accel_hash_entry *)*accel_hash->max_num_entries);
diff --git a/ext/opcache/zend_shared_alloc.c b/ext/opcache/zend_shared_alloc.c
@@ -86,7 +86,7 @@ void zend_shared_alloc_create_lock(char *lockfile_path)
 	fchmod(lock_file, 0666);
 
 	if (lock_file == -1) {
-		zend_accel_error(ACCEL_LOG_FATAL, "Unable to create lock file: %s (%d)", strerror(errno), errno);
+		zend_accel_error_noreturn(ACCEL_LOG_FATAL, "Unable to create lock file: %s (%d)", strerror(errno), errno);
 	}
 	val = fcntl(lock_file, F_GETFD, 0);
 	val |= FD_CLOEXEC;
@@ -98,7 +98,7 @@ void zend_shared_alloc_create_lock(char *lockfile_path)
 
 static void no_memory_bailout(size_t allocate_size, char *error)
 {
-	zend_accel_error(ACCEL_LOG_FATAL, "Unable to allocate shared memory segment of %zu bytes: %s: %s (%d)", allocate_size, error?error:"unknown", strerror(errno), errno );
+	zend_accel_error_noreturn(ACCEL_LOG_FATAL, "Unable to allocate shared memory segment of %zu bytes: %s: %s (%d)", allocate_size, error?error:"unknown", strerror(errno), errno );
 }
 
 static void copy_shared_segments(void *to, void *from, int count, int size)
@@ -231,14 +231,14 @@ int zend_shared_alloc_startup(size_t requested_size, size_t reserved_size)
 
 	p_tmp_shared_globals = (zend_smm_shared_globals *) zend_shared_alloc(sizeof(zend_smm_shared_globals));
 	if (!p_tmp_shared_globals) {
-		zend_accel_error(ACCEL_LOG_FATAL, "Insufficient shared memory!");
+		zend_accel_error_noreturn(ACCEL_LOG_FATAL, "Insufficient shared memory!");
 		return ALLOC_FAILURE;
 	}
 	memset(p_tmp_shared_globals, 0, sizeof(zend_smm_shared_globals));
 
 	tmp_shared_segments = zend_shared_alloc(shared_segments_array_size + ZSMMG(shared_segments_count) * sizeof(void *));
 	if (!tmp_shared_segments) {
-		zend_accel_error(ACCEL_LOG_FATAL, "Insufficient shared memory!");
+		zend_accel_error_noreturn(ACCEL_LOG_FATAL, "Insufficient shared memory!");
 		return ALLOC_FAILURE;
 	}
 
@@ -252,7 +252,7 @@ int zend_shared_alloc_startup(size_t requested_size, size_t reserved_size)
 
 	ZSMMG(shared_memory_state).positions = (int *)zend_shared_alloc(sizeof(int) * ZSMMG(shared_segments_count));
 	if (!ZSMMG(shared_memory_state).positions) {
-		zend_accel_error(ACCEL_LOG_FATAL, "Insufficient shared memory!");
+		zend_accel_error_noreturn(ACCEL_LOG_FATAL, "Insufficient shared memory!");
 		return ALLOC_FAILURE;
 	}
 
@@ -263,7 +263,7 @@ int zend_shared_alloc_startup(size_t requested_size, size_t reserved_size)
 			ZSMMG(reserved) = (char*)ZSMMG(shared_segments)[i]->p + ZSMMG(shared_segments)[i]->end;
 			ZSMMG(reserved_size) = reserved_size;
 		} else {
-			zend_accel_error(ACCEL_LOG_FATAL, "Insufficient shared memory!");
+			zend_accel_error_noreturn(ACCEL_LOG_FATAL, "Insufficient shared memory!");
 			return ALLOC_FAILURE;
 		}
 	}
@@ -340,7 +340,7 @@ void *zend_shared_alloc(size_t size)
 
 #if 1
 	if (!ZCG(locked)) {
-		zend_accel_error(ACCEL_LOG_ERROR, "Shared memory lock not obtained");
+		zend_accel_error_noreturn(ACCEL_LOG_ERROR, "Shared memory lock not obtained");
 	}
 #endif
 	if (block_size > ZSMMG(shared_free)) { /* No hope to find a big-enough block */
@@ -482,7 +482,7 @@ void zend_shared_alloc_lock(void)
 			if (errno == EINTR) {
 				continue;
 			}
-			zend_accel_error(ACCEL_LOG_ERROR, "Cannot create lock - %s (%d)", strerror(errno), errno);
+			zend_accel_error_noreturn(ACCEL_LOG_ERROR, "Cannot create lock - %s (%d)", strerror(errno), errno);
 		}
 		break;
 	}
@@ -508,7 +508,7 @@ void zend_shared_alloc_unlock(void)
 
 #ifndef ZEND_WIN32
 	if (fcntl(lock_file, F_SETLK, &mem_write_unlock) == -1) {
-		zend_accel_error(ACCEL_LOG_ERROR, "Cannot remove lock - %s (%d)", strerror(errno), errno);
+		zend_accel_error_noreturn(ACCEL_LOG_ERROR, "Cannot remove lock - %s (%d)", strerror(errno), errno);
 	}
 #ifdef ZTS
 	tsrm_mutex_unlock(zts_lock);
@@ -631,7 +631,7 @@ void zend_accel_shared_protect(int mode)
 	for (i = 0; i < ZSMMG(shared_segments_count); i++) {
 		DWORD oldProtect;
 		if (!VirtualProtect(ZSMMG(shared_segments)[i]->p, ZSMMG(shared_segments)[i]->end, mode, &oldProtect)) {
-			zend_accel_error(ACCEL_LOG_ERROR, "Failed to protect memory");
+			zend_accel_error_noreturn(ACCEL_LOG_ERROR, "Failed to protect memory");
 		}
 	}
 #endif

Original file line number	Diff line number	Diff line change
`@@ -60,15 +60,15 @@ void zend_accel_blacklist_init(zend_blacklist *blacklist)`
`60`	`60`
`61`	`61`	`blacklist->entries = (zend_blacklist_entry *) calloc(sizeof(zend_blacklist_entry), blacklist->size);`
`62`	`62`	`if (!blacklist->entries) {`
`63`		`- zend_accel_error(ACCEL_LOG_FATAL, "Blacklist initialization: no memory\n");`
	`63`	`+ zend_accel_error_noreturn(ACCEL_LOG_FATAL, "Blacklist initialization: no memory\n");`
`64`	`64`	`return;`
`65`	`65`	`}`
`66`	`66`	`blacklist->regexp_list = NULL;`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`static void blacklist_report_regexp_error(const char *pcre_error, int pcre_error_offset)`
`70`	`70`	`{`
`71`		`- zend_accel_error(ACCEL_LOG_ERROR, "Blacklist compilation failed (offset: %d), %s\n", pcre_error_offset, pcre_error);`
	`71`	`+ zend_accel_error_noreturn(ACCEL_LOG_ERROR, "Blacklist compilation failed (offset: %d), %s\n", pcre_error_offset, pcre_error);`
`72`	`72`	`}`
`73`	`73`
`74`	`74`	`static void zend_accel_blacklist_update_regexp(zend_blacklist *blacklist)`
`@@ -163,7 +163,7 @@ static void zend_accel_blacklist_update_regexp(zend_blacklist *blacklist)`
`163`	`163`	`if (*c \|\| i == blacklist->pos - 1) {`
`164`	`164`	`if (*c) {`
`165`	`165`	`if (!backtrack) {`
`166`		`- zend_accel_error(ACCEL_LOG_ERROR, "Too long blacklist entry\n");`
	`166`	`+ zend_accel_error_noreturn(ACCEL_LOG_ERROR, "Too long blacklist entry\n");`
`167`	`167`	`}`
`168`	`168`	`p = backtrack;`
`169`	`169`	`} else {`
`@@ -173,7 +173,7 @@ static void zend_accel_blacklist_update_regexp(zend_blacklist *blacklist)`
`173`	`173`
`174`	`174`	`it = (zend_regexp_list*)malloc(sizeof(zend_regexp_list));`
`175`	`175`	`if (!it) {`
`176`		`- zend_accel_error(ACCEL_LOG_ERROR, "malloc() failed\n");`
	`176`	`+ zend_accel_error_noreturn(ACCEL_LOG_ERROR, "malloc() failed\n");`
`177`	`177`	`return;`
`178`	`178`	`}`
`179`	`179`	`it->next = NULL;`
`@@ -302,7 +302,7 @@ static void zend_accel_blacklist_loadone(zend_blacklist blacklist, char filena`
`302`	`302`	`blacklist->entries[blacklist->pos].path_length = path_length;`
`303`	`303`	`blacklist->entries[blacklist->pos].path = (char *)malloc(path_length + 1);`
`304`	`304`	`if (!blacklist->entries[blacklist->pos].path) {`
`305`		`- zend_accel_error(ACCEL_LOG_ERROR, "malloc() failed\n");`
	`305`	`+ zend_accel_error_noreturn(ACCEL_LOG_ERROR, "malloc() failed\n");`
`306`	`306`	`fclose(fp);`
`307`	`307`	`return;`
`308`	`308`	`}`
Original file line number	Diff line number	Diff line change
`@@ -86,7 +86,7 @@ void zend_shared_alloc_create_lock(char *lockfile_path)`
`86`	`86`	`fchmod(lock_file, 0666);`
`87`	`87`
`88`	`88`	`if (lock_file == -1) {`
`89`		`- zend_accel_error(ACCEL_LOG_FATAL, "Unable to create lock file: %s (%d)", strerror(errno), errno);`
	`89`	`+ zend_accel_error_noreturn(ACCEL_LOG_FATAL, "Unable to create lock file: %s (%d)", strerror(errno), errno);`
`90`	`90`	`}`
`91`	`91`	`val = fcntl(lock_file, F_GETFD, 0);`
`92`	`92`	`val \|= FD_CLOEXEC;`
`@@ -98,7 +98,7 @@ void zend_shared_alloc_create_lock(char *lockfile_path)`
`98`	`98`
`99`	`99`	`static void no_memory_bailout(size_t allocate_size, char *error)`
`100`	`100`	`{`
`101`		`- zend_accel_error(ACCEL_LOG_FATAL, "Unable to allocate shared memory segment of %zu bytes: %s: %s (%d)", allocate_size, error?error:"unknown", strerror(errno), errno );`
	`101`	`+ zend_accel_error_noreturn(ACCEL_LOG_FATAL, "Unable to allocate shared memory segment of %zu bytes: %s: %s (%d)", allocate_size, error?error:"unknown", strerror(errno), errno );`
`102`	`102`	`}`
`103`	`103`
`104`	`104`	`static void copy_shared_segments(void to, void from, int count, int size)`
`@@ -231,14 +231,14 @@ int zend_shared_alloc_startup(size_t requested_size, size_t reserved_size)`
`231`	`231`
`232`	`232`	`p_tmp_shared_globals = (zend_smm_shared_globals *) zend_shared_alloc(sizeof(zend_smm_shared_globals));`
`233`	`233`	`if (!p_tmp_shared_globals) {`
`234`		`- zend_accel_error(ACCEL_LOG_FATAL, "Insufficient shared memory!");`
	`234`	`+ zend_accel_error_noreturn(ACCEL_LOG_FATAL, "Insufficient shared memory!");`
`235`	`235`	`return ALLOC_FAILURE;`
`236`	`236`	`}`
`237`	`237`	`memset(p_tmp_shared_globals, 0, sizeof(zend_smm_shared_globals));`
`238`	`238`
`239`	`239`	`tmp_shared_segments = zend_shared_alloc(shared_segments_array_size + ZSMMG(shared_segments_count) * sizeof(void *));`
`240`	`240`	`if (!tmp_shared_segments) {`
`241`		`- zend_accel_error(ACCEL_LOG_FATAL, "Insufficient shared memory!");`
	`241`	`+ zend_accel_error_noreturn(ACCEL_LOG_FATAL, "Insufficient shared memory!");`
`242`	`242`	`return ALLOC_FAILURE;`
`243`	`243`	`}`
`244`	`244`
`@@ -252,7 +252,7 @@ int zend_shared_alloc_startup(size_t requested_size, size_t reserved_size)`
`252`	`252`
`253`	`253`	`ZSMMG(shared_memory_state).positions = (int )zend_shared_alloc(sizeof(int) ZSMMG(shared_segments_count));`
`254`	`254`	`if (!ZSMMG(shared_memory_state).positions) {`
`255`		`- zend_accel_error(ACCEL_LOG_FATAL, "Insufficient shared memory!");`
	`255`	`+ zend_accel_error_noreturn(ACCEL_LOG_FATAL, "Insufficient shared memory!");`
`256`	`256`	`return ALLOC_FAILURE;`
`257`	`257`	`}`
`258`	`258`
`@@ -263,7 +263,7 @@ int zend_shared_alloc_startup(size_t requested_size, size_t reserved_size)`
`263`	`263`	`ZSMMG(reserved) = (char*)ZSMMG(shared_segments)[i]->p + ZSMMG(shared_segments)[i]->end;`
`264`	`264`	`ZSMMG(reserved_size) = reserved_size;`
`265`	`265`	`} else {`
`266`		`- zend_accel_error(ACCEL_LOG_FATAL, "Insufficient shared memory!");`
	`266`	`+ zend_accel_error_noreturn(ACCEL_LOG_FATAL, "Insufficient shared memory!");`
`267`	`267`	`return ALLOC_FAILURE;`
`268`	`268`	`}`
`269`	`269`	`}`
`@@ -340,7 +340,7 @@ void *zend_shared_alloc(size_t size)`
`340`	`340`
`341`	`341`	`#if 1`
`342`	`342`	`if (!ZCG(locked)) {`
`343`		`- zend_accel_error(ACCEL_LOG_ERROR, "Shared memory lock not obtained");`
	`343`	`+ zend_accel_error_noreturn(ACCEL_LOG_ERROR, "Shared memory lock not obtained");`
`344`	`344`	`}`
`345`	`345`	`#endif`
`346`	`346`	`if (block_size > ZSMMG(shared_free)) { /* No hope to find a big-enough block */`
`@@ -482,7 +482,7 @@ void zend_shared_alloc_lock(void)`
`482`	`482`	`if (errno == EINTR) {`
`483`	`483`	`continue;`
`484`	`484`	`}`
`485`		`- zend_accel_error(ACCEL_LOG_ERROR, "Cannot create lock - %s (%d)", strerror(errno), errno);`
	`485`	`+ zend_accel_error_noreturn(ACCEL_LOG_ERROR, "Cannot create lock - %s (%d)", strerror(errno), errno);`
`486`	`486`	`}`
`487`	`487`	`break;`
`488`	`488`	`}`
`@@ -508,7 +508,7 @@ void zend_shared_alloc_unlock(void)`
`508`	`508`
`509`	`509`	`#ifndef ZEND_WIN32`
`510`	`510`	`if (fcntl(lock_file, F_SETLK, &mem_write_unlock) == -1) {`
`511`		`- zend_accel_error(ACCEL_LOG_ERROR, "Cannot remove lock - %s (%d)", strerror(errno), errno);`
	`511`	`+ zend_accel_error_noreturn(ACCEL_LOG_ERROR, "Cannot remove lock - %s (%d)", strerror(errno), errno);`
`512`	`512`	`}`
`513`	`513`	`#ifdef ZTS`
`514`	`514`	`tsrm_mutex_unlock(zts_lock);`
`@@ -631,7 +631,7 @@ void zend_accel_shared_protect(int mode)`
`631`	`631`	`for (i = 0; i < ZSMMG(shared_segments_count); i++) {`
`632`	`632`	`DWORD oldProtect;`
`633`	`633`	`if (!VirtualProtect(ZSMMG(shared_segments)[i]->p, ZSMMG(shared_segments)[i]->end, mode, &oldProtect)) {`
`634`		`- zend_accel_error(ACCEL_LOG_ERROR, "Failed to protect memory");`
	`634`	`+ zend_accel_error_noreturn(ACCEL_LOG_ERROR, "Failed to protect memory");`
`635`	`635`	`}`
`636`	`636`	`}`
`637`	`637`	`#endif`