drm/vmwgfx: Add a new define for vmwgfx user-space debugging

Error messages or debugging message reported during user-space command
submission should not be printed to dmesg by default. So add a new
preprocessor define called VMW_DEBUG_USER which translates to
DRM_DEBUG_DRIVER.

v2: Use VMW_DEBUG_USER instead of using DRM_DEBUG_DRIVER directly.

Signed-off-by: Deepak Rawat <drawat@vmware.com>
Reviewed-by: Thomas Hellstrom <thellstrom@vmware.com>

diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_context.c b/drivers/gpu/drm/vmwgfx/vmwgfx_context.c
index 694fabafaeeefbd8ac773fe729b62143407437ad..39e96bb86329810f9cf7683ba943c4874b07eb89 100644 (file)
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_context.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_context.c
@@ -751,7 +751,7 @@ static int vmw_context_define(struct drm_device *dev, void *data,
        int ret;
 
        if (!dev_priv->has_dx && dx) {
-               DRM_ERROR("DX contexts not supported by device.\n");
+               VMW_DEBUG_USER("DX contexts not supported by device.\n");
                return -EINVAL;
        }
 

diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h
index abe975b7ea89e72d8b856625eb876fdd04cad6ff..92367d4ebdf3ccc101d0d499f73bdf0936c4a86c 100644 (file)
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.h
@@ -1313,6 +1313,20 @@ int vmw_host_get_guestinfo(const char *guest_info_param,
                           char *buffer, size_t *length);
 int vmw_host_log(const char *log);
 
+/* VMW logging */
+
+/**
+ * VMW_DEBUG_USER - Debug output for user-space debugging.
+ *
+ * @fmt: printf() like format string.
+ *
+ * This macro is for logging user-space error and debugging messages for e.g.
+ * command buffer execution errors due to malformed commands, invalid context,
+ * etc.
+ */
+#define VMW_DEBUG_USER(fmt, ...)                                              \
+       DRM_DEBUG_DRIVER(fmt, ##__VA_ARGS__)
+
 /**
  * Inline helper functions
  */

diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c b/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c
index 2c92744817eca8f7e16401f7c1fba43dffa8157e..9362670af03cd34d894732748bbbf9ebd9fa6f83 100644 (file)
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c
@@ -43,7 +43,7 @@
 #define VMW_GET_CTX_NODE(__sw_context)                                        \
 ({                                                                            \
        __sw_context->dx_ctx_node ? __sw_context->dx_ctx_node : ({            \
-               DRM_ERROR("SM context is not set at %s\n", __func__);         \
+               VMW_DEBUG_USER("SM context is not set at %s\n", __func__);    \
                __sw_context->dx_ctx_node;                                    \
        });                                                                   \
 })
@@ -217,8 +217,7 @@ static int vmw_cmd_ctx_first_setup(struct vmw_private *dev_priv,
                sw_context->staged_bindings =
                        vmw_binding_state_alloc(dev_priv);
                if (IS_ERR(sw_context->staged_bindings)) {
-                       DRM_ERROR("Failed to allocate context binding "
-                                 "information.\n");
+                       VMW_DEBUG_USER("Failed to alloc ctx binding info.\n");
                        ret = PTR_ERR(sw_context->staged_bindings);
                        sw_context->staged_bindings = NULL;
                        goto out_err;
@@ -228,8 +227,7 @@ static int vmw_cmd_ctx_first_setup(struct vmw_private *dev_priv,
        if (sw_context->staged_bindings_inuse) {
                node->staged = vmw_binding_state_alloc(dev_priv);
                if (IS_ERR(node->staged)) {
-                       DRM_ERROR("Failed to allocate context binding "
-                                 "information.\n");
+                       VMW_DEBUG_USER("Failed to alloc ctx binding info.\n");
                        ret = PTR_ERR(node->staged);
                        node->staged = NULL;
                        goto out_err;
@@ -424,7 +422,7 @@ vmw_view_id_val_add(struct vmw_sw_context *sw_context,
        int ret;
 
        if (!ctx_node) {
-               DRM_ERROR("DX Context not set.\n");
+               VMW_DEBUG_USER("DX Context not set.\n");
                return ERR_PTR(-EINVAL);
        }
 
@@ -522,7 +520,7 @@ static int vmw_resource_relocation_add(struct vmw_sw_context *sw_context,
 
        rel = vmw_validation_mem_alloc(sw_context->ctx, sizeof(*rel));
        if (unlikely(!rel)) {
-               DRM_ERROR("Failed to allocate a resource relocation.\n");
+               VMW_DEBUG_USER("Failed to allocate a resource relocation.\n");
                return -ENOMEM;
        }
 
@@ -659,7 +657,7 @@ vmw_cmd_res_check(struct vmw_private *dev_priv,
 
        if (*id_loc == SVGA3D_INVALID_ID) {
                if (res_type == vmw_res_context) {
-                       DRM_ERROR("Illegal context invalid id.\n");
+                       VMW_DEBUG_USER("Illegal context invalid id.\n");
                        return -EINVAL;
                }
                return 0;
@@ -680,8 +678,8 @@ vmw_cmd_res_check(struct vmw_private *dev_priv,
                res = vmw_user_resource_noref_lookup_handle
                        (dev_priv, sw_context->fp->tfile, *id_loc, converter);
                if (IS_ERR(res)) {
-                       DRM_ERROR("Could not find or use resource 0x%08x.\n",
-                                 (unsigned int) *id_loc);
+                       VMW_DEBUG_USER("Could not find/use resource 0x%08x.\n",
+                                      (unsigned int) *id_loc);
                        return PTR_ERR(res);
                }
 
@@ -726,7 +724,7 @@ static int vmw_rebind_all_dx_query(struct vmw_resource *ctx_res)
        cmd = vmw_fifo_reserve_dx(dev_priv, sizeof(*cmd), ctx_res->id);
 
        if (cmd == NULL) {
-               DRM_ERROR("Failed to rebind queries.\n");
+               VMW_DEBUG_USER("Failed to rebind queries.\n");
                return -ENOMEM;
        }
 
@@ -758,7 +756,7 @@ static int vmw_rebind_contexts(struct vmw_sw_context *sw_context)
                ret = vmw_binding_rebind_all(val->cur);
                if (unlikely(ret != 0)) {
                        if (ret != -ERESTARTSYS)
-                               DRM_ERROR("Failed to rebind context.\n");
+                               VMW_DEBUG_USER("Failed to rebind context.\n");
                        return ret;
                }
 
@@ -803,7 +801,7 @@ static int vmw_view_bindings_add(struct vmw_sw_context *sw_context,
                        view = vmw_view_id_val_add(sw_context, view_type,
                                                   view_ids[i]);
                        if (IS_ERR(view)) {
-                               DRM_ERROR("View not found.\n");
+                               VMW_DEBUG_USER("View not found.\n");
                                return PTR_ERR(view);
                        }
                }
@@ -881,8 +879,8 @@ static int vmw_cmd_set_render_target_check(struct vmw_private *dev_priv,
        cmd = container_of(header, typeof(*cmd), header);
 
        if (cmd->body.type >= SVGA3D_RT_MAX) {
-               DRM_ERROR("Illegal render target type %u.\n",
-                         (unsigned) cmd->body.type);
+               VMW_DEBUG_USER("Illegal render target type %u.\n",
+                              (unsigned int) cmd->body.type);
                return -EINVAL;
        }
 
@@ -1043,7 +1041,7 @@ static int vmw_query_bo_switch_prepare(struct vmw_private *dev_priv,
        if (unlikely(new_query_bo != sw_context->cur_query_bo)) {
 
                if (unlikely(new_query_bo->base.num_pages > 4)) {
-                       DRM_ERROR("Query buffer too large.\n");
+                       VMW_DEBUG_USER("Query buffer too large.\n");
                        return -EINVAL;
                }
 
@@ -1106,7 +1104,7 @@ static void vmw_query_bo_switch_commit(struct vmw_private *dev_priv,
                ret = vmw_fifo_emit_dummy_query(dev_priv, ctx->id);
 
                if (unlikely(ret != 0))
-                       DRM_ERROR("Out of fifo space for dummy query.\n");
+                       VMW_DEBUG_USER("Out of fifo space for dummy query.\n");
        }
 
        if (dev_priv->pinned_bo != sw_context->cur_query_bo) {
@@ -1170,7 +1168,7 @@ static int vmw_translate_mob_ptr(struct vmw_private *dev_priv,
        vmw_validation_preload_bo(sw_context->ctx);
        vmw_bo = vmw_user_bo_noref_lookup(sw_context->fp->tfile, handle);
        if (IS_ERR(vmw_bo)) {
-               DRM_ERROR("Could not find or use MOB buffer.\n");
+               VMW_DEBUG_USER("Could not find or use MOB buffer.\n");
                return PTR_ERR(vmw_bo);
        }
 
@@ -1224,7 +1222,7 @@ static int vmw_translate_guest_ptr(struct vmw_private *dev_priv,
        vmw_validation_preload_bo(sw_context->ctx);
        vmw_bo = vmw_user_bo_noref_lookup(sw_context->fp->tfile, handle);
        if (IS_ERR(vmw_bo)) {
-               DRM_ERROR("Could not find or use GMR region.\n");
+               VMW_DEBUG_USER("Could not find or use GMR region.\n");
                return PTR_ERR(vmw_bo);
        }
 
@@ -1543,7 +1541,7 @@ static int vmw_cmd_dma(struct vmw_private *dev_priv,
 
        /* Make sure device and verifier stays in sync. */
        if (unlikely(suffix->suffixSize != sizeof(*suffix))) {
-               DRM_ERROR("Invalid DMA suffix size.\n");
+               VMW_DEBUG_USER("Invalid DMA suffix size.\n");
                return -EINVAL;
        }
 
@@ -1556,7 +1554,7 @@ static int vmw_cmd_dma(struct vmw_private *dev_priv,
        /* Make sure DMA doesn't cross BO boundaries. */
        bo_size = vmw_bo->base.num_pages * PAGE_SIZE;
        if (unlikely(cmd->body.guest.ptr.offset > bo_size)) {
-               DRM_ERROR("Invalid DMA offset.\n");
+               VMW_DEBUG_USER("Invalid DMA offset.\n");
                return -EINVAL;
        }
 
@@ -1571,7 +1569,7 @@ static int vmw_cmd_dma(struct vmw_private *dev_priv,
                                &cmd->body.host.sid, NULL);
        if (unlikely(ret != 0)) {
                if (unlikely(ret != -ERESTARTSYS))
-                       DRM_ERROR("could not find surface for DMA.\n");
+                       VMW_DEBUG_USER("could not find surface for DMA.\n");
                return ret;
        }
 
@@ -1603,7 +1601,7 @@ static int vmw_cmd_draw(struct vmw_private *dev_priv,
        maxnum = (header->size - sizeof(cmd->body)) / sizeof(*decl);
 
        if (unlikely(cmd->body.numVertexDecls > maxnum)) {
-               DRM_ERROR("Illegal number of vertex declarations.\n");
+               VMW_DEBUG_USER("Illegal number of vertex declarations.\n");
                return -EINVAL;
        }
 
@@ -1619,7 +1617,7 @@ static int vmw_cmd_draw(struct vmw_private *dev_priv,
        maxnum = (header->size - sizeof(cmd->body) -
                  cmd->body.numVertexDecls * sizeof(*decl)) / sizeof(*range);
        if (unlikely(cmd->body.numRanges > maxnum)) {
-               DRM_ERROR("Illegal number of index ranges.\n");
+               VMW_DEBUG_USER("Illegal number of index ranges.\n");
                return -EINVAL;
        }
 
@@ -1662,8 +1660,8 @@ static int vmw_cmd_tex_state(struct vmw_private *dev_priv,
                        continue;
 
                if (cur_state->stage >= SVGA3D_NUM_TEXTURE_UNITS) {
-                       DRM_ERROR("Illegal texture/sampler unit %u.\n",
-                                 (unsigned) cur_state->stage);
+                       VMW_DEBUG_USER("Illegal texture/sampler unit %u.\n",
+                                      (unsigned int) cur_state->stage);
                        return -EINVAL;
                }
 
@@ -2035,8 +2033,8 @@ static int vmw_cmd_set_shader(struct vmw_private *dev_priv,
        cmd = container_of(header, typeof(*cmd), header);
 
        if (cmd->body.type >= SVGA3D_SHADERTYPE_PREDX_MAX) {
-               DRM_ERROR("Illegal shader type %u.\n",
-                         (unsigned) cmd->body.type);
+               VMW_DEBUG_USER("Illegal shader type %u.\n",
+                              (unsigned int) cmd->body.type);
                return -EINVAL;
        }
 
@@ -2173,9 +2171,9 @@ vmw_cmd_dx_set_single_constant_buffer(struct vmw_private *dev_priv,
 
        if (binding.shader_slot >= SVGA3D_NUM_SHADERTYPE_DX10 ||
            binding.slot >= SVGA3D_DX_MAX_CONSTBUFFERS) {
-               DRM_ERROR("Illegal const buffer shader %u slot %u.\n",
-                         (unsigned) cmd->body.type,
-                         (unsigned) binding.slot);
+               VMW_DEBUG_USER("Illegal const buffer shader %u slot %u.\n",
+                              (unsigned int) cmd->body.type,
+                              (unsigned int) binding.slot);
                return -EINVAL;
        }
 
@@ -2205,7 +2203,7 @@ static int vmw_cmd_dx_set_shader_res(struct vmw_private *dev_priv,
        if ((u64) cmd->body.startView + (u64) num_sr_view >
            (u64) SVGA3D_DX_MAX_SRVIEWS ||
            cmd->body.type >= SVGA3D_SHADERTYPE_DX10_MAX) {
-               DRM_ERROR("Invalid shader binding.\n");
+               VMW_DEBUG_USER("Invalid shader binding.\n");
                return -EINVAL;
        }
 
@@ -2240,15 +2238,15 @@ static int vmw_cmd_dx_set_shader(struct vmw_private *dev_priv,
        cmd = container_of(header, typeof(*cmd), header);
 
        if (cmd->body.type >= SVGA3D_SHADERTYPE_DX10_MAX) {
-               DRM_ERROR("Illegal shader type %u.\n",
-                         (unsigned) cmd->body.type);
+               VMW_DEBUG_USER("Illegal shader type %u.\n",
+                              (unsigned int) cmd->body.type);
                return -EINVAL;
        }
 
        if (cmd->body.shaderId != SVGA3D_INVALID_ID) {
                res = vmw_shader_lookup(sw_context->man, cmd->body.shaderId, 0);
                if (IS_ERR(res)) {
-                       DRM_ERROR("Could not find shader for binding.\n");
+                       VMW_DEBUG_USER("Could not find shader for binding.\n");
                        return PTR_ERR(res);
                }
 
@@ -2299,7 +2297,7 @@ static int vmw_cmd_dx_set_vertex_buffers(struct vmw_private *dev_priv,
                sizeof(SVGA3dVertexBuffer);
        if ((u64)num + (u64)cmd->body.startBuffer >
            (u64)SVGA3D_DX_MAX_VERTEXBUFFERS) {
-               DRM_ERROR("Invalid number of vertex buffers.\n");
+               VMW_DEBUG_USER("Invalid number of vertex buffers.\n");
                return -EINVAL;
        }
 
@@ -2383,7 +2381,7 @@ static int vmw_cmd_dx_set_rendertargets(struct vmw_private *dev_priv,
        int ret;
 
        if (num_rt_view > SVGA3D_MAX_SIMULTANEOUS_RENDER_TARGETS) {
-               DRM_ERROR("Invalid DX Rendertarget binding.\n");
+               VMW_DEBUG_USER("Invalid DX Rendertarget binding.\n");
                return -EINVAL;
        }
 
@@ -2513,7 +2511,7 @@ static int vmw_cmd_dx_set_so_targets(struct vmw_private *dev_priv,
                sizeof(SVGA3dSoTarget);
 
        if (num > SVGA3D_DX_MAX_SOTARGETS) {
-               DRM_ERROR("Invalid DX SO binding.\n");
+               VMW_DEBUG_USER("Invalid DX SO binding.\n");
                return -EINVAL;
        }
 
@@ -2716,7 +2714,7 @@ static int vmw_cmd_dx_destroy_shader(struct vmw_private *dev_priv,
        ret = vmw_shader_remove(sw_context->man, cmd->body.shaderId, 0,
                                &sw_context->staged_cmd_res);
        if (ret)
-               DRM_ERROR("Could not find shader to remove.\n");
+               VMW_DEBUG_USER("Could not find shader to remove.\n");
 
        return ret;
 }
@@ -2759,14 +2757,14 @@ static int vmw_cmd_dx_bind_shader(struct vmw_private *dev_priv,
        res = vmw_shader_lookup(vmw_context_res_man(ctx),
                                cmd->body.shid, 0);
        if (IS_ERR(res)) {
-               DRM_ERROR("Could not find shader to bind.\n");
+               VMW_DEBUG_USER("Could not find shader to bind.\n");
                return PTR_ERR(res);
        }
 
        ret = vmw_execbuf_res_noctx_val_add(sw_context, res,
                                            VMW_RES_DIRTY_NONE);
        if (ret) {
-               DRM_ERROR("Error creating resource validation node.\n");
+               VMW_DEBUG_USER("Error creating resource validation node.\n");
                return ret;
        }
 
@@ -2866,18 +2864,18 @@ static int vmw_cmd_check_not_3d(struct vmw_private *dev_priv,
                *size = sizeof(uint32_t) + sizeof(SVGAFifoCmdBlitGMRFBToScreen);
                break;
        default:
-               DRM_ERROR("Unsupported SVGA command: %u.\n", cmd_id);
+               VMW_DEBUG_USER("Unsupported SVGA command: %u.\n", cmd_id);
                return -EINVAL;
        }
 
        if (*size > size_remaining) {
-               DRM_ERROR("Invalid SVGA command (size mismatch):"
-                         " %u.\n", cmd_id);
+               VMW_DEBUG_USER("Invalid SVGA command (size mismatch): %u.\n",
+                              cmd_id);
                return -EINVAL;
        }
 
        if (unlikely(!sw_context->kernel)) {
-               DRM_ERROR("Kernel only SVGA command: %u.\n", cmd_id);
+               VMW_DEBUG_USER("Kernel only SVGA command: %u.\n", cmd_id);
                return -EPERM;
        }
 
@@ -3294,20 +3292,20 @@ static int vmw_cmd_check(struct vmw_private *dev_priv,
 
        return 0;
 out_invalid:
-       DRM_ERROR("Invalid SVGA3D command: %d\n",
-                 cmd_id + SVGA_3D_CMD_BASE);
+       VMW_DEBUG_USER("Invalid SVGA3D command: %d\n",
+                      cmd_id + SVGA_3D_CMD_BASE);
        return -EINVAL;
 out_privileged:
-       DRM_ERROR("Privileged SVGA3D command: %d\n",
-                 cmd_id + SVGA_3D_CMD_BASE);
+       VMW_DEBUG_USER("Privileged SVGA3D command: %d\n",
+                      cmd_id + SVGA_3D_CMD_BASE);
        return -EPERM;
 out_old:
-       DRM_ERROR("Deprecated (disallowed) SVGA3D command: %d\n",
-                 cmd_id + SVGA_3D_CMD_BASE);
+       VMW_DEBUG_USER("Deprecated (disallowed) SVGA3D command: %d\n",
+                      cmd_id + SVGA_3D_CMD_BASE);
        return -EINVAL;
 out_new:
-       DRM_ERROR("SVGA3D command: %d not supported by virtual hardware.\n",
-                 cmd_id + SVGA_3D_CMD_BASE);
+       VMW_DEBUG_USER("SVGA3D command: %d not supported by virtual device.\n",
+                      cmd_id + SVGA_3D_CMD_BASE);
        return -EINVAL;
 }
 
@@ -3331,7 +3329,7 @@ static int vmw_cmd_check_all(struct vmw_private *dev_priv,
        }
 
        if (unlikely(cur_size != 0)) {
-               DRM_ERROR("Command verifier out of sync.\n");
+               VMW_DEBUG_USER("Command verifier out of sync.\n");
                return -EINVAL;
        }
 
@@ -3389,7 +3387,7 @@ static int vmw_resize_cmd_bounce(struct vmw_sw_context *sw_context,
        sw_context->cmd_bounce = vmalloc(sw_context->cmd_bounce_size);
 
        if (sw_context->cmd_bounce == NULL) {
-               DRM_ERROR("Failed to allocate command bounce buffer.\n");
+               VMW_DEBUG_USER("Failed to allocate command bounce buffer.\n");
                sw_context->cmd_bounce_size = 0;
                return -ENOMEM;
        }
@@ -3422,7 +3420,7 @@ int vmw_execbuf_fence_commands(struct drm_file *file_priv,
 
        ret = vmw_fifo_send_fence(dev_priv, &sequence);
        if (unlikely(ret != 0)) {
-               DRM_ERROR("Fence submission error. Syncing.\n");
+               VMW_DEBUG_USER("Fence submission error. Syncing.\n");
                synced = true;
        }
 
@@ -3515,7 +3513,7 @@ vmw_execbuf_copy_fence_user(struct vmw_private *dev_priv,
 
                ttm_ref_object_base_unref(vmw_fp->tfile,
                                          fence_handle, TTM_REF_USAGE);
-               DRM_ERROR("Fence copy error. Syncing.\n");
+               VMW_DEBUG_USER("Fence copy error. Syncing.\n");
                (void) vmw_fence_obj_wait(fence, false, false,
                                          VMW_FENCE_WAIT_TIMEOUT);
        }
@@ -3546,7 +3544,7 @@ static int vmw_execbuf_submit_fifo(struct vmw_private *dev_priv,
        else
                cmd = vmw_fifo_reserve(dev_priv, command_size);
        if (!cmd) {
-               DRM_ERROR("Failed reserving fifo space for commands.\n");
+               VMW_DEBUG_USER("Failed reserving fifo space for commands.\n");
                return -ENOMEM;
        }
 
@@ -3622,7 +3620,7 @@ static void *vmw_execbuf_cmdbuf(struct vmw_private *dev_priv,
 
        *header = NULL;
        if (command_size > SVGA_CB_MAX_SIZE) {
-               DRM_ERROR("Command buffer is too large.\n");
+               VMW_DEBUG_USER("Command buffer is too large.\n");
                return ERR_PTR(-EINVAL);
        }
 
@@ -3640,7 +3638,7 @@ static void *vmw_execbuf_cmdbuf(struct vmw_private *dev_priv,
        ret = copy_from_user(kernel_commands, user_commands,
                             command_size);
        if (ret) {
-               DRM_ERROR("Failed copying commands.\n");
+               VMW_DEBUG_USER("Failed copying commands.\n");
                vmw_cmdbuf_header_free(*header);
                *header = NULL;
                return ERR_PTR(-EFAULT);
@@ -3669,8 +3667,8 @@ static int vmw_execbuf_tie_context(struct vmw_private *dev_priv,
                (dev_priv, sw_context->fp->tfile, handle,
                 user_context_converter);
        if (IS_ERR(res)) {
-               DRM_ERROR("Could not find or user DX context 0x%08x.\n",
-                         (unsigned) handle);
+               VMW_DEBUG_USER("Could not find or user DX context 0x%08x.\n",
+                              (unsigned int) handle);
                return PTR_ERR(res);
        }
 
@@ -3709,7 +3707,7 @@ int vmw_execbuf_process(struct drm_file *file_priv,
        if (flags & DRM_VMW_EXECBUF_FLAG_EXPORT_FENCE_FD) {
                out_fence_fd = get_unused_fd_flags(O_CLOEXEC);
                if (out_fence_fd < 0) {
-                       DRM_ERROR("Failed to get a fence file descriptor.\n");
+                       VMW_DEBUG_USER("Failed to get a fence fd.\n");
                        return out_fence_fd;
                }
        }
@@ -3748,7 +3746,7 @@ int vmw_execbuf_process(struct drm_file *file_priv,
 
                if (unlikely(ret != 0)) {
                        ret = -EFAULT;
-                       DRM_ERROR("Failed copying commands.\n");
+                       VMW_DEBUG_USER("Failed copying commands.\n");
                        goto out_unlock;
                }
                kernel_commands = sw_context->cmd_bounce;
@@ -3838,7 +3836,7 @@ int vmw_execbuf_process(struct drm_file *file_priv,
         */
 
        if (ret != 0)
-               DRM_ERROR("Fence submission error. Syncing.\n");
+               VMW_DEBUG_USER("Fence submission error. Syncing.\n");
 
        vmw_execbuf_bindings_commit(sw_context, false);
        vmw_bind_dx_query_mob(sw_context);
@@ -3860,7 +3858,7 @@ int vmw_execbuf_process(struct drm_file *file_priv,
 
                sync_file = sync_file_create(&fence->base);
                if (!sync_file) {
-                       DRM_ERROR("Unable to create sync file for fence\n");
+                       VMW_DEBUG_USER("Sync file create failed for fence\n");
                        put_unused_fd(out_fence_fd);
                        out_fence_fd = -1;
 
@@ -3939,7 +3937,7 @@ out_free_fence_fd:
  */
 static void vmw_execbuf_unpin_panic(struct vmw_private *dev_priv)
 {
-       DRM_ERROR("Can't unpin query buffer. Trying to recover.\n");
+       VMW_DEBUG_USER("Can't unpin query buffer. Trying to recover.\n");
 
        (void) vmw_fallback_wait(dev_priv, false, true, 0, false, 10*HZ);
        vmw_bo_pin_reserved(dev_priv->pinned_bo, false);
@@ -4072,8 +4070,8 @@ int vmw_execbuf_ioctl(struct drm_device *dev, unsigned long data,
        struct dma_fence *in_fence = NULL;
 
        if (unlikely(size < copy_offset[0])) {
-               DRM_ERROR("Invalid command size, ioctl %d\n",
-                         DRM_VMW_EXECBUF);
+               VMW_DEBUG_USER("Invalid command size, ioctl %d\n",
+                              DRM_VMW_EXECBUF);
                return -EINVAL;
        }
 
@@ -4089,7 +4087,7 @@ int vmw_execbuf_ioctl(struct drm_device *dev, unsigned long data,
 
        if (unlikely(arg.version > DRM_VMW_EXECBUF_VERSION ||
                     arg.version == 0)) {
-               DRM_ERROR("Incorrect execbuf version.\n");
+               VMW_DEBUG_USER("Incorrect execbuf version.\n");
                return -EINVAL;
        }
 
@@ -4115,7 +4113,7 @@ int vmw_execbuf_ioctl(struct drm_device *dev, unsigned long data,
                in_fence = sync_file_get_fence(arg.imported_fence_fd);
 
                if (!in_fence) {
-                       DRM_ERROR("Cannot get imported fence\n");
+                       VMW_DEBUG_USER("Cannot get imported fence\n");
                        return -EINVAL;
                }
 

diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_ioctl.c b/drivers/gpu/drm/vmwgfx/vmwgfx_ioctl.c
index 172a6ba6539cb39d274bdd445628ca7fade9ddd4..a15375eb476e974e457b490106cf0c471582ad49 100644 (file)
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_ioctl.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_ioctl.c
@@ -188,7 +188,7 @@ int vmw_get_cap_3d_ioctl(struct drm_device *dev, void *data,
        struct vmw_fpriv *vmw_fp = vmw_fpriv(file_priv);
 
        if (unlikely(arg->pad64 != 0 || arg->max_size == 0)) {
-               DRM_ERROR("Illegal GET_3D_CAP argument.\n");
+               VMW_DEBUG_USER("Illegal GET_3D_CAP argument.\n");
                return -EINVAL;
        }
 
@@ -268,7 +268,7 @@ int vmw_present_ioctl(struct drm_device *dev, void *data,
                return 0;
 
        if (clips_ptr == NULL) {
-               DRM_ERROR("Variable clips_ptr must be specified.\n");
+               VMW_DEBUG_USER("Variable clips_ptr must be specified.\n");
                ret = -EINVAL;
                goto out_clips;
        }
@@ -291,7 +291,7 @@ int vmw_present_ioctl(struct drm_device *dev, void *data,
 
        fb = drm_framebuffer_lookup(dev, file_priv, arg->fb_id);
        if (!fb) {
-               DRM_ERROR("Invalid framebuffer id.\n");
+               VMW_DEBUG_USER("Invalid framebuffer id.\n");
                ret = -ENOENT;
                goto out_no_fb;
        }
@@ -351,7 +351,7 @@ int vmw_present_readback_ioctl(struct drm_device *dev, void *data,
                return 0;
 
        if (clips_ptr == NULL) {
-               DRM_ERROR("Argument clips_ptr must be specified.\n");
+               VMW_DEBUG_USER("Argument clips_ptr must be specified.\n");
                ret = -EINVAL;
                goto out_clips;
        }
@@ -374,14 +374,14 @@ int vmw_present_readback_ioctl(struct drm_device *dev, void *data,
 
        fb = drm_framebuffer_lookup(dev, file_priv, arg->fb_id);
        if (!fb) {
-               DRM_ERROR("Invalid framebuffer id.\n");
+               VMW_DEBUG_USER("Invalid framebuffer id.\n");
                ret = -ENOENT;
                goto out_no_fb;
        }
 
        vfb = vmw_framebuffer_to_vfb(fb);
        if (!vfb->bo) {
-               DRM_ERROR("Framebuffer not buffer backed.\n");
+               VMW_DEBUG_USER("Framebuffer not buffer backed.\n");
                ret = -EINVAL;
                goto out_no_ttm_lock;
        }

diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_shader.c b/drivers/gpu/drm/vmwgfx/vmwgfx_shader.c
index bf32fe44621986758ca59982e69a896a77d85e2f..bbc95743a3819786eb3cbe02649c632f31b73a75 100644 (file)
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_shader.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_shader.c
@@ -865,14 +865,13 @@ static int vmw_shader_define(struct drm_device *dev, struct drm_file *file_priv,
                ret = vmw_user_bo_lookup(tfile, buffer_handle,
                                             &buffer, NULL);
                if (unlikely(ret != 0)) {
-                       DRM_ERROR("Could not find buffer for shader "
-                                 "creation.\n");
+                       VMW_DEBUG_USER("Couldn't find buffer for shader creation.\n");
                        return ret;
                }
 
                if ((u64)buffer->base.num_pages * PAGE_SIZE <
                    (u64)size + (u64)offset) {
-                       DRM_ERROR("Illegal buffer- or shader size.\n");
+                       VMW_DEBUG_USER("Illegal buffer- or shader size.\n");
                        ret = -EINVAL;
                        goto out_bad_arg;
                }
@@ -886,7 +885,7 @@ static int vmw_shader_define(struct drm_device *dev, struct drm_file *file_priv,
                shader_type = SVGA3D_SHADERTYPE_PS;
                break;
        default:
-               DRM_ERROR("Illegal shader type.\n");
+               VMW_DEBUG_USER("Illegal shader type.\n");
                ret = -EINVAL;
                goto out_bad_arg;
        }

diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_simple_resource.c b/drivers/gpu/drm/vmwgfx/vmwgfx_simple_resource.c
index 6a6865384e91f21fba1890f69b3889771e683bea..73e9a487e659e8f7c43d958bee49cda5071ae2f3 100644 (file)
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_simple_resource.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_simple_resource.c
@@ -239,17 +239,17 @@ vmw_simple_resource_lookup(struct ttm_object_file *tfile,
 
        base = ttm_base_object_lookup(tfile, handle);
        if (!base) {
-               DRM_ERROR("Invalid %s handle 0x%08lx.\n",
-                         func->res_func.type_name,
-                         (unsigned long) handle);
+               VMW_DEBUG_USER("Invalid %s handle 0x%08lx.\n",
+                              func->res_func.type_name,
+                              (unsigned long) handle);
                return ERR_PTR(-ESRCH);
        }
 
        if (ttm_base_object_type(base) != func->ttm_res_type) {
                ttm_base_object_unref(&base);
-               DRM_ERROR("Invalid type of %s handle 0x%08lx.\n",
-                         func->res_func.type_name,
-                         (unsigned long) handle);
+               VMW_DEBUG_USER("Invalid type of %s handle 0x%08lx.\n",
+                              func->res_func.type_name,
+                              (unsigned long) handle);
                return ERR_PTR(-EINVAL);
        }
 

diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_so.c b/drivers/gpu/drm/vmwgfx/vmwgfx_so.c
index 4ef8460eaf2c068b2a372b2970fc269127705142..c50002a3db277a59e189f3321d86eb48dcf27751 100644 (file)
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_so.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_so.c
@@ -338,12 +338,12 @@ int vmw_view_add(struct vmw_cmdbuf_res_manager *man,
 
        if (cmd_size != vmw_view_define_sizes[view_type] +
            sizeof(SVGA3dCmdHeader)) {
-               DRM_ERROR("Illegal view create command size.\n");
+               VMW_DEBUG_USER("Illegal view create command size.\n");
                return -EINVAL;
        }
 
        if (!vmw_view_id_ok(user_key, view_type)) {
-               DRM_ERROR("Illegal view add view id.\n");
+               VMW_DEBUG_USER("Illegal view add view id.\n");
                return -EINVAL;
        }
 
@@ -352,8 +352,7 @@ int vmw_view_add(struct vmw_cmdbuf_res_manager *man,
        ret = ttm_mem_global_alloc(vmw_mem_glob(dev_priv), size, &ttm_opt_ctx);
        if (ret) {
                if (ret != -ERESTARTSYS)
-                       DRM_ERROR("Out of graphics memory for view"
-                                 " creation.\n");
+                       DRM_ERROR("Out of graphics memory for view creation\n");
                return ret;
        }
 
@@ -413,7 +412,7 @@ int vmw_view_remove(struct vmw_cmdbuf_res_manager *man,
                    struct vmw_resource **res_p)
 {
        if (!vmw_view_id_ok(user_key, view_type)) {
-               DRM_ERROR("Illegal view remove view id.\n");
+               VMW_DEBUG_USER("Illegal view remove view id.\n");
                return -EINVAL;
        }
 

diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_surface.c b/drivers/gpu/drm/vmwgfx/vmwgfx_surface.c
index ef09f7edf931b9825fb993745daaa01e07588a99..b550f69578e805b56c2ff10046fa05915f776966 100644 (file)
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_surface.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_surface.c
@@ -748,11 +748,10 @@ int vmw_surface_define_ioctl(struct drm_device *dev, void *data,
                ttm_round_pot(num_sizes * sizeof(struct drm_vmw_size)) +
                ttm_round_pot(num_sizes * sizeof(struct vmw_surface_offset));
 
-
        desc = svga3dsurface_get_desc(req->format);
        if (unlikely(desc->block_desc == SVGA3DBLOCKDESC_NONE)) {
-               DRM_ERROR("Invalid surface format for surface creation.\n");
-               DRM_ERROR("Format requested is: %d\n", req->format);
+               VMW_DEBUG_USER("Invalid format %d for surface creation.\n",
+                              req->format);
                return -EINVAL;
        }
 
@@ -764,8 +763,7 @@ int vmw_surface_define_ioctl(struct drm_device *dev, void *data,
                                   size, &ctx);
        if (unlikely(ret != 0)) {
                if (ret != -ERESTARTSYS)
-                       DRM_ERROR("Out of graphics memory for surface"
-                                 " creation.\n");
+                       DRM_ERROR("Out of graphics memory for surface.\n");
                goto out_unlock;
        }
 
@@ -939,12 +937,12 @@ vmw_surface_handle_reference(struct vmw_private *dev_priv,
        ret = -EINVAL;
        base = ttm_base_object_lookup_for_ref(dev_priv->tdev, handle);
        if (unlikely(!base)) {
-               DRM_ERROR("Could not find surface to reference.\n");
+               VMW_DEBUG_USER("Could not find surface to reference.\n");
                goto out_no_lookup;
        }
 
        if (unlikely(ttm_base_object_type(base) != VMW_RES_SURFACE)) {
-               DRM_ERROR("Referenced object is not a surface.\n");
+               VMW_DEBUG_USER("Referenced object is not a surface.\n");
                goto out_bad_resource;
        }
 
@@ -1022,8 +1020,8 @@ int vmw_surface_reference_ioctl(struct drm_device *dev, void *data,
                ret = copy_to_user(user_sizes, &srf->base_size,
                                   sizeof(srf->base_size));
        if (unlikely(ret != 0)) {
-               DRM_ERROR("copy_to_user failed %p %u\n",
-                         user_sizes, srf->num_sizes);
+               VMW_DEBUG_USER("copy_to_user failed %p %u\n", user_sizes,
+                              srf->num_sizes);
                ttm_ref_object_base_unref(tfile, base->handle, TTM_REF_USAGE);
                ret = -EFAULT;
        }
@@ -1405,16 +1403,16 @@ int vmw_surface_gb_priv_define(struct drm_device *dev,
 
        if (for_scanout) {
                if (!svga3dsurface_is_screen_target_format(format)) {
-                       DRM_ERROR("Invalid Screen Target surface format.");
+                       VMW_DEBUG_USER("Invalid Screen Target surface format.");
                        return -EINVAL;
                }
 
                if (size.width > dev_priv->texture_max_width ||
                    size.height > dev_priv->texture_max_height) {
-                       DRM_ERROR("%ux%u\n, exceeds max surface size %ux%u",
-                                 size.width, size.height,
-                                 dev_priv->texture_max_width,
-                                 dev_priv->texture_max_height);
+                       VMW_DEBUG_USER("%ux%u\n, exceeds max surface size %ux%u",
+                                      size.width, size.height,
+                                      dev_priv->texture_max_width,
+                                      dev_priv->texture_max_height);
                        return -EINVAL;
                }
        } else {
@@ -1422,14 +1420,14 @@ int vmw_surface_gb_priv_define(struct drm_device *dev,
 
                desc = svga3dsurface_get_desc(format);
                if (unlikely(desc->block_desc == SVGA3DBLOCKDESC_NONE)) {
-                       DRM_ERROR("Invalid surface format.\n");
+                       VMW_DEBUG_USER("Invalid surface format.\n");
                        return -EINVAL;
                }
        }
 
        /* array_size must be null for non-GL3 host. */
        if (array_size > 0 && !dev_priv->has_dx) {
-               DRM_ERROR("Tried to create DX surface on non-DX host.\n");
+               VMW_DEBUG_USER("Tried to create DX surface on non-DX host.\n");
                return -EINVAL;
        }
 
@@ -1651,7 +1649,7 @@ vmw_gb_surface_define_internal(struct drm_device *dev,
                if (ret == 0) {
                        if (res->backup->base.num_pages * PAGE_SIZE <
                            res->backup_size) {
-                               DRM_ERROR("Surface backup buffer too small.\n");
+                               VMW_DEBUG_USER("Surface backup buffer too small.\n");
                                vmw_bo_unreference(&res->backup);
                                ret = -EINVAL;
                                goto out_unlock;

diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_validation.c b/drivers/gpu/drm/vmwgfx/vmwgfx_validation.c
index 5ab7da1cbb4577d7c94ec7601905d8136e04b98d..f611b2290a1b9325ac0405936c6cbbfcf414776f 100644 (file)
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_validation.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_validation.c
@@ -325,8 +325,7 @@ int vmw_validation_add_resource(struct vmw_validation_context *ctx,
 
        node = vmw_validation_mem_alloc(ctx, sizeof(*node) + priv_size);
        if (!node) {
-               DRM_ERROR("Failed to allocate a resource validation "
-                         "entry.\n");
+               VMW_DEBUG_USER("Failed to allocate a resource validation entry.\n");
                return -ENOMEM;
        }