for (n = 0; n < ARRAY_SIZE(ctx->engine); n++) {
                if (ctx->engine[n].state)
                        per_file_stats(0, ctx->engine[n].state, data);
-               if (ctx->engine[n].ringbuf)
-                       per_file_stats(0, ctx->engine[n].ringbuf->obj, data);
+               if (ctx->engine[n].ring)
+                       per_file_stats(0, ctx->engine[n].ring->obj, data);
        }
 
        return 0;
                        seq_putc(m, ce->initialised ? 'I' : 'i');
                        if (ce->state)
                                describe_obj(m, ce->state);
-                       if (ce->ringbuf)
-                               describe_ctx_ringbuf(m, ce->ringbuf);
+                       if (ce->ring)
+                               describe_ctx_ringbuf(m, ce->ring);
                        seq_putc(m, '\n');
                }
 
 
                 * resubmit the request. See gen8_emit_request() for where we
                 * prepare the padding after the end of the request.
                 */
-               struct intel_ringbuffer *ringbuf;
-
-               ringbuf = req0->ctx->engine[engine->id].ringbuf;
                req0->tail += 8;
-               req0->tail &= ringbuf->size - 1;
+               req0->tail &= req0->ring->size - 1;
        }
 
        execlists_submit_requests(req0, req1);
                        return ret;
        }
 
-       request->ring = ce->ringbuf;
+       request->ring = ce->ring;
 
        if (i915.enable_guc_submission) {
                /*
 
        lrc_reg_state = vaddr + LRC_STATE_PN * PAGE_SIZE;
 
-       ret = intel_pin_and_map_ringbuffer_obj(dev_priv, ce->ringbuf);
+       ret = intel_pin_and_map_ringbuffer_obj(dev_priv, ce->ring);
        if (ret)
                goto unpin_map;
 
        ce->lrc_vma = i915_gem_obj_to_ggtt(ce->state);
        intel_lr_context_descriptor_update(ctx, engine);
 
-       lrc_reg_state[CTX_RING_BUFFER_START+1] = ce->ringbuf->vma->node.start;
+       lrc_reg_state[CTX_RING_BUFFER_START+1] = ce->ring->vma->node.start;
        ce->lrc_reg_state = lrc_reg_state;
        ce->state->dirty = true;
 
        if (--ce->pin_count)
                return;
 
-       intel_unpin_ringbuffer_obj(ce->ringbuf);
+       intel_unpin_ringbuffer_obj(ce->ring);
 
        i915_gem_object_unpin_map(ce->state);
        i915_gem_object_ggtt_unpin(ce->state);
        struct drm_i915_gem_object *ctx_obj;
        struct intel_context *ce = &ctx->engine[engine->id];
        uint32_t context_size;
-       struct intel_ringbuffer *ringbuf;
+       struct intel_ringbuffer *ring;
        int ret;
 
        WARN_ON(ce->state);
                return PTR_ERR(ctx_obj);
        }
 
-       ringbuf = intel_engine_create_ringbuffer(engine, ctx->ring_size);
-       if (IS_ERR(ringbuf)) {
-               ret = PTR_ERR(ringbuf);
+       ring = intel_engine_create_ringbuffer(engine, ctx->ring_size);
+       if (IS_ERR(ring)) {
+               ret = PTR_ERR(ring);
                goto error_deref_obj;
        }
 
-       ret = populate_lr_context(ctx, ctx_obj, engine, ringbuf);
+       ret = populate_lr_context(ctx, ctx_obj, engine, ring);
        if (ret) {
                DRM_DEBUG_DRIVER("Failed to populate LRC: %d\n", ret);
-               goto error_ringbuf;
+               goto error_ring_free;
        }
 
-       ce->ringbuf = ringbuf;
+       ce->ring = ring;
        ce->state = ctx_obj;
        ce->initialised = engine->init_context == NULL;
 
        return 0;
 
-error_ringbuf:
-       intel_ringbuffer_free(ringbuf);
+error_ring_free:
+       intel_ringbuffer_free(ring);
 error_deref_obj:
        i915_gem_object_put(ctx_obj);
-       ce->ringbuf = NULL;
+       ce->ring = NULL;
        ce->state = NULL;
        return ret;
 }
 
                i915_gem_object_unpin_map(ctx_obj);
 
-               ce->ringbuf->head = 0;
-               ce->ringbuf->tail = 0;
+               ce->ring->head = 0;
+               ce->ring->tail = 0;
        }
 }