zend_file_cache_open with struct

Author: iamacarpet

ext/opcache/zend_accelerator_module.c

@@ -380,11 +380,11 @@ static int filename_is_in_file_cache(zend_string *filename)
 	zend_stream_init_filename_ex(&handle, filename);
 	handle.opened_path = realpath;
 
-	bool result = zend_file_cache_script_validate(&handle);
+	zend_result result = zend_file_cache_script_validate(&handle);
 
 	zend_destroy_file_handle(&handle);
 
-	return result;
+	return result == SUCCESS;
 }
 
 

ext/opcache/zend_file_cache.c

@@ -1813,187 +1813,58 @@ static void zend_file_cache_unserialize(zend_persistent_script  *script,
 	zend_file_cache_unserialize_early_bindings(script, buf);
 }
 
-// Function to validate the file cache and return a boolean result
-bool zend_file_cache_script_validate(zend_file_handle *file_handle)
+zend_always_inline zend_result zend_file_cache_open(zend_file_handle *file_handle, zend_file_cache_handle *cache_handle)
 {
-    int fd;
-    char *filename;
-    zend_file_cache_metainfo info;
-    unsigned int actual_checksum;
-    void *mem, *checkpoint;
-
-    if (!file_handle || !file_handle->opened_path) {
-        return false;
-    }
-
-    filename = zend_file_cache_get_bin_file_path(file_handle->opened_path);
-    fd = zend_file_cache_open(filename, O_RDONLY | O_BINARY);
-    if (fd < 0) {
-        goto failure; // Open failed
-    }
-
-    if (zend_file_cache_flock(fd, LOCK_SH) != 0) {
-        goto failure_close; // Flock failed
-    }
-
-
-    if (read(fd, &info, sizeof(info)) != sizeof(info)) {
-        zend_accel_error(ACCEL_LOG_WARNING, "opcache cannot read from file '%s' (info)\n", filename);
-        goto failure_unlock_close;
-    }
-
-    // Verify header
-    if (memcmp(info.magic, "OPCACHE", 8) != 0 || memcmp(info.system_id, zend_system_id, 32) != 0) {
-        zend_accel_error(ACCEL_LOG_WARNING, "opcache invalid header in file '%s'\n", filename);
-        goto failure_unlock_close;
-    }
-
-    // Verify timestamp if required
-    if (ZCG(accel_directives).validate_timestamps &&
-        zend_get_file_handle_timestamp(file_handle, NULL) != info.timestamp) {
-        goto failure_unlock_close;
-    }
-
-    checkpoint = zend_arena_checkpoint(CG(arena));
-#if defined(__AVX__) || defined(__SSE2__)
-	/* Align to 64-byte boundary */
-	mem = zend_arena_alloc(&CG(arena), info.mem_size + info.str_size + 64);
-	mem = (void*)(((uintptr_t)mem + 63L) & ~63L);
-#else
-	mem = zend_arena_alloc(&CG(arena), info.mem_size + info.str_size);
-#endif
-
-	if (read(fd, mem, info.mem_size + info.str_size) != (ssize_t)(info.mem_size + info.str_size)) {
-		zend_accel_error(ACCEL_LOG_WARNING, "opcache cannot read from file '%s' (mem)\n", filename);
-		zend_arena_release(&CG(arena), checkpoint);
-		goto failure_unlock_close;
-	}
-	if (zend_file_cache_flock(fd, LOCK_UN) != 0) {
-		zend_accel_error(ACCEL_LOG_WARNING, "opcache cannot unlock file '%s'\n", filename);
-	}
-	close(fd);
-
-	/* verify checksum */
-	if (ZCG(accel_directives).file_cache_consistency_checks &&
-	    (actual_checksum = zend_adler32(ADLER32_INIT, mem, info.mem_size + info.str_size)) != info.checksum) {
-		zend_accel_error(ACCEL_LOG_WARNING, "corrupted file '%s' excepted checksum: 0x%08x actual checksum: 0x%08x\n", filename, info.checksum, actual_checksum);
-		zend_arena_release(&CG(arena), checkpoint);
-		goto failure;
-	}
-
-	zend_arena_release(&CG(arena), checkpoint);
-    efree(filename);
-    return true; // Validation successful
-
-failure_unlock_close:
-    zend_file_cache_flock(fd, LOCK_UN);
-failure_close:
-    close(fd);
-failure:
-    if (!ZCG(accel_directives).file_cache_read_only) {
-        zend_file_cache_unlink(filename);
-    }
-    efree(filename);
-
-    return false; // Validation failed
-}
-
-zend_persistent_script *zend_file_cache_script_load(zend_file_handle *file_handle)
-{
-	zend_string *full_path = file_handle->opened_path;
 	int fd;
 	char *filename;
-	zend_persistent_script *script;
-	zend_file_cache_metainfo info;
-	zend_accel_hash_entry *bucket;
-	void *mem, *checkpoint, *buf;
-	bool cache_it = true;
 	unsigned int actual_checksum;
-	bool ok;
 
-	if (!full_path) {
-		return NULL;
+	if (!file_handle || !file_handle->opened_path) {
+		return FAILURE;
 	}
-	filename = zend_file_cache_get_bin_file_path(full_path);
+	zend_file_cache_handle->full_path = file_handle->opened_path
 
+	filename = zend_file_cache_get_bin_file_path(zend_file_cache_handle->full_path);
 	fd = zend_file_cache_open(filename, O_RDONLY | O_BINARY);
 	if (fd < 0) {
-		efree(filename);
-		return NULL;
+		goto failure; // Open failed
 	}
 
 	if (zend_file_cache_flock(fd, LOCK_SH) != 0) {
-		close(fd);
-		efree(filename);
-		return NULL;
+		goto failure_close; // Flock failed
 	}
 
-	if (read(fd, &info, sizeof(info)) != sizeof(info)) {
+
+	if (read(fd, &zend_file_cache_handle->info, sizeof(zend_file_cache_handle->info)) != sizeof(zend_file_cache_handle->info)) {
 		zend_accel_error(ACCEL_LOG_WARNING, "opcache cannot read from file '%s' (info)\n", filename);
-		zend_file_cache_flock(fd, LOCK_UN);
-		close(fd);
-		if (!ZCG(accel_directives).file_cache_read_only) {
-			zend_file_cache_unlink(filename);
-		}
-		efree(filename);
-		return NULL;
+		goto failure_unlock_close;
 	}
 
-	/* verify header */
-	if (memcmp(info.magic, "OPCACHE", 8) != 0) {
-		zend_accel_error(ACCEL_LOG_WARNING, "opcache cannot read from file '%s' (wrong header)\n", filename);
-		zend_file_cache_flock(fd, LOCK_UN);
-		close(fd);
-		if (!ZCG(accel_directives).file_cache_read_only) {
-			zend_file_cache_unlink(filename);
-		}
-		efree(filename);
-		return NULL;
-	}
-	if (memcmp(info.system_id, zend_system_id, 32) != 0) {
-		zend_accel_error(ACCEL_LOG_WARNING, "opcache cannot read from file '%s' (wrong \"system_id\")\n", filename);
-		zend_file_cache_flock(fd, LOCK_UN);
-		close(fd);
-		if (!ZCG(accel_directives).file_cache_read_only) {
-			zend_file_cache_unlink(filename);
-		}
-		efree(filename);
-		return NULL;
+	// Verify header
+	if (memcmp(zend_file_cache_handle->info.magic, "OPCACHE", 8) != 0 || memcmp(zend_file_cache_handle->info.system_id, zend_system_id, 32) != 0) {
+		zend_accel_error(ACCEL_LOG_WARNING, "opcache invalid header in file '%s'\n", filename);
+		goto failure_unlock_close;
 	}
 
-	/* verify timestamp */
+	// Verify timestamp if required
 	if (ZCG(accel_directives).validate_timestamps &&
-	    zend_get_file_handle_timestamp(file_handle, NULL) != info.timestamp) {
-		if (zend_file_cache_flock(fd, LOCK_UN) != 0) {
-			zend_accel_error(ACCEL_LOG_WARNING, "opcache cannot unlock file '%s'\n", filename);
-		}
-		close(fd);
-		if (!ZCG(accel_directives).file_cache_read_only) {
-			zend_file_cache_unlink(filename);
-		}
-		efree(filename);
-		return NULL;
+		zend_get_file_handle_timestamp(file_handle, NULL) != zend_file_cache_handle->info.timestamp) {
+		goto failure_unlock_close;
 	}
 
-	checkpoint = zend_arena_checkpoint(CG(arena));
+	zend_file_cache_handle->checkpoint = zend_arena_checkpoint(CG(arena));
 #if defined(__AVX__) || defined(__SSE2__)
 	/* Align to 64-byte boundary */
-	mem = zend_arena_alloc(&CG(arena), info.mem_size + info.str_size + 64);
-	mem = (void*)(((uintptr_t)mem + 63L) & ~63L);
+	zend_file_cache_handle->mem = zend_arena_alloc(&CG(arena), zend_file_cache_handle->info.mem_size + zend_file_cache_handle->info.str_size + 64);
+	zend_file_cache_handle->mem = (void*)(((uintptr_t)zend_file_cache_handle->mem + 63L) & ~63L);
 #else
-	mem = zend_arena_alloc(&CG(arena), info.mem_size + info.str_size);
+	zend_file_cache_handle->mem = zend_arena_alloc(&CG(arena), zend_file_cache_handle->info.mem_size + zend_file_cache_handle->info.str_size);
 #endif
 
-	if (read(fd, mem, info.mem_size + info.str_size) != (ssize_t)(info.mem_size + info.str_size)) {
+	if (read(fd, zend_file_cache_handle->mem, zend_file_cache_handle->info.mem_size + zend_file_cache_handle->info.str_size) != (ssize_t)(zend_file_cache_handle->info.mem_size + zend_file_cache_handle->info.str_size)) {
 		zend_accel_error(ACCEL_LOG_WARNING, "opcache cannot read from file '%s' (mem)\n", filename);
-		zend_file_cache_flock(fd, LOCK_UN);
-		close(fd);
-		if (!ZCG(accel_directives).file_cache_read_only) {
-			zend_file_cache_unlink(filename);
-		}
-		zend_arena_release(&CG(arena), checkpoint);
-		efree(filename);
-		return NULL;
+		zend_arena_release(&CG(arena), zend_file_cache_handle->checkpoint);
+		goto failure_unlock_close;
 	}
 	if (zend_file_cache_flock(fd, LOCK_UN) != 0) {
 		zend_accel_error(ACCEL_LOG_WARNING, "opcache cannot unlock file '%s'\n", filename);
@@ -2002,13 +1873,56 @@ zend_persistent_script *zend_file_cache_script_load(zend_file_handle *file_handl
 
 	/* verify checksum */
 	if (ZCG(accel_directives).file_cache_consistency_checks &&
-	    (actual_checksum = zend_adler32(ADLER32_INIT, mem, info.mem_size + info.str_size)) != info.checksum) {
-		zend_accel_error(ACCEL_LOG_WARNING, "corrupted file '%s' excepted checksum: 0x%08x actual checksum: 0x%08x\n", filename, info.checksum, actual_checksum);
-		if (!ZCG(accel_directives).file_cache_read_only) {
-			zend_file_cache_unlink(filename);
-		}
-		zend_arena_release(&CG(arena), checkpoint);
-		efree(filename);
+		(actual_checksum = zend_adler32(ADLER32_INIT, zend_file_cache_handle->mem, zend_file_cache_handle->info.mem_size + zend_file_cache_handle->info.str_size)) != zend_file_cache_handle->info.checksum) {
+		zend_accel_error(ACCEL_LOG_WARNING, "corrupted file '%s' excepted checksum: 0x%08x actual checksum: 0x%08x\n", filename, zend_file_cache_handle->info.checksum, actual_checksum);
+		zend_arena_release(&CG(arena), zend_file_cache_handle->checkpoint);
+		goto failure;
+	}
+
+	efree(filename);
+	return SUCCESS;
+
+failure_unlock_close:
+	zend_file_cache_flock(fd, LOCK_UN);
+failure_close:
+	close(fd);
+failure:
+	if (!ZCG(accel_directives).file_cache_read_only) {
+		zend_file_cache_unlink(filename);
+	}
+	efree(filename);
+
+	return FAILURE;
+}
+
+zend_always_inline void zend_file_cache_close(zend_file_cache_handle *cache_handle)
+{
+	zend_arena_release(&CG(arena), zend_file_cache_handle->checkpoint);
+}
+
+zend_result zend_file_cache_validate(zend_file_handle *file_handle)
+{
+	zend_file_cache_handle cache_handle;
+
+	zend_result ret = zend_file_cache_open(file_handle, &cache_handle);
+
+	if (res == SUCCESS) {
+		zend_file_cache_close(&cache_handle);
+	}
+
+	return ret;
+}
+
+zend_persistent_script *zend_file_cache_script_load(zend_file_handle *file_handle)
+{
+	zend_file_cache_handle cache_handle;
+	zend_persistent_script *script;
+	zend_accel_hash_entry *bucket;
+	void *buf;
+	bool cache_it = true;
+	bool ok;
+
+	if (zend_file_cache_open(file_handle, &cache_handle) == FAILURE) {
 		return NULL;
 	}
 
@@ -2023,13 +1937,12 @@ zend_persistent_script *zend_file_cache_script_load(zend_file_handle *file_handl
 		/* Check if we still need to put the file into the cache (may be it was
 		 * already stored by another process. This final check is done under
 		 * exclusive lock) */
-		bucket = zend_accel_hash_find_entry(&ZCSG(hash), full_path);
+		bucket = zend_accel_hash_find_entry(&ZCSG(hash), cache_handle->full_path);
 		if (bucket) {
 			script = (zend_persistent_script *)bucket->data;
 			if (!script->corrupted) {
 				zend_shared_alloc_unlock();
-				zend_arena_release(&CG(arena), checkpoint);
-				efree(filename);
+				zend_file_cache_close(&cache_handle);
 				return script;
 			}
 		}
@@ -2042,23 +1955,23 @@ zend_persistent_script *zend_file_cache_script_load(zend_file_handle *file_handl
 			goto use_process_mem;
 		}
 
-		buf = zend_shared_alloc_aligned(info.mem_size);
+		buf = zend_shared_alloc_aligned(cache_handle->info.mem_size);
 
 		if (!buf) {
 			zend_accel_schedule_restart_if_necessary(ACCEL_RESTART_OOM);
 			zend_shared_alloc_unlock();
 			goto use_process_mem;
 		}
-		memcpy(buf, mem, info.mem_size);
+		memcpy(buf, cache_handle->mem, cache_handle->info.mem_size);
 		zend_map_ptr_extend(ZCSG(map_ptr_last));
 	} else {
 use_process_mem:
-		buf = mem;
+		buf = cache_handle->mem;
 		cache_it = false;
 	}
 
-	ZCG(mem) = ((char*)mem + info.mem_size);
-	script = (zend_persistent_script*)((char*)buf + info.script_offset);
+	ZCG(cache_handle->mem) = ((char*)cache_handle->mem + cache_handle->info.mem_size);
+	script = (zend_persistent_script*)((char*)buf + cache_handle->info.script_offset);
 	script->corrupted = !cache_it; /* used to check if script restored to SHM or process memory */
 
 	ok = true;
@@ -2072,8 +1985,7 @@ zend_persistent_script *zend_file_cache_script_load(zend_file_handle *file_handl
 			zend_shared_alloc_unlock();
 			goto use_process_mem;
 		} else {
-			zend_arena_release(&CG(arena), checkpoint);
-			efree(filename);
+			zend_file_cache_close(&cache_handle);
 			return NULL;
 		}
 	}
@@ -2089,9 +2001,8 @@ zend_persistent_script *zend_file_cache_script_load(zend_file_handle *file_handl
 		zend_shared_alloc_unlock();
 		zend_accel_error(ACCEL_LOG_INFO, "File cached script loaded into memory '%s'", ZSTR_VAL(script->script.filename));
 
-		zend_arena_release(&CG(arena), checkpoint);
+		zend_file_cache_close(&cache_handle);
 	}
-	efree(filename);
 
 	return script;
 }

ext/opcache/zend_file_cache.h

@@ -19,8 +19,16 @@
 #ifndef ZEND_FILE_CACHE_H
 #define ZEND_FILE_CACHE_H
 
+typedef struct _zend_file_cache_handle {
+	zend_string *full_path;
+	zend_file_cache_metainfo info;
+	void *mem, *checkpoint;
+} zend_file_cache_handle;
+
 int zend_file_cache_script_store(zend_persistent_script *script, bool in_shm);
-bool zend_file_cache_script_validate(zend_file_handle *file_handle);
+zend_always_inline zend_result zend_file_cache_open(zend_file_handle *file_handle, zend_file_cache_handle *cache_handle);
+zend_always_inline void zend_file_cache_close(zend_file_cache_handle *cache_handle);
+zend_result zend_file_cache_validate(zend_file_handle *file_handle);
 zend_persistent_script *zend_file_cache_script_load(zend_file_handle *file_handle);
 void zend_file_cache_invalidate(zend_string *full_path);