amdgpu_ttm_placement_from_domain(bo, domain);
 
        r = ttm_bo_init_reserved(&adev->mman.bdev, &bo->tbo, size, type,
-                                &bo->placement, page_align, &ctx, NULL,
-                                acc_size, sg, resv, &amdgpu_ttm_bo_destroy);
+                                &bo->placement, page_align, &ctx, acc_size,
+                                sg, resv, &amdgpu_ttm_bo_destroy);
        if (unlikely(r != 0))
                return r;
 
 
 
        ret = ttm_bo_init(&ast->ttm.bdev, &astbo->bo, size,
                          ttm_bo_type_device, &astbo->placement,
-                         align >> PAGE_SHIFT, false, NULL, acc_size,
+                         align >> PAGE_SHIFT, false, acc_size,
                          NULL, NULL, ast_bo_ttm_destroy);
        if (ret)
                goto error;
 
 
        ret = ttm_bo_init(&bochs->ttm.bdev, &bochsbo->bo, size,
                          ttm_bo_type_device, &bochsbo->placement,
-                         align >> PAGE_SHIFT, false, NULL, acc_size,
+                         align >> PAGE_SHIFT, false, acc_size,
                          NULL, NULL, bochs_bo_ttm_destroy);
        if (ret)
                return ret;
 
 
        ret = ttm_bo_init(&cirrus->ttm.bdev, &cirrusbo->bo, size,
                          ttm_bo_type_device, &cirrusbo->placement,
-                         align >> PAGE_SHIFT, false, NULL, acc_size,
+                         align >> PAGE_SHIFT, false, acc_size,
                          NULL, NULL, cirrus_bo_ttm_destroy);
        if (ret)
                return ret;
 
 
        ret = ttm_bo_init(&hibmc->bdev, &hibmcbo->bo, size,
                          ttm_bo_type_device, &hibmcbo->placement,
-                         align >> PAGE_SHIFT, false, NULL, acc_size,
+                         align >> PAGE_SHIFT, false, acc_size,
                          NULL, NULL, hibmc_bo_ttm_destroy);
        if (ret) {
                hibmc_bo_unref(&hibmcbo);
 
 
        ret = ttm_bo_init(&mdev->ttm.bdev, &mgabo->bo, size,
                          ttm_bo_type_device, &mgabo->placement,
-                         align >> PAGE_SHIFT, false, NULL, acc_size,
+                         align >> PAGE_SHIFT, false, acc_size,
                          NULL, NULL, mgag200_bo_ttm_destroy);
        if (ret)
                return ret;
 
 
        ret = ttm_bo_init(&drm->ttm.bdev, &nvbo->bo, size,
                          type, &nvbo->placement,
-                         align >> PAGE_SHIFT, false, NULL, acc_size, sg,
+                         align >> PAGE_SHIFT, false, acc_size, sg,
                          robj, nouveau_bo_del_ttm);
        if (ret) {
                /* ttm will call nouveau_bo_del_ttm if it fails.. */
 
        qxl_ttm_placement_from_domain(bo, domain, pinned);
 
        r = ttm_bo_init(&qdev->mman.bdev, &bo->tbo, size, type,
-                       &bo->placement, 0, !kernel, NULL, size,
+                       &bo->placement, 0, !kernel, size,
                        NULL, NULL, &qxl_ttm_bo_destroy);
        if (unlikely(r != 0)) {
                if (r != -ERESTARTSYS)
 
        /* Kernel allocation are uninterruptible */
        down_read(&rdev->pm.mclk_lock);
        r = ttm_bo_init(&rdev->mman.bdev, &bo->tbo, size, type,
-                       &bo->placement, page_align, !kernel, NULL,
-                       acc_size, sg, resv, &radeon_ttm_bo_destroy);
+                       &bo->placement, page_align, !kernel, acc_size,
+                       sg, resv, &radeon_ttm_bo_destroy);
        up_read(&rdev->pm.mclk_lock);
        if (unlikely(r != 0)) {
                return r;
 
                         struct ttm_placement *placement,
                         uint32_t page_alignment,
                         struct ttm_operation_ctx *ctx,
-                        struct file *persistent_swap_storage,
                         size_t acc_size,
                         struct sg_table *sg,
                         struct reservation_object *resv,
        bo->mem.bus.io_reserved_count = 0;
        bo->moving = NULL;
        bo->mem.placement = (TTM_PL_FLAG_SYSTEM | TTM_PL_FLAG_CACHED);
-       bo->persistent_swap_storage = persistent_swap_storage;
        bo->acc_size = acc_size;
        bo->sg = sg;
        if (resv) {
                struct ttm_placement *placement,
                uint32_t page_alignment,
                bool interruptible,
-               struct file *persistent_swap_storage,
                size_t acc_size,
                struct sg_table *sg,
                struct reservation_object *resv,
        int ret;
 
        ret = ttm_bo_init_reserved(bdev, bo, size, type, placement,
-                                  page_alignment, &ctx,
-                                  persistent_swap_storage, acc_size,
+                                  page_alignment, &ctx, acc_size,
                                   sg, resv, destroy);
        if (ret)
                return ret;
                        struct ttm_placement *placement,
                        uint32_t page_alignment,
                        bool interruptible,
-                       struct file *persistent_swap_storage,
                        struct ttm_buffer_object **p_bo)
 {
        struct ttm_buffer_object *bo;
 
        acc_size = ttm_bo_acc_size(bdev, size, sizeof(struct ttm_buffer_object));
        ret = ttm_bo_init(bdev, bo, size, type, placement, page_alignment,
-                         interruptible, persistent_swap_storage, acc_size,
+                         interruptible, acc_size,
                          NULL, NULL, NULL);
        if (likely(ret == 0))
                *p_bo = bo;
 
        virtio_gpu_init_ttm_placement(bo, pinned);
 
        ret = ttm_bo_init(&vgdev->mman.bdev, &bo->tbo, size, type,
-                         &bo->placement, 0, !kernel, NULL, acc_size,
+                         &bo->placement, 0, !kernel, acc_size,
                          NULL, NULL, &virtio_gpu_ttm_bo_destroy);
        /* ttm_bo_init failure will call the destroy */
        if (ret != 0)
 
                        return -ENOMEM;
 
                ret = ttm_bo_create(&dev_priv->bdev, size, ttm_bo_type_device,
-                                   &vmw_mob_ne_placement, 0, false, NULL,
+                                   &vmw_mob_ne_placement, 0, false,
                                    &man->cmd_space);
                if (ret)
                        return ret;
 
        ret = ttm_bo_create(&dev_priv->bdev, bo_size,
                            ttm_bo_type_device,
                            &vmw_sys_ne_placement,
-                           0, false, NULL,
-                           &batch->otable_bo);
+                           0, false, &batch->otable_bo);
 
        if (unlikely(ret != 0))
                goto out_no_bo;
        ret = ttm_bo_create(&dev_priv->bdev, mob->num_pages * PAGE_SIZE,
                            ttm_bo_type_device,
                            &vmw_sys_ne_placement,
-                           0, false, NULL, &mob->pt_bo);
+                           0, false, &mob->pt_bo);
        if (unlikely(ret != 0))
                return ret;
 
 
 
        ret = ttm_bo_init(bdev, &vmw_bo->base, size,
                          ttm_bo_type_device, placement,
-                         0, interruptible,
-                         NULL, acc_size, NULL, NULL, bo_free);
+                         0, interruptible, acc_size,
+                         NULL, NULL, bo_free);
        return ret;
 }
 
 
 
        ret = ttm_bo_init(&vbox->ttm.bdev, &vboxbo->bo, size,
                          ttm_bo_type_device, &vboxbo->placement,
-                         align >> PAGE_SHIFT, false, NULL, acc_size,
+                         align >> PAGE_SHIFT, false, acc_size,
                          NULL, NULL, vbox_bo_ttm_destroy);
        if (ret)
                goto err_free_vboxbo;
 
  * @flags: Initial placement flags.
  * @page_alignment: Data alignment in pages.
  * @ctx: TTM operation context for memory allocation.
- * @persistent_swap_storage: Usually the swap storage is deleted for buffers
- * pinned in physical memory. If this behaviour is not desired, this member
- * holds a pointer to a persistent shmem object. Typically, this would
- * point to the shmem object backing a GEM object if TTM is used to back a
- * GEM user interface.
  * @acc_size: Accounted size for this object.
  * @resv: Pointer to a reservation_object, or NULL to let ttm allocate one.
  * @destroy: Destroy function. Use NULL for kfree().
                         struct ttm_placement *placement,
                         uint32_t page_alignment,
                         struct ttm_operation_ctx *ctx,
-                        struct file *persistent_swap_storage,
                         size_t acc_size,
                         struct sg_table *sg,
                         struct reservation_object *resv,
  * @page_alignment: Data alignment in pages.
  * @interruptible: If needing to sleep to wait for GPU resources,
  * sleep interruptible.
- * @persistent_swap_storage: Usually the swap storage is deleted for buffers
  * pinned in physical memory. If this behaviour is not desired, this member
  * holds a pointer to a persistent shmem object. Typically, this would
  * point to the shmem object backing a GEM object if TTM is used to back a
 int ttm_bo_init(struct ttm_bo_device *bdev, struct ttm_buffer_object *bo,
                unsigned long size, enum ttm_bo_type type,
                struct ttm_placement *placement,
-               uint32_t page_alignment, bool interrubtible,
-               struct file *persistent_swap_storage, size_t acc_size,
+               uint32_t page_alignment, bool interrubtible, size_t acc_size,
                struct sg_table *sg, struct reservation_object *resv,
                void (*destroy) (struct ttm_buffer_object *));
 
  * @page_alignment: Data alignment in pages.
  * @interruptible: If needing to sleep while waiting for GPU resources,
  * sleep interruptible.
- * @persistent_swap_storage: Usually the swap storage is deleted for buffers
- * pinned in physical memory. If this behaviour is not desired, this member
- * holds a pointer to a persistent shmem object. Typically, this would
- * point to the shmem object backing a GEM object if TTM is used to back a
- * GEM user interface.
  * @p_bo: On successful completion *p_bo points to the created object.
  *
  * This function allocates a ttm_buffer_object, and then calls ttm_bo_init
 int ttm_bo_create(struct ttm_bo_device *bdev, unsigned long size,
                  enum ttm_bo_type type, struct ttm_placement *placement,
                  uint32_t page_alignment, bool interruptible,
-                 struct file *persistent_swap_storage,
                  struct ttm_buffer_object **p_bo);
 
 /**