rcu_read_lock();
                        task = pid_task(ctx->pid ?: file->pid, PIDTYPE_PID);
-                       snprintf(name, sizeof(name), "%s/%d",
-                                task ? task->comm : "<unknown>",
-                                ctx->user_handle);
+                       snprintf(name, sizeof(name), "%s",
+                                task ? task->comm : "<unknown>");
                        rcu_read_unlock();
 
                        print_file_stats(m, name, stats);
 
 
        /* And finally expose ourselves to userspace via the idr */
        mutex_lock(&fpriv->context_idr_lock);
-       ret = idr_alloc(&fpriv->context_idr, ctx,
-                       DEFAULT_CONTEXT_HANDLE, 0, GFP_KERNEL);
-       if (ret >= 0)
-               ctx->user_handle = ret;
+       ret = idr_alloc(&fpriv->context_idr, ctx, 0, 0, GFP_KERNEL);
        mutex_unlock(&fpriv->context_idr_lock);
-       if (ret < 0)
-               goto err_name;
-
-       return 0;
+       if (ret >= 0)
+               goto out;
 
-err_name:
        kfree(fetch_and_zero(&ctx->name));
 err_pid:
        put_pid(fetch_and_zero(&ctx->pid));
+out:
        return ret;
 }
 
        }
 
        err = gem_context_register(ctx, file_priv);
-       if (err)
+       if (err < 0)
                goto err_ctx;
 
-       GEM_BUG_ON(ctx->user_handle != DEFAULT_CONTEXT_HANDLE);
        GEM_BUG_ON(i915_gem_context_is_kernel(ctx));
+       GEM_BUG_ON(err > 0);
 
        return 0;
 
                return PTR_ERR(ctx);
 
        ret = gem_context_register(ctx, file_priv);
-       if (ret)
+       if (ret < 0)
                goto err_ctx;
 
-       args->ctx_id = ctx->user_handle;
+       args->ctx_id = ret;
        DRM_DEBUG("HW context %d created\n", args->ctx_id);
 
        return 0;
        if (args->pad != 0)
                return -EINVAL;
 
-       if (args->ctx_id == DEFAULT_CONTEXT_HANDLE)
+       if (!args->ctx_id)
                return -ENOENT;
 
        if (mutex_lock_interruptible(&file_priv->context_idr_lock))
 
        atomic_dec(&ctx->hw_id_pin_count);
 }
 
-static inline bool i915_gem_context_is_default(const struct i915_gem_context *c)
-{
-       return c->user_handle == DEFAULT_CONTEXT_HANDLE;
-}
-
 static inline bool i915_gem_context_is_kernel(struct i915_gem_context *ctx)
 {
        return !ctx->file_priv;
 
        struct list_head active_engines;
        struct mutex mutex;
 
-       /**
-        * @user_handle: userspace identifier
-        *
-        * A unique per-file identifier is generated from
-        * &drm_i915_file_private.contexts.
-        */
-       u32 user_handle;
-#define DEFAULT_CONTEXT_HANDLE 0
-
        struct i915_sched_attr sched;
 
        /** hw_contexts: per-engine logical HW state */
 
                                const char *header,
                                const struct drm_i915_error_context *ctx)
 {
-       err_printf(m, "%s%s[%d] user_handle %d hw_id %d, prio %d, guilty %d active %d\n",
-                  header, ctx->comm, ctx->pid, ctx->handle, ctx->hw_id,
+       err_printf(m, "%s%s[%d] hw_id %d, prio %d, guilty %d active %d\n",
+                  header, ctx->comm, ctx->pid, ctx->hw_id,
                   ctx->sched_attr.priority, ctx->guilty, ctx->active);
 }
 
                if (obj) {
                        err_puts(m, m->i915->engine[i]->name);
                        if (ee->context.pid)
-                               err_printf(m, " (submitted by %s [%d], ctx %d [%d])",
+                               err_printf(m, " (submitted by %s [%d])",
                                           ee->context.comm,
-                                          ee->context.pid,
-                                          ee->context.handle,
-                                          ee->context.hw_id);
+                                          ee->context.pid);
                        err_printf(m, " --- gtt_offset = 0x%08x %08x\n",
                                   upper_32_bits(obj->gtt_offset),
                                   lower_32_bits(obj->gtt_offset));
                rcu_read_unlock();
        }
 
-       e->handle = ctx->user_handle;
        e->hw_id = ctx->hw_id;
        e->sched_attr = ctx->sched;
        e->guilty = atomic_read(&ctx->guilty_count);
 
                struct drm_i915_error_context {
                        char comm[TASK_COMM_LEN];
                        pid_t pid;
-                       u32 handle;
                        u32 hw_id;
                        int active;
                        int guilty;
 
                return ctx;
 
        err = gem_context_register(ctx, file->driver_priv);
-       if (err)
+       if (err < 0)
                goto err_ctx;
 
        return ctx;