lkml.org 
[lkml]   [2021]   [Dec]   [14]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Date
    Subject[PATCH 27/43] x86: kmsan: add iomem support
    From
    Functions from lib/iomap.c and arch/x86/lib/iomem.c interact with hardware,
    so KMSAN must ensure that:
    - every read function returns an initialized value
    - every write function checks values before sending them to hardware.

    Signed-off-by: Alexander Potapenko <glider@google.com>

    ---
    Link: https://linux-review.googlesource.com/id/I45527599f09090aca046dfe1a26df453adab100d
    ---
    arch/x86/lib/iomem.c | 5 +++++
    lib/iomap.c | 40 ++++++++++++++++++++++++++++++++++++++++
    2 files changed, 45 insertions(+)

    diff --git a/arch/x86/lib/iomem.c b/arch/x86/lib/iomem.c
    index df50451d94ef7..2307770f3f4c8 100644
    --- a/arch/x86/lib/iomem.c
    +++ b/arch/x86/lib/iomem.c
    @@ -1,6 +1,7 @@
    #include <linux/string.h>
    #include <linux/module.h>
    #include <linux/io.h>
    +#include <linux/kmsan-checks.h>

    #define movs(type,to,from) \
    asm volatile("movs" type:"=&D" (to), "=&S" (from):"0" (to), "1" (from):"memory")
    @@ -37,6 +38,8 @@ void memcpy_fromio(void *to, const volatile void __iomem *from, size_t n)
    n-=2;
    }
    rep_movs(to, (const void *)from, n);
    + /* KMSAN must treat values read from devices as initialized. */
    + kmsan_unpoison_memory(to, n);
    }
    EXPORT_SYMBOL(memcpy_fromio);

    @@ -45,6 +48,8 @@ void memcpy_toio(volatile void __iomem *to, const void *from, size_t n)
    if (unlikely(!n))
    return;

    + /* Make sure uninitialized memory isn't copied to devices. */
    + kmsan_check_memory(from, n);
    /* Align any unaligned destination IO */
    if (unlikely(1 & (unsigned long)to)) {
    movs("b", to, from);
    diff --git a/lib/iomap.c b/lib/iomap.c
    index fbaa3e8f19d6c..bdda1a42771b2 100644
    --- a/lib/iomap.c
    +++ b/lib/iomap.c
    @@ -6,6 +6,7 @@
    */
    #include <linux/pci.h>
    #include <linux/io.h>
    +#include <linux/kmsan-checks.h>

    #include <linux/export.h>

    @@ -70,26 +71,31 @@ static void bad_io_access(unsigned long port, const char *access)
    #define mmio_read64be(addr) swab64(readq(addr))
    #endif

    +__no_sanitize_memory
    unsigned int ioread8(const void __iomem *addr)
    {
    IO_COND(addr, return inb(port), return readb(addr));
    return 0xff;
    }
    +__no_sanitize_memory
    unsigned int ioread16(const void __iomem *addr)
    {
    IO_COND(addr, return inw(port), return readw(addr));
    return 0xffff;
    }
    +__no_sanitize_memory
    unsigned int ioread16be(const void __iomem *addr)
    {
    IO_COND(addr, return pio_read16be(port), return mmio_read16be(addr));
    return 0xffff;
    }
    +__no_sanitize_memory
    unsigned int ioread32(const void __iomem *addr)
    {
    IO_COND(addr, return inl(port), return readl(addr));
    return 0xffffffff;
    }
    +__no_sanitize_memory
    unsigned int ioread32be(const void __iomem *addr)
    {
    IO_COND(addr, return pio_read32be(port), return mmio_read32be(addr));
    @@ -142,18 +148,21 @@ static u64 pio_read64be_hi_lo(unsigned long port)
    return lo | (hi << 32);
    }

    +__no_sanitize_memory
    u64 ioread64_lo_hi(const void __iomem *addr)
    {
    IO_COND(addr, return pio_read64_lo_hi(port), return readq(addr));
    return 0xffffffffffffffffULL;
    }

    +__no_sanitize_memory
    u64 ioread64_hi_lo(const void __iomem *addr)
    {
    IO_COND(addr, return pio_read64_hi_lo(port), return readq(addr));
    return 0xffffffffffffffffULL;
    }

    +__no_sanitize_memory
    u64 ioread64be_lo_hi(const void __iomem *addr)
    {
    IO_COND(addr, return pio_read64be_lo_hi(port),
    @@ -161,6 +170,7 @@ u64 ioread64be_lo_hi(const void __iomem *addr)
    return 0xffffffffffffffffULL;
    }

    +__no_sanitize_memory
    u64 ioread64be_hi_lo(const void __iomem *addr)
    {
    IO_COND(addr, return pio_read64be_hi_lo(port),
    @@ -188,22 +198,32 @@ EXPORT_SYMBOL(ioread64be_hi_lo);

    void iowrite8(u8 val, void __iomem *addr)
    {
    + /* Make sure uninitialized memory isn't copied to devices. */
    + kmsan_check_memory(&val, sizeof(val));
    IO_COND(addr, outb(val,port), writeb(val, addr));
    }
    void iowrite16(u16 val, void __iomem *addr)
    {
    + /* Make sure uninitialized memory isn't copied to devices. */
    + kmsan_check_memory(&val, sizeof(val));
    IO_COND(addr, outw(val,port), writew(val, addr));
    }
    void iowrite16be(u16 val, void __iomem *addr)
    {
    + /* Make sure uninitialized memory isn't copied to devices. */
    + kmsan_check_memory(&val, sizeof(val));
    IO_COND(addr, pio_write16be(val,port), mmio_write16be(val, addr));
    }
    void iowrite32(u32 val, void __iomem *addr)
    {
    + /* Make sure uninitialized memory isn't copied to devices. */
    + kmsan_check_memory(&val, sizeof(val));
    IO_COND(addr, outl(val,port), writel(val, addr));
    }
    void iowrite32be(u32 val, void __iomem *addr)
    {
    + /* Make sure uninitialized memory isn't copied to devices. */
    + kmsan_check_memory(&val, sizeof(val));
    IO_COND(addr, pio_write32be(val,port), mmio_write32be(val, addr));
    }
    EXPORT_SYMBOL(iowrite8);
    @@ -239,24 +259,32 @@ static void pio_write64be_hi_lo(u64 val, unsigned long port)

    void iowrite64_lo_hi(u64 val, void __iomem *addr)
    {
    + /* Make sure uninitialized memory isn't copied to devices. */
    + kmsan_check_memory(&val, sizeof(val));
    IO_COND(addr, pio_write64_lo_hi(val, port),
    writeq(val, addr));
    }

    void iowrite64_hi_lo(u64 val, void __iomem *addr)
    {
    + /* Make sure uninitialized memory isn't copied to devices. */
    + kmsan_check_memory(&val, sizeof(val));
    IO_COND(addr, pio_write64_hi_lo(val, port),
    writeq(val, addr));
    }

    void iowrite64be_lo_hi(u64 val, void __iomem *addr)
    {
    + /* Make sure uninitialized memory isn't copied to devices. */
    + kmsan_check_memory(&val, sizeof(val));
    IO_COND(addr, pio_write64be_lo_hi(val, port),
    mmio_write64be(val, addr));
    }

    void iowrite64be_hi_lo(u64 val, void __iomem *addr)
    {
    + /* Make sure uninitialized memory isn't copied to devices. */
    + kmsan_check_memory(&val, sizeof(val));
    IO_COND(addr, pio_write64be_hi_lo(val, port),
    mmio_write64be(val, addr));
    }
    @@ -328,14 +356,20 @@ static inline void mmio_outsl(void __iomem *addr, const u32 *src, int count)
    void ioread8_rep(const void __iomem *addr, void *dst, unsigned long count)
    {
    IO_COND(addr, insb(port,dst,count), mmio_insb(addr, dst, count));
    + /* KMSAN must treat values read from devices as initialized. */
    + kmsan_unpoison_memory(dst, count);
    }
    void ioread16_rep(const void __iomem *addr, void *dst, unsigned long count)
    {
    IO_COND(addr, insw(port,dst,count), mmio_insw(addr, dst, count));
    + /* KMSAN must treat values read from devices as initialized. */
    + kmsan_unpoison_memory(dst, count * 2);
    }
    void ioread32_rep(const void __iomem *addr, void *dst, unsigned long count)
    {
    IO_COND(addr, insl(port,dst,count), mmio_insl(addr, dst, count));
    + /* KMSAN must treat values read from devices as initialized. */
    + kmsan_unpoison_memory(dst, count * 4);
    }
    EXPORT_SYMBOL(ioread8_rep);
    EXPORT_SYMBOL(ioread16_rep);
    @@ -343,14 +377,20 @@ EXPORT_SYMBOL(ioread32_rep);

    void iowrite8_rep(void __iomem *addr, const void *src, unsigned long count)
    {
    + /* Make sure uninitialized memory isn't copied to devices. */
    + kmsan_check_memory(src, count);
    IO_COND(addr, outsb(port, src, count), mmio_outsb(addr, src, count));
    }
    void iowrite16_rep(void __iomem *addr, const void *src, unsigned long count)
    {
    + /* Make sure uninitialized memory isn't copied to devices. */
    + kmsan_check_memory(src, count * 2);
    IO_COND(addr, outsw(port, src, count), mmio_outsw(addr, src, count));
    }
    void iowrite32_rep(void __iomem *addr, const void *src, unsigned long count)
    {
    + /* Make sure uninitialized memory isn't copied to devices. */
    + kmsan_check_memory(src, count * 4);
    IO_COND(addr, outsl(port, src,count), mmio_outsl(addr, src, count));
    }
    EXPORT_SYMBOL(iowrite8_rep);
    --
    2.34.1.173.g76aa8bc2d0-goog
    \
     
     \ /
      Last update: 2021-12-14 17:24    [W:2.667 / U:0.348 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site