drm/amd: Add Suspend/Hibernate notification callback support

As part of the suspend sequence VRAM needs to be evicted on dGPUs.
In order to make suspend/resume more reliable we moved this into
the pmops prepare() callback so that the suspend sequence would fail
but the system could remain operational under high memory usage suspend.

Another class of issues exist though where due to memory fragementation
there isn't a large enough contiguous space and swap isn't accessible.

Add support for a suspend/hibernate notification callback that could
evict VRAM before tasks are frozen. This should allow paging out to swap
if necessary.

Link: https://github.com/ROCm/ROCK-Kernel-Driver/issues/174
Link: https://gitlab.freedesktop.org/drm/amd/-/issues/3476
Closes: https://gitlab.freedesktop.org/drm/amd/-/issues/2362
Closes: https://gitlab.freedesktop.org/drm/amd/-/issues/3781
Reviewed-by: Lijo Lazar <lijo.lazar@amd.com>
Link: https://lore.kernel.org/r/20241128032656.2090059-2-superm1@kernel.org
Signed-off-by: Mario Limonciello <mario.limonciello@amd.com>
Signed-off-by: Alex Deucher <alexander.deucher@amd.com>

diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu.h b/drivers/gpu/drm/amd/amdgpu/amdgpu.h
index 4653a8d..9f5351c 100644 (file)
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu.h
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu.h
@@ -880,6 +880,7 @@ struct amdgpu_device {
        bool                            need_swiotlb;
        bool                            accel_working;
        struct notifier_block           acpi_nb;
+       struct notifier_block           pm_nb;
        struct amdgpu_i2c_chan          *i2c_bus[AMDGPU_MAX_I2C_BUS];
        struct debugfs_blob_wrapper     debugfs_vbios_blob;
        struct debugfs_blob_wrapper     debugfs_discovery_blob;

diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c
index 69109f5..d44123d 100644 (file)
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c
@@ -199,6 +199,8 @@ void amdgpu_set_init_level(struct amdgpu_device *adev,
 }
 
 static inline void amdgpu_device_stop_pending_resets(struct amdgpu_device *adev);
+static int amdgpu_device_pm_notifier(struct notifier_block *nb, unsigned long mode,
+                                    void *data);
 
 /**
  * DOC: pcie_replay_count
@@ -4596,6 +4598,11 @@ fence_driver_init:
 
        amdgpu_device_check_iommu_direct_map(adev);
 
+       adev->pm_nb.notifier_call = amdgpu_device_pm_notifier;
+       r = register_pm_notifier(&adev->pm_nb);
+       if (r)
+               goto failed;
+
        return 0;
 
 release_ras_con:
@@ -4660,6 +4667,8 @@ void amdgpu_device_fini_hw(struct amdgpu_device *adev)
                drain_workqueue(adev->mman.bdev.wq);
        adev->shutdown = true;
 
+       unregister_pm_notifier(&adev->pm_nb);
+
        /* make sure IB test finished before entering exclusive mode
         * to avoid preemption on IB test
         */
@@ -4791,6 +4800,41 @@ static int amdgpu_device_evict_resources(struct amdgpu_device *adev)
 /*
  * Suspend & resume.
  */
+/**
+ * amdgpu_device_pm_notifier - Notification block for Suspend/Hibernate events
+ * @nb: notifier block
+ * @mode: suspend mode
+ * @data: data
+ *
+ * This function is called when the system is about to suspend or hibernate.
+ * It is used to evict resources from the device before the system goes to
+ * sleep while there is still access to swap.
+ */
+static int amdgpu_device_pm_notifier(struct notifier_block *nb, unsigned long mode,
+                                    void *data)
+{
+       struct amdgpu_device *adev = container_of(nb, struct amdgpu_device, pm_nb);
+       int r;
+
+       switch (mode) {
+       case PM_HIBERNATION_PREPARE:
+               adev->in_s4 = true;
+               fallthrough;
+       case PM_SUSPEND_PREPARE:
+               r = amdgpu_device_evict_resources(adev);
+               /*
+                * This is considered non-fatal at this time because
+                * amdgpu_device_prepare() will also fatally evict resources.
+                * See https://gitlab.freedesktop.org/drm/amd/-/issues/3781
+                */
+               if (r)
+                       drm_warn(adev_to_drm(adev), "Failed to evict resources, freeze active processes if problems occur: %d\n", r);
+               break;
+       }
+
+       return NOTIFY_DONE;
+}
+
 /**
  * amdgpu_device_prepare - prepare for device suspend
  *
@@ -4830,7 +4874,7 @@ int amdgpu_device_prepare(struct drm_device *dev)
        return 0;
 
 unprepare:
-       adev->in_s0ix = adev->in_s3 = false;
+       adev->in_s0ix = adev->in_s3 = adev->in_s4 = false;
 
        return r;
 }

diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c
index 3868620..5e5ab0b 100644 (file)
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c
@@ -2552,7 +2552,6 @@ static int amdgpu_pmops_freeze(struct device *dev)
        struct amdgpu_device *adev = drm_to_adev(drm_dev);
        int r;
 
-       adev->in_s4 = true;
        r = amdgpu_device_suspend(drm_dev, true);
        adev->in_s4 = false;
        if (r)