radv: allow the secure process to read and write from disk cache

This allows the secure process to read and write to the disk cache
via the parent process. This commit just adds the functionality
needed for the secure process, the following commit will add the
functionality for the parent process.

Reviewed-by: Bas Nieuwenhuizen <bas@basnieuwenhuizen.nl>

diff --git a/src/amd/vulkan/radv_pipeline_cache.c b/src/amd/vulkan/radv_pipeline_cache.c
index 031d910550c3373bed037b9bff85867607067a8d..8ec1d66e9f1aba15478482f5f4393ff0812856eb 100644 (file)
--- a/src/amd/vulkan/radv_pipeline_cache.c
+++ b/src/amd/vulkan/radv_pipeline_cache.c
@@ -243,6 +243,63 @@ radv_is_cache_disabled(struct radv_device *device)
        return (device->instance->debug_flags & RADV_DEBUG_NO_CACHE);
 }
 
+/*
+ * Secure compiles cannot open files so we get the parent process to load the
+ * cache entry for us.
+ */
+static struct cache_entry *
+radv_sc_read_from_disk_cache(struct radv_device *device, uint8_t *disk_sha1)
+{
+       struct cache_entry *entry;
+       unsigned process = device->sc_state->secure_compile_thread_counter;
+       enum radv_secure_compile_type sc_type = RADV_SC_TYPE_READ_DISK_CACHE;
+
+       write(device->sc_state->secure_compile_processes[process].fd_secure_output,
+             &sc_type, sizeof(enum radv_secure_compile_type));
+       write(device->sc_state->secure_compile_processes[process].fd_secure_output,
+             disk_sha1, sizeof(uint8_t) * 20);
+
+       uint8_t found_cache_entry;
+       read(device->sc_state->secure_compile_processes[process].fd_secure_input,
+            &found_cache_entry, sizeof(uint8_t));
+
+       if (found_cache_entry) {
+               size_t entry_size;
+               read(device->sc_state->secure_compile_processes[process].fd_secure_input,
+                    &entry_size, sizeof(size_t));
+
+               entry = malloc(entry_size);
+               read(device->sc_state->secure_compile_processes[process].fd_secure_input,
+                    entry, entry_size);
+               return entry;
+       }
+
+       return NULL;
+}
+
+/*
+ * Secure compiles cannot open files so we get the parent process to write to
+ * the disk cache for us.
+ */
+static void
+radv_sc_write_to_disk_cache(struct radv_device *device, uint8_t *disk_sha1,
+                           struct cache_entry *entry)
+{
+       unsigned process = device->sc_state->secure_compile_thread_counter;
+       enum radv_secure_compile_type sc_type = RADV_SC_TYPE_WRITE_DISK_CACHE;
+
+       write(device->sc_state->secure_compile_processes[process].fd_secure_output,
+             &sc_type, sizeof(enum radv_secure_compile_type));
+       write(device->sc_state->secure_compile_processes[process].fd_secure_output,
+             disk_sha1, sizeof(uint8_t) * 20);
+
+       uint32_t size = entry_size(entry);
+       write(device->sc_state->secure_compile_processes[process].fd_secure_output,
+             &size, sizeof(uint32_t));
+       write(device->sc_state->secure_compile_processes[process].fd_secure_output,
+             entry, size);
+}
+
 bool
 radv_create_shader_variants_from_pipeline_cache(struct radv_device *device,
                                                struct radv_pipeline_cache *cache,
@@ -275,9 +332,15 @@ radv_create_shader_variants_from_pipeline_cache(struct radv_device *device,
                uint8_t disk_sha1[20];
                disk_cache_compute_key(device->physical_device->disk_cache,
                                       sha1, 20, disk_sha1);
-               entry = (struct cache_entry *)
-                       disk_cache_get(device->physical_device->disk_cache,
-                                      disk_sha1, NULL);
+
+               if (radv_device_use_secure_compile(device->instance)) {
+                       entry = radv_sc_read_from_disk_cache(device, disk_sha1);
+               } else {
+                       entry = (struct cache_entry *)
+                               disk_cache_get(device->physical_device->disk_cache,
+                                              disk_sha1, NULL);
+               }
+
                if (!entry) {
                        pthread_mutex_unlock(&cache->mutex);
                        return false;
@@ -402,8 +465,17 @@ radv_pipeline_cache_insert_shaders(struct radv_device *device,
                uint8_t disk_sha1[20];
                disk_cache_compute_key(device->physical_device->disk_cache, sha1, 20,
                               disk_sha1);
-               disk_cache_put(device->physical_device->disk_cache,
-                              disk_sha1, entry, entry_size(entry), NULL);
+
+               /* Write the cache item out to the parent of this forked
+                * process.
+                */
+               if (radv_device_use_secure_compile(device->instance)) {
+                       radv_sc_write_to_disk_cache(device, disk_sha1, entry);
+               } else {
+                       disk_cache_put(device->physical_device->disk_cache,
+                                      disk_sha1, entry, entry_size(entry),
+                                      NULL);
+               }
        }
 
        if (device->instance->debug_flags & RADV_DEBUG_NO_MEMORY_CACHE &&