runtime/driver: refine error handlings.

We should always check whether a dri_bo_map success or fail.

Signed-off-by: Zhigang Gong <zhigang.gong@intel.com>
Reviewed-by: Yang Rong <rong.r.yang@intel.com>

5 files changed, 91 insertions, 40 deletions

diff --git a/src/cl_command_queue_gen7.c b/src/cl_command_queue_gen7.c
index 5b80d746..58ecc5a2 100644
--- a/src/cl_command_queue_gen7.c
+++ b/src/cl_command_queue_gen7.c
@@ -96,7 +96,7 @@ error:
   return err;
 }
 
-static void
+static int
 cl_upload_constant_buffer(cl_command_queue queue, cl_kernel ker)
 {
   /* calculate constant buffer size
@@ -125,11 +125,15 @@ cl_upload_constant_buffer(cl_command_queue queue, cl_kernel ker)
     }
   }
   if(raw_size == 0)
-     return;
+     return 0;
 
   cl_buffer bo = cl_gpgpu_alloc_constant_buffer(gpgpu, aligned_size);
+  if (bo == NULL)
+    return -1;
   cl_buffer_map(bo, 1);
   char * cst_addr = cl_buffer_get_virtual(bo);
+  if (cst_addr == NULL)
+    return -1;
 
   /* upload the global constant data */
   if (global_const_size > 0) {
@@ -162,6 +166,7 @@ cl_upload_constant_buffer(cl_command_queue queue, cl_kernel ker)
     }
   }
   cl_buffer_unmap(bo);
+  return 0;
 }
 
 /* Will return the total amount of slm used */
@@ -254,19 +259,24 @@ cl_bind_stack(cl_gpgpu gpgpu, cl_kernel ker)
   cl_gpgpu_set_stack(gpgpu, offset, stack_sz, cl_gpgpu_get_cache_ctrl());
 }
 
-static void
+static int
 cl_bind_printf(cl_gpgpu gpgpu, cl_kernel ker, void* printf_info, int printf_num, size_t global_sz) {
   int32_t value = GBE_CURBE_PRINTF_INDEX_POINTER;
   int32_t offset = interp_kernel_get_curbe_offset(ker->opaque, value, 0);
   size_t buf_size = global_sz * sizeof(int) * printf_num;
-  if (offset > 0)
-    cl_gpgpu_set_printf_buffer(gpgpu, 0, buf_size, offset);
+  if (offset > 0) {
+    if (cl_gpgpu_set_printf_buffer(gpgpu, 0, buf_size, offset) != 0)
+      return -1;
+  }
 
   value = GBE_CURBE_PRINTF_BUF_POINTER;
   offset = interp_kernel_get_curbe_offset(ker->opaque, value, 0);
   buf_size = interp_get_printf_sizeof_size(printf_info) * global_sz;
-  if (offset > 0)
-    cl_gpgpu_set_printf_buffer(gpgpu, 1, buf_size, offset);
+  if (offset > 0) {
+    if (cl_gpgpu_set_printf_buffer(gpgpu, 1, buf_size, offset) != 0)
+      return -1;
+  }
+  return 0;
 }
 
 LOCAL cl_int
@@ -322,13 +332,15 @@ cl_command_queue_ND_range_gen7(cl_command_queue queue,
 
   /* Setup the kernel */
   if (queue->props & CL_QUEUE_PROFILING_ENABLE)
-    cl_gpgpu_state_init(gpgpu, ctx->device->max_compute_unit * ctx->device->max_thread_per_unit, cst_sz / 32, 1);
+    err = cl_gpgpu_state_init(gpgpu, ctx->device->max_compute_unit * ctx->device->max_thread_per_unit, cst_sz / 32, 1);
   else
-    cl_gpgpu_state_init(gpgpu, ctx->device->max_compute_unit * ctx->device->max_thread_per_unit, cst_sz / 32, 0);
-
+    err = cl_gpgpu_state_init(gpgpu, ctx->device->max_compute_unit * ctx->device->max_thread_per_unit, cst_sz / 32, 0);
+  if (err != 0)
+    goto error;
   printf_num = interp_get_printf_num(printf_info);
   if (printf_num) {
-    cl_bind_printf(gpgpu, ker, printf_info, printf_num, global_size);
+    if (cl_bind_printf(gpgpu, ker, printf_info, printf_num, global_size) != 0)
+      goto error;
   }
 
   /* Bind user buffers */
@@ -338,12 +350,14 @@ cl_command_queue_ND_range_gen7(cl_command_queue queue,
   /* Bind all samplers */
   cl_gpgpu_bind_sampler(gpgpu, ker->samplers, ker->sampler_sz);
 
-  cl_gpgpu_set_scratch(gpgpu, scratch_sz);
+  if (cl_gpgpu_set_scratch(gpgpu, scratch_sz) != 0)
+    goto error;
 
   /* Bind a stack if needed */
   cl_bind_stack(gpgpu, ker);
 
-  cl_upload_constant_buffer(queue, ker);
+  if (cl_upload_constant_buffer(queue, ker) != 0)
+    goto error;
 
   cl_gpgpu_states_setup(gpgpu, &kernel);
 
@@ -355,12 +369,14 @@ cl_command_queue_ND_range_gen7(cl_command_queue queue,
         memcpy(final_curbe + cst_sz * i, ker->curbe, cst_sz);
     }
     TRY (cl_set_varying_payload, ker, final_curbe, local_wk_sz, simd_sz, cst_sz, thread_n);
-    cl_gpgpu_upload_curbes(gpgpu, final_curbe, thread_n*cst_sz);
+    if (cl_gpgpu_upload_curbes(gpgpu, final_curbe, thread_n*cst_sz) != 0)
+      goto error;
   }
 
   /* Start a new batch buffer */
   batch_sz = cl_kernel_compute_batch_sz(ker);
-  cl_gpgpu_batch_reset(gpgpu, batch_sz);
+  if (cl_gpgpu_batch_reset(gpgpu, batch_sz) != 0)
+    goto error;
   cl_set_thread_batch_buf(queue, cl_gpgpu_ref_batch_buf(gpgpu));
   cl_gpgpu_batch_start(gpgpu);
 
@@ -369,7 +385,11 @@ cl_command_queue_ND_range_gen7(cl_command_queue queue,
 
   /* Close the batch buffer and submit it */
   cl_gpgpu_batch_end(gpgpu, 0);
+  return CL_SUCCESS;
+
 error:
-  return err;
+  fprintf(stderr, "error occured. \n");
+  exit(-1);
+  return CL_OUT_OF_RESOURCES;
 }
 
diff --git a/src/cl_driver.h b/src/cl_driver.h
index 3d1d8d87..374813a5 100644
--- a/src/cl_driver.h
+++ b/src/cl_driver.h
@@ -143,11 +143,11 @@ typedef void (cl_gpgpu_set_stack_cb)(cl_gpgpu, uint32_t offset, uint32_t size, u
 extern cl_gpgpu_set_stack_cb *cl_gpgpu_set_stack;
 
 /* Setup scratch */
-typedef void (cl_gpgpu_set_scratch_cb)(cl_gpgpu, uint32_t per_thread_size);
+typedef int (cl_gpgpu_set_scratch_cb)(cl_gpgpu, uint32_t per_thread_size);
 extern cl_gpgpu_set_scratch_cb *cl_gpgpu_set_scratch;
 
 /* Configure internal state */
-typedef void (cl_gpgpu_state_init_cb)(cl_gpgpu, uint32_t max_threads, uint32_t size_cs_entry, int profiling);
+typedef int (cl_gpgpu_state_init_cb)(cl_gpgpu, uint32_t max_threads, uint32_t size_cs_entry, int profiling);
 extern cl_gpgpu_state_init_cb *cl_gpgpu_state_init;
 
 /* Set the buffer object where to report performance counters */
@@ -155,7 +155,7 @@ typedef void (cl_gpgpu_set_perf_counters_cb)(cl_gpgpu, cl_buffer perf);
 extern cl_gpgpu_set_perf_counters_cb *cl_gpgpu_set_perf_counters;
 
 /* Fills current curbe buffer with data */
-typedef void (cl_gpgpu_upload_curbes_cb)(cl_gpgpu, const void* data, uint32_t size);
+typedef int (cl_gpgpu_upload_curbes_cb)(cl_gpgpu, const void* data, uint32_t size);
 extern cl_gpgpu_upload_curbes_cb *cl_gpgpu_upload_curbes;
 
 typedef cl_buffer (cl_gpgpu_alloc_constant_buffer_cb)(cl_gpgpu, uint32_t size);
@@ -174,7 +174,7 @@ typedef void (cl_gpgpu_set_sampler_cb)(cl_gpgpu, uint32_t index, uint32_t non_no
 extern cl_gpgpu_set_sampler_cb *cl_gpgpu_set_sampler;
 
 /* Allocate the batch buffer and return the BO used for the batch buffer */
-typedef void (cl_gpgpu_batch_reset_cb)(cl_gpgpu, size_t sz);
+typedef int (cl_gpgpu_batch_reset_cb)(cl_gpgpu, size_t sz);
 extern cl_gpgpu_batch_reset_cb *cl_gpgpu_batch_reset;
 
 /* Atomic begin, pipeline select, urb, pipeline state and constant buffer */
@@ -226,7 +226,7 @@ typedef void (cl_gpgpu_unref_batch_buf_cb)(void*);
 extern cl_gpgpu_unref_batch_buf_cb *cl_gpgpu_unref_batch_buf;
 
 /* Set the printf buffer */
-typedef void (cl_gpgpu_set_printf_buffer_cb)(cl_gpgpu, uint32_t, uint32_t, uint32_t);
+typedef int (cl_gpgpu_set_printf_buffer_cb)(cl_gpgpu, uint32_t, uint32_t, uint32_t);
 extern cl_gpgpu_set_printf_buffer_cb *cl_gpgpu_set_printf_buffer;
 
 /* get the printf buffer offset in the apeture*/
@@ -246,7 +246,7 @@ typedef unsigned long (cl_gpgpu_release_printf_buffer_cb)(cl_gpgpu, uint32_t);
 extern cl_gpgpu_release_printf_buffer_cb *cl_gpgpu_release_printf_buffer;
 
 /* Set the last printfset pointer */
-typedef void (cl_gpgpu_set_printf_info_cb)(cl_gpgpu, void *, size_t*);
+typedef int (cl_gpgpu_set_printf_info_cb)(cl_gpgpu, void *, size_t*);
 extern cl_gpgpu_set_printf_info_cb *cl_gpgpu_set_printf_info;
 
 /* Get the last printfset pointer */
diff --git a/src/intel/intel_batchbuffer.c b/src/intel/intel_batchbuffer.c
index 7767db3e..d3da3cc6 100644
--- a/src/intel/intel_batchbuffer.c
+++ b/src/intel/intel_batchbuffer.c
@@ -53,7 +53,7 @@
 #include <string.h>
 #include <assert.h>
 
-LOCAL void
+LOCAL int
 intel_batchbuffer_reset(intel_batchbuffer_t *batch, size_t sz)
 {
   if (batch->buffer != NULL) {
@@ -66,15 +66,19 @@ intel_batchbuffer_reset(intel_batchbuffer_t *batch, size_t sz)
                                "batch buffer",
                                sz,
                                64);
-  assert(batch->buffer);
-
-  dri_bo_map(batch->buffer, 1);
+  if (!batch->buffer || (dri_bo_map(batch->buffer, 1) != 0)) {
+    if (batch->buffer)
+      dri_bo_unreference(batch->buffer);
+    batch->buffer = NULL;
+    return -1;
+  }
   batch->map = (uint8_t*) batch->buffer->virtual;
   batch->size = sz;
   batch->ptr = batch->map;
   batch->atomic = 0;
   batch->last_bo = batch->buffer;
   batch->enable_slm = 0;
+  return 0;
 }
 
 LOCAL void
diff --git a/src/intel/intel_batchbuffer.h b/src/intel/intel_batchbuffer.h
index 0c3bc13e..4c28a7c7 100644
--- a/src/intel/intel_batchbuffer.h
+++ b/src/intel/intel_batchbuffer.h
@@ -100,7 +100,7 @@ extern void intel_batchbuffer_emit_mi_flush(intel_batchbuffer_t*);
 extern void intel_batchbuffer_init(intel_batchbuffer_t*, struct intel_driver*);
 extern void intel_batchbuffer_terminate(intel_batchbuffer_t*);
 extern void intel_batchbuffer_flush(intel_batchbuffer_t*);
-extern void intel_batchbuffer_reset(intel_batchbuffer_t*, size_t sz);
+extern int intel_batchbuffer_reset(intel_batchbuffer_t*, size_t sz);
 
 static INLINE uint32_t
 intel_batchbuffer_space(const intel_batchbuffer_t *batch)
diff --git a/src/intel/intel_gpgpu.c b/src/intel/intel_gpgpu.c
index d00bc83a..174baba0 100644
--- a/src/intel/intel_gpgpu.c
+++ b/src/intel/intel_gpgpu.c
@@ -28,6 +28,7 @@
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <stddef.h>
+#include <errno.h>
 
 #include "intel/intel_gpgpu.h"
 #include "intel/intel_defines.h"
@@ -553,10 +554,10 @@ intel_gpgpu_batch_end(intel_gpgpu_t *gpgpu, int32_t flush_mode)
   intel_batchbuffer_end_atomic(gpgpu->batch);
 }
 
-static void
+static int
 intel_gpgpu_batch_reset(intel_gpgpu_t *gpgpu, size_t sz)
 {
-  intel_batchbuffer_reset(gpgpu->batch, sz);
+  return intel_batchbuffer_reset(gpgpu->batch, sz);
 }
 /* check we do not get a 0 starting address for binded buf */
 static void
@@ -584,7 +585,7 @@ intel_gpgpu_flush(intel_gpgpu_t *gpgpu)
   intel_gpgpu_check_binded_buf_address(gpgpu);
 }
 
-static void
+static int
 intel_gpgpu_state_init(intel_gpgpu_t *gpgpu,
                        uint32_t max_threads,
                        uint32_t size_cs_entry,
@@ -616,8 +617,9 @@ intel_gpgpu_state_init(intel_gpgpu_t *gpgpu,
   gpgpu->time_stamp_b.bo = NULL;
   if (profiling) {
     bo = dri_bo_alloc(gpgpu->drv->bufmgr, "timestamp query", 4096, 4096);
-    assert(bo);
     gpgpu->time_stamp_b.bo = bo;
+    if (!bo)
+      fprintf(stderr, "Could not allocate buffer for profiling.\n");
   }
 
   /* stack */
@@ -629,6 +631,7 @@ intel_gpgpu_state_init(intel_gpgpu_t *gpgpu,
   uint32_t size_aux = 0;
   if(gpgpu->aux_buf.bo)
     dri_bo_unreference(gpgpu->aux_buf.bo);
+  gpgpu->aux_buf.bo = NULL;
 
   //surface heap must be 4096 bytes aligned because state base address use 20bit for the address
   size_aux = ALIGN(size_aux, 4096);
@@ -656,10 +659,18 @@ intel_gpgpu_state_init(intel_gpgpu_t *gpgpu,
   size_aux += GEN_MAX_SAMPLERS * sizeof(gen7_sampler_border_color_t);
 
   bo = dri_bo_alloc(gpgpu->drv->bufmgr, "AUX_BUFFER", size_aux, 0);
-  assert(bo);
-  dri_bo_map(bo, 1);
+  if (!bo || dri_bo_map(bo, 1) != 0) {
+    fprintf(stderr, "%s:%d: %s.\n", __FILE__, __LINE__, strerror(errno));
+    if (bo)
+      dri_bo_unreference(bo);
+    if (profiling && gpgpu->time_stamp_b.bo)
+      dri_bo_unreference(gpgpu->time_stamp_b.bo);
+    gpgpu->time_stamp_b.bo = NULL;
+    return -1;
+  }
   memset(bo->virtual, 0, size_aux);
   gpgpu->aux_buf.bo = bo;
+  return 0;
 }
 
 static void
@@ -698,7 +709,8 @@ intel_gpgpu_alloc_constant_buffer(intel_gpgpu_t *gpgpu, uint32_t size)
   if(gpgpu->constant_b.bo)
     dri_bo_unreference(gpgpu->constant_b.bo);
   gpgpu->constant_b.bo = drm_intel_bo_alloc(gpgpu->drv->bufmgr, "CONSTANT_BUFFER", s, 64);
-  assert(gpgpu->constant_b.bo);
+  if (gpgpu->constant_b.bo == NULL)
+    return NULL;
   ss2->ss1.base_addr = gpgpu->constant_b.bo->offset;
   dri_bo_emit_reloc(gpgpu->aux_buf.bo,
                       I915_GEM_DOMAIN_RENDER,
@@ -882,7 +894,7 @@ intel_gpgpu_bind_buf(intel_gpgpu_t *gpgpu, drm_intel_bo *buf, uint32_t offset,
   gpgpu->binded_n++;
 }
 
-static void
+static int
 intel_gpgpu_set_scratch(intel_gpgpu_t * gpgpu, uint32_t per_thread_size)
 {
   drm_intel_bufmgr *bufmgr = gpgpu->drv->bufmgr;
@@ -899,8 +911,12 @@ intel_gpgpu_set_scratch(intel_gpgpu_t * gpgpu, uint32_t per_thread_size)
     old = NULL;
   }
 
-  if(!old)
+  if(!old && total) {
     gpgpu->scratch_b.bo = drm_intel_bo_alloc(bufmgr, "SCRATCH_BO", total, 4096);
+    if (gpgpu->scratch_b.bo == NULL)
+      return -1;
+  }
+  return 0;
 }
 static void
 intel_gpgpu_set_stack(intel_gpgpu_t *gpgpu, uint32_t offset, uint32_t size, uint32_t cchint)
@@ -966,7 +982,7 @@ intel_gpgpu_build_idrt(intel_gpgpu_t *gpgpu, cl_gpgpu_kernel *kernel)
                     gpgpu->aux_buf.bo);
 }
 
-static void
+static int
 intel_gpgpu_upload_curbes(intel_gpgpu_t *gpgpu, const void* data, uint32_t size)
 {
   unsigned char *curbe = NULL;
@@ -974,7 +990,10 @@ intel_gpgpu_upload_curbes(intel_gpgpu_t *gpgpu, const void* data, uint32_t size)
   uint32_t i, j;
 
   /* Upload the data first */
-  dri_bo_map(gpgpu->aux_buf.bo, 1);
+  if (dri_bo_map(gpgpu->aux_buf.bo, 1) != 0) {
+    fprintf(stderr, "%s:%d: %s.\n", __FILE__, __LINE__, strerror(errno));
+    return -1;
+  }
   assert(gpgpu->aux_buf.bo->virtual);
   curbe = (unsigned char *) (gpgpu->aux_buf.bo->virtual + gpgpu->aux_offset.curbe_offset);
   memcpy(curbe, data, size);
@@ -991,6 +1010,7 @@ intel_gpgpu_upload_curbes(intel_gpgpu_t *gpgpu, const void* data, uint32_t size)
                               I915_GEM_DOMAIN_RENDER);
     }
   dri_bo_unmap(gpgpu->aux_buf.bo);
+  return 0;
 }
 
 static void
@@ -1294,7 +1314,7 @@ intel_gpgpu_event_get_exec_timestamp(intel_gpgpu_t* gpgpu, intel_event_t *event,
   drm_intel_gem_bo_unmap_gtt(event->ts_buf);
 }
 
-static void
+static int
 intel_gpgpu_set_printf_buf(intel_gpgpu_t *gpgpu, uint32_t i, uint32_t size, uint32_t offset)
 {
   drm_intel_bo *bo = NULL;
@@ -1311,11 +1331,18 @@ intel_gpgpu_set_printf_buf(intel_gpgpu_t *gpgpu, uint32_t i, uint32_t size, uint
   } else
     assert(0);
 
-  drm_intel_bo_map(bo, 1);
+  if (!bo || (drm_intel_bo_map(bo, 1) != 0)) {
+    if (gpgpu->printf_b.bo)
+      drm_intel_bo_unreference(gpgpu->printf_b.bo);
+    gpgpu->printf_b.bo = NULL;
+    fprintf(stderr, "%s:%d: %s.\n", __FILE__, __LINE__, strerror(errno));
+    return -1;
+  }
   memset(bo->virtual, 0, size);
   drm_intel_bo_unmap(bo);
 
   intel_gpgpu_bind_buf(gpgpu, bo, offset, 0, 0);
+  return 0;
 }
 
 static void*