WARNING: at drivers/gpu/drm/vmwgfx/vmwgfx_cmdbuf.c:399 vmw_cmdbuf_ctx_process+0x258/0x280 [vmwgfx]

Root Cause

increasing guest mob limits come from ./drivers/gpu/drm/vmwgfx/vmwgfx_gmrid_manager.c

    52  static int vmw_gmrid_man_get_node(struct ttm_resource_manager *man,
    53                                    struct ttm_buffer_object *bo,
    54                                    const struct ttm_place *place,
    55                                    struct ttm_resource **res)
    56  {
    57          struct vmwgfx_gmrid_man *gman = to_gmrid_manager(man);
    58          int id;
    59  
    60          *res = kmalloc(sizeof(**res), GFP_KERNEL);
    61          if (!*res)
    62                  return -ENOMEM;
    63  
    64          ttm_resource_init(bo, place, *res);
    65  
    66          id = ida_alloc_max(&gman->gmr_ida, gman->max_gmr_ids - 1, GFP_KERNEL);
    67          if (id < 0)
    68                  return id;
    69  
    70          spin_lock(&gman->lock);
    71  
    72          if (gman->max_gmr_pages > 0) {
    73                  gman->used_gmr_pages += PFN_UP((*res)->size);
    74                  /*
    75                   * Because the graphics memory is a soft limit we can try to
    76                   * expand it instead of letting the userspace apps crash.
    77                   * We're just going to have a sane limit (half of RAM)
    78                   * on the number of MOB's that we create and will try to keep
    79                   * the system running until we reach that.
    80                   */
    81                  if (unlikely(gman->used_gmr_pages > gman->max_gmr_pages)) {
    82                          const unsigned long max_graphics_pages = totalram_pages() / 2;
    83                          uint32_t new_max_pages = 0;
    84  
    85                          DRM_WARN("vmwgfx: mob memory overflow. Consider increasing guest RAM and graphicsMemory.\n");
    86                          vmw_host_printf("vmwgfx, warning: mob memory overflow. Consider increasing guest RAM and graphicsMemory.\n");
    87  
    88                          if (gman->max_gmr_pages > (max_graphics_pages / 2)) {
    89                                  DRM_WARN("vmwgfx: guest requires more than half of RAM for graphics.\n");
    90                                  new_max_pages = max_graphics_pages;
    91                          } else
    92                                  new_max_pages = gman->max_gmr_pages * 2;
    93                          if (new_max_pages > gman->max_gmr_pages && new_max_pages >= gman->used_gmr_pages) {
    94                                  DRM_WARN("vmwgfx: increasing guest mob limits to %u kB.\n",          <<-------
    95                                           ((new_max_pages) << (PAGE_SHIFT - 10)));
    96  
    97                                  gman->max_gmr_pages = new_max_pages;
    98                          } else {
    99                                  char buf[256];
   100                                  snprintf(buf, sizeof(buf),
   101                                           "vmwgfx, error: guest graphics is out of memory (mob limit at: %ukB).\n",
   102                                           ((gman->max_gmr_pages) << (PAGE_SHIFT - 10)));
   103                                  vmw_host_printf(buf);
   104                                  DRM_WARN("%s", buf);
   105                                  goto nospace;
   106                          }
   107                  }
   108          }
   109  
   110          (*res)->start = id;
   111  
   112          spin_unlock(&gman->lock);
   113          return 0;
   114  
   115  nospace:
   116          gman->used_gmr_pages -= PFN_UP((*res)->size);
   117          spin_unlock(&gman->lock);
   118          ida_free(&gman->gmr_ida, id);
   119          ttm_resource_fini(man, *res);
   120          kfree(*res);
   121          return -ENOSPC;
   122  }

Command buffer error comes from ./drivers/gpu/drm/vmwgfx/vmwgfx_cmdbuf.c

   366  /**
   367   * vmw_cmdbuf_ctx_process - Process a command buffer context.
   368   *
   369   * @man: The command buffer manager.
   370   * @ctx: The command buffer context.
   371   * @notempty: Pass back count of non-empty command submitted lists.
   372   *
   373   * Submit command buffers to hardware if possible, and process finished
   374   * buffers. Typically freeing them, but on preemption or error take
   375   * appropriate action. Wake up waiters if appropriate.
   376   */
   377  static void vmw_cmdbuf_ctx_process(struct vmw_cmdbuf_man *man,
   378                                     struct vmw_cmdbuf_context *ctx,
   379                                     int *notempty)
   380  {
   381          struct vmw_cmdbuf_header *entry, *next;
   382  
   383          vmw_cmdbuf_ctx_submit(man, ctx);
   384  
   385          list_for_each_entry_safe(entry, next, &ctx->hw_submitted, list) {
   386                  SVGACBStatus status = entry->cb_header->status;
   387  
   388                  if (status == SVGA_CB_STATUS_NONE)
   389                          break;
   390  
   391                  list_del(&entry->list);
   392                  wake_up_all(&man->idle_queue);
   393                  ctx->num_hw_submitted--;
   394                  switch (status) {
   395                  case SVGA_CB_STATUS_COMPLETED:
   396                          __vmw_cmdbuf_header_free(entry);
   397                          break;
   398                  case SVGA_CB_STATUS_COMMAND_ERROR:
   399                          WARN_ONCE(true, "Command buffer error.\n");              <<<<-----
   400                          entry->cb_header->status = SVGA_CB_STATUS_NONE;
   401                          list_add_tail(&entry->list, &man->error);
   402                          schedule_work(&man->work);
   403                          break;
   404                  case SVGA_CB_STATUS_PREEMPTED:
   405                          entry->cb_header->status = SVGA_CB_STATUS_NONE;
   406                          list_add_tail(&entry->list, &ctx->preempted);
   407                          break;
   408                  case SVGA_CB_STATUS_CB_HEADER_ERROR:
   409                          WARN_ONCE(true, "Command buffer header error.\n");
   410                          __vmw_cmdbuf_header_free(entry);
   411                          break;
   412                  default:
   413                          WARN_ONCE(true, "Undefined command buffer status.\n");
   414                          __vmw_cmdbuf_header_free(entry);
   415                          break;
   416                  }
   417          }
   418  
   419          vmw_cmdbuf_ctx_submit(man, ctx);
   420          if (!list_empty(&ctx->submitted))
   421                  (*notempty)++;
   422  }