rq = i915_active_request_raw(&timeline->last_request,
                                     &engine->i915->drm.struct_mutex);
        if (rq && rq->engine == engine) {
-               GEM_TRACE("last request for %s on engine %s: %llx:%llu\n",
-                         timeline->name, engine->name,
-                         rq->fence.context, rq->fence.seqno);
+               GEM_TRACE("last request on engine %s: %llx:%llu\n",
+                         engine->name, rq->fence.context, rq->fence.seqno);
                GEM_BUG_ON(rq->timeline != timeline);
                return rq;
        }
 
        if (test_bit(DMA_FENCE_FLAG_SIGNALED_BIT, &fence->flags))
                return "signaled";
 
-       return to_request(fence)->timeline->name;
+       return to_request(fence)->gem_context->name ?: "[i915]";
 }
 
 static bool i915_fence_signaled(struct dma_fence *fence)
                 * is just about to be. Either works, if we miss the last two
                 * noops - they are safe to be replayed on a reset.
                 */
-               GEM_TRACE("marking %s as inactive\n", ring->timeline->name);
                tail = READ_ONCE(request->tail);
                list_del(&ring->active_link);
        } else {
        __i915_active_request_set(&timeline->last_request, request);
 
        list_add_tail(&request->ring_link, &ring->request_list);
-       if (list_is_first(&request->ring_link, &ring->request_list)) {
-               GEM_TRACE("marking %s as active\n", ring->timeline->name);
+       if (list_is_first(&request->ring_link, &ring->request_list))
                list_add(&ring->active_link, &request->i915->gt.active_rings);
-       }
        request->i915->gt.active_engines |= request->engine->mask;
        request->emitted_jiffies = jiffies;
 
 
 
 int i915_timeline_init(struct drm_i915_private *i915,
                       struct i915_timeline *timeline,
-                      const char *name,
                       struct i915_vma *hwsp)
 {
        void *vaddr;
        BUILD_BUG_ON(KSYNCMAP < I915_NUM_ENGINES);
 
        timeline->i915 = i915;
-       timeline->name = name;
        timeline->pin_count = 0;
        timeline->has_initial_breadcrumb = !hwsp;
        timeline->hwsp_cacheline = NULL;
 
 struct i915_timeline *
 i915_timeline_create(struct drm_i915_private *i915,
-                    const char *name,
                     struct i915_vma *global_hwsp)
 {
        struct i915_timeline *timeline;
        if (!timeline)
                return ERR_PTR(-ENOMEM);
 
-       err = i915_timeline_init(i915, timeline, name, global_hwsp);
+       err = i915_timeline_init(i915, timeline, global_hwsp);
        if (err) {
                kfree(timeline);
                return ERR_PTR(err);
 
 
 int i915_timeline_init(struct drm_i915_private *i915,
                       struct i915_timeline *tl,
-                      const char *name,
                       struct i915_vma *hwsp);
 void i915_timeline_fini(struct i915_timeline *tl);
 
 
 struct i915_timeline *
 i915_timeline_create(struct drm_i915_private *i915,
-                    const char *name,
                     struct i915_vma *global_hwsp);
 
 static inline struct i915_timeline *
 
        struct i915_active_request barrier;
 
        struct list_head link;
-       const char *name;
        struct drm_i915_private *i915;
 
        struct kref kref;
 
 
        err = i915_timeline_init(engine->i915,
                                 &engine->timeline,
-                                engine->name,
                                 engine->status_page.vma);
        if (err)
                goto err_hwsp;
                return -ENOMEM;
 
        if (i915_timeline_init(engine->i915,
-                              &frame->timeline, "measure",
+                              &frame->timeline,
                               engine->status_page.vma))
                goto out_frame;
 
 
 
 static struct i915_timeline *get_timeline(struct i915_gem_context *ctx)
 {
-       return i915_timeline_create(ctx->i915, ctx->name, NULL);
+       return i915_timeline_create(ctx->i915, NULL);
 }
 
 static int execlists_context_deferred_alloc(struct intel_context *ce,
 
        if (err)
                return err;
 
-       timeline = i915_timeline_create(engine->i915,
-                                       engine->name,
-                                       engine->status_page.vma);
+       timeline = i915_timeline_create(engine->i915, engine->status_page.vma);
        if (IS_ERR(timeline)) {
                err = PTR_ERR(timeline);
                goto err;
 
                unsigned long cacheline;
                int err;
 
-               tl = i915_timeline_create(state->i915, "mock", NULL);
+               tl = i915_timeline_create(state->i915, NULL);
                if (IS_ERR(tl))
                        return PTR_ERR(tl);
 
 {
        struct i915_timeline *tl;
 
-       tl = i915_timeline_create(i915, "live", NULL);
+       tl = i915_timeline_create(i915, NULL);
        if (IS_ERR(tl))
                return tl;
 
        mutex_lock(&i915->drm.struct_mutex);
        wakeref = intel_runtime_pm_get(i915);
 
-       tl = i915_timeline_create(i915, __func__, NULL);
+       tl = i915_timeline_create(i915, NULL);
        if (IS_ERR(tl)) {
                err = PTR_ERR(tl);
                goto out_rpm;
 
        if (!ring)
                return NULL;
 
-       if (i915_timeline_init(engine->i915,
-                              &ring->timeline, engine->name,
-                              NULL)) {
+       if (i915_timeline_init(engine->i915, &ring->timeline, NULL)) {
                kfree(ring);
                return NULL;
        }
        engine->base.reset.finish = mock_reset_finish;
        engine->base.cancel_requests = mock_cancel_requests;
 
-       if (i915_timeline_init(i915,
-                              &engine->base.timeline,
-                              engine->base.name,
-                              NULL))
+       if (i915_timeline_init(i915, &engine->base.timeline, NULL))
                goto err_free;
        i915_timeline_set_subclass(&engine->base.timeline, TIMELINE_ENGINE);