iommu/amd: Fix illegal cap/mmio access in IOMMU debugfs

In the current AMD IOMMU debugfs, when multiple processes simultaneously
access the IOMMU mmio/cap registers using the IOMMU debugfs, illegal
access issues can occur in the following execution flow:

1. CPU1: Sets a valid access address using iommu_mmio/capability_write,
and verifies the access address's validity in iommu_mmio/capability_show

2. CPU2: Sets an invalid address using iommu_mmio/capability_write

3. CPU1: accesses the IOMMU mmio/cap registers based on the invalid
address, resulting in an illegal access.

This patch modifies the execution process to first verify the address's
validity and then access it based on the same address, ensuring
correctness and robustness.

Signed-off-by: Guanghui Feng <guanghuifeng@linux.alibaba.com>
Signed-off-by: Joerg Roedel <joerg.roedel@amd.com>

diff --git a/drivers/iommu/amd/debugfs.c b/drivers/iommu/amd/debugfs.c
index 0b03e0622f67e8962e4c7c1a78b689bdca4c4817..4e66473d7ceafecd0a9c69a0bd869b8cea4a7145 100644 (file)
--- a/drivers/iommu/amd/debugfs.c
+++ b/drivers/iommu/amd/debugfs.c
@@ -26,22 +26,19 @@ static ssize_t iommu_mmio_write(struct file *filp, const char __user *ubuf,
 {
        struct seq_file *m = filp->private_data;
        struct amd_iommu *iommu = m->private;
-       int ret;
-
-       iommu->dbg_mmio_offset = -1;
+       int ret, dbg_mmio_offset = iommu->dbg_mmio_offset = -1;
 
        if (cnt > OFS_IN_SZ)
                return -EINVAL;
 
-       ret = kstrtou32_from_user(ubuf, cnt, 0, &iommu->dbg_mmio_offset);
+       ret = kstrtou32_from_user(ubuf, cnt, 0, &dbg_mmio_offset);
        if (ret)
                return ret;
 
-       if (iommu->dbg_mmio_offset > iommu->mmio_phys_end - sizeof(u64)) {
-               iommu->dbg_mmio_offset = -1;
-               return  -EINVAL;
-       }
+       if (dbg_mmio_offset > iommu->mmio_phys_end - sizeof(u64))
+               return -EINVAL;
 
+       iommu->dbg_mmio_offset = dbg_mmio_offset;
        return cnt;
 }
 
@@ -49,14 +46,16 @@ static int iommu_mmio_show(struct seq_file *m, void *unused)
 {
        struct amd_iommu *iommu = m->private;
        u64 value;
+       int dbg_mmio_offset = iommu->dbg_mmio_offset;
 
-       if (iommu->dbg_mmio_offset < 0) {
+       if (dbg_mmio_offset < 0 || dbg_mmio_offset >
+                       iommu->mmio_phys_end - sizeof(u64)) {
                seq_puts(m, "Please provide mmio register's offset\n");
                return 0;
        }
 
-       value = readq(iommu->mmio_base + iommu->dbg_mmio_offset);
-       seq_printf(m, "Offset:0x%x Value:0x%016llx\n", iommu->dbg_mmio_offset, value);
+       value = readq(iommu->mmio_base + dbg_mmio_offset);
+       seq_printf(m, "Offset:0x%x Value:0x%016llx\n", dbg_mmio_offset, value);
 
        return 0;
 }
@@ -67,23 +66,20 @@ static ssize_t iommu_capability_write(struct file *filp, const char __user *ubuf
 {
        struct seq_file *m = filp->private_data;
        struct amd_iommu *iommu = m->private;
-       int ret;
-
-       iommu->dbg_cap_offset = -1;
+       int ret, dbg_cap_offset = iommu->dbg_cap_offset = -1;
 
        if (cnt > OFS_IN_SZ)
                return -EINVAL;
 
-       ret = kstrtou32_from_user(ubuf, cnt, 0, &iommu->dbg_cap_offset);
+       ret = kstrtou32_from_user(ubuf, cnt, 0, &dbg_cap_offset);
        if (ret)
                return ret;
 
        /* Capability register at offset 0x14 is the last IOMMU capability register. */
-       if (iommu->dbg_cap_offset > 0x14) {
-               iommu->dbg_cap_offset = -1;
+       if (dbg_cap_offset > 0x14)
                return -EINVAL;
-       }
 
+       iommu->dbg_cap_offset = dbg_cap_offset;
        return cnt;
 }
 
@@ -91,21 +87,21 @@ static int iommu_capability_show(struct seq_file *m, void *unused)
 {
        struct amd_iommu *iommu = m->private;
        u32 value;
-       int err;
+       int err, dbg_cap_offset = iommu->dbg_cap_offset;
 
-       if (iommu->dbg_cap_offset < 0) {
+       if (dbg_cap_offset < 0 || dbg_cap_offset > 0x14) {
                seq_puts(m, "Please provide capability register's offset in the range [0x00 - 0x14]\n");
                return 0;
        }
 
-       err = pci_read_config_dword(iommu->dev, iommu->cap_ptr + iommu->dbg_cap_offset, &value);
+       err = pci_read_config_dword(iommu->dev, iommu->cap_ptr + dbg_cap_offset, &value);
        if (err) {
                seq_printf(m, "Not able to read capability register at 0x%x\n",
-                          iommu->dbg_cap_offset);
+                          dbg_cap_offset);
                return 0;
        }
 
-       seq_printf(m, "Offset:0x%x Value:0x%08x\n", iommu->dbg_cap_offset, value);
+       seq_printf(m, "Offset:0x%x Value:0x%08x\n", dbg_cap_offset, value);
 
        return 0;
 }