c/main: More propagate errors

src/xrt/compositor/main/comp_mirror_to_debug_gui.c

···
  * @ingroup comp_main
  */
 
+#include "xrt/xrt_results.h"
 #include "math/m_mathinclude.h"
 #include "main/comp_mirror_to_debug_gui.h"
 
···
 	return true;
 }
 
-void
+XRT_CHECK_RESULT xrt_result_t
 comp_mirror_do_blit(struct comp_mirror_to_debug_gui *m,
                     struct vk_bundle *vk,
                     uint64_t frame_id,
···
 	struct vk_image_readback_to_xf *wrap = NULL;
 
 	if (!vk_image_readback_to_xf_pool_get_unused_frame(vk, m->pool, &wrap)) {
-		return;
+		return XRT_ERROR_VULKAN;
 	}
 
 	if (!ensure_scratch(m, vk)) {
-		return;
+		return XRT_ERROR_VULKAN;
 	}
 
 	VkDescriptorSet descriptor_set = VK_NULL_HANDLE;
···
 	    &descriptor_set);              // descriptor_set
 	if (ret != VK_SUCCESS) {
 		VK_ERROR(vk, "vk_create_descriptor_set: %s", vk_result_string(ret));
-		return;
+		return XRT_ERROR_VULKAN;
 	}
 
 	VK_NAME_DESCRIPTOR_SET(vk, descriptor_set, "comp_mirror_to_debug_ui blit descriptor set");
···
 	if (ret != VK_SUCCESS) {
 		vk->vkResetDescriptorPool(vk->device, m->blit.descriptor_pool, 0);
 		vk_cmd_pool_unlock(pool);
-		return;
+		return XRT_ERROR_VULKAN;
 	}
 
 	VK_NAME_COMMAND_BUFFER(vk, cmd, "comp_mirror_to_debug_ui command buffer");
···
 	if (ret != VK_SUCCESS) {
 		//! @todo Better handling of error?
 		VK_ERROR(vk, "vk_cmd_pool_end_submit_wait_and_free_cmd_buffer_locked: %s", vk_result_string(ret));
+		return XRT_ERROR_VULKAN;
 	}
 
 	wrap->base_frame.source_timestamp = wrap->base_frame.timestamp = predicted_display_time_ns;
···
 
 	// Tidies the descriptor we created.
 	vk->vkResetDescriptorPool(vk->device, m->blit.descriptor_pool, 0);
+	return XRT_ERROR_VULKAN;
 }
 
 void

src/xrt/compositor/main/comp_mirror_to_debug_gui.h

···
  */
 #pragma once
 
+#include "xrt/xrt_compiler.h"
+#include "xrt/xrt_results.h"
 #include "util/u_sink.h"
 #include "vk/vk_image_readback_to_xf_pool.h"
+
 #include "main/comp_compositor.h"
 
 
···
  *
  * @public @memberof comp_mirror_to_debug_gui
  */
-void
+XRT_CHECK_RESULT xrt_result_t
 comp_mirror_do_blit(struct comp_mirror_to_debug_gui *m,
                     struct vk_bundle *vk,
                     uint64_t frame_id,

src/xrt/compositor/main/comp_renderer.c

···
 #include "xrt/xrt_defines.h"
 #include "xrt/xrt_frame.h"
 #include "xrt/xrt_compositor.h"
+#include "xrt/xrt_results.h"
 
 #include "os/os_time.h"
 
···
 	r->fenced_buffer = -1;
 }
 
-static void
+static XRT_CHECK_RESULT VkResult
 renderer_submit_queue(struct comp_renderer *r, VkCommandBuffer cmd, VkPipelineStageFlags pipeline_stage_flag)
 {
 	COMP_TRACE_MARKER();
···
 	ret = vk->vkResetFences(vk->device, 1, &r->fences[r->acquired_buffer]);
 	if (ret != VK_SUCCESS) {
 		COMP_ERROR(r->c, "vkResetFences: %s", vk_result_string(ret));
+		return ret;
 	}
 
 
···
 	ret = vk_cmd_submit_locked(vk, 1, &comp_submit_info, r->fences[r->acquired_buffer]);
 	if (ret != VK_SUCCESS) {
 		COMP_ERROR(r->c, "vkQueueSubmit: %s", vk_result_string(ret));
+		return ret;
 	}
 
 	// This buffer now have a pending fence.
 	r->fenced_buffer = r->acquired_buffer;
+	return ret;
 }
 
 static void
···
 /*!
  * @pre render_gfx_init(rr, &c->nr)
  */
-static void
+static XRT_CHECK_RESULT VkResult
 dispatch_graphics(struct comp_renderer *r, struct render_gfx *rr)
 {
 	COMP_TRACE_MARKER();
···
 	render_gfx_begin(rr);
 
 
+	VkResult ret = VK_SUCCESS;
+
 	comp_render_gfx_dispatch(     //
 	    rr,                       // rr
 	    &r->scratch,              // rsi
···
 	render_gfx_end(rr);
 
 	// Everything is ready, submit to the queue.
-	renderer_submit_queue(r, rr->r->cmd, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT);
+	ret = renderer_submit_queue(r, rr->r->cmd, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT);
 
 	// We mark afterwards to not include CPU time spent.
 	comp_target_mark_submit(ct, c->frame.rendering.id, os_monotonic_get_ns());
+
+	return ret;
 }
 
 
···
 /*!
  * @pre render_compute_init(crc, &c->nr)
  */
-static void
+static XRT_CHECK_RESULT VkResult
 dispatch_compute(struct comp_renderer *r, struct render_compute *crc)
 {
 	COMP_TRACE_MARKER();
···
 
 	comp_target_mark_submit(ct, c->frame.rendering.id, os_monotonic_get_ns());
 
-	renderer_submit_queue(r, crc->r->cmd, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
+	return renderer_submit_queue(r, crc->r->cmd, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
 }
 
 
···
  *
  */
 
-void
+XRT_CHECK_RESULT xrt_result_t
 comp_renderer_draw(struct comp_renderer *r)
 {
 	COMP_TRACE_MARKER();
···
 
 		// Clear the rendering frame.
 		comp_frame_clear_locked(&c->frame.rendering);
-		return;
+		return XRT_SUCCESS;
 	}
 
 	comp_target_flush(ct);
···
 	bool use_compute = r->settings->use_compute;
 	struct render_gfx rr = {0};
 	struct render_compute crc = {0};
+
+	VkResult res = VK_SUCCESS;
 	if (use_compute) {
 		render_compute_init(&crc, &c->nr);
-		dispatch_compute(r, &crc);
+		res = dispatch_compute(r, &crc);
 	} else {
 		render_gfx_init(&rr, &c->nr);
-		dispatch_graphics(r, &rr);
+		res = dispatch_graphics(r, &rr);
+	}
+	if (res != VK_SUCCESS) {
+		return XRT_ERROR_VULKAN;
 	}
 
 #ifdef XRT_FEATURE_WINDOW_PEEK
···
 	// Clear the rendered frame.
 	comp_frame_clear_locked(&c->frame.rendering);
 
+	xrt_result_t xret = XRT_SUCCESS;
 	comp_mirror_fixup_ui_state(&r->mirror_to_debug_gui, c);
 	if (comp_mirror_is_ready_and_active(&r->mirror_to_debug_gui, c, predicted_display_time_ns)) {
 
···
 		// Covers the whole view.
 		struct xrt_normalized_rect rect = {0, 0, 1.0f, 1.0f};
 
-		comp_mirror_do_blit(               //
+		xret = comp_mirror_do_blit(        //
 		    &r->mirror_to_debug_gui,       //
 		    &c->base.vk,                   //
 		    frame_id,                      //
···
 	 */
 	renderer_wait_queue_idle(r);
 
-
-	/*
-	 * Get timestamps of GPU work (if available).
-	 */
+	if (xret == XRT_SUCCESS) {
+		/*
+		 * Get timestamps of GPU work (if available).
+		 */
 
-	uint64_t gpu_start_ns, gpu_end_ns;
-	if (render_resources_get_timestamps(&c->nr, &gpu_start_ns, &gpu_end_ns)) {
-		uint64_t now_ns = os_monotonic_get_ns();
-		comp_target_info_gpu(ct, frame_id, gpu_start_ns, gpu_end_ns, now_ns);
+		uint64_t gpu_start_ns, gpu_end_ns;
+		if (render_resources_get_timestamps(&c->nr, &gpu_start_ns, &gpu_end_ns)) {
+			uint64_t now_ns = os_monotonic_get_ns();
+			comp_target_info_gpu(ct, frame_id, gpu_start_ns, gpu_end_ns, now_ns);
+		}
 	}
 
 
···
 	}
 
 	comp_target_update_timings(ct);
+
+	return xret;
 }
 
 struct comp_renderer *

src/xrt/compositor/main/comp_renderer.h

···
  * @public @memberof comp_renderer
  * @ingroup comp_main
  */
-void
+XRT_CHECK_RESULT xrt_result_t
 comp_renderer_draw(struct comp_renderer *r);
 
 void