fix(uio): consider "offset" from sysfs for unaligned UIO nodes

patrislav1 · patrislav1 · commit 38a142914f6b · 2025-03-06T15:40:00.000+01:00
sometimes a UIO node is not aligned to mmap boundary (e.g. 0xA5005040),
then sysfs will give an address (0xA5005000) and an offset (0x40).
use the address for mmapping and consider the offset for accesses.
diff --git a/inc/udmaio/HwAccessor.hpp b/inc/udmaio/HwAccessor.hpp
@@ -11,6 +11,7 @@
 
 #pragma once
 
+#include <cstddef>
 #include <filesystem>
 #include <fstream>
 #include <iostream>
@@ -117,7 +118,7 @@ class HwAccessor : public Logger, private boost::noncopyable {
 template <typename max_access_width_t>
 class HwAccessorMmap : public HwAccessor {
   public:
-    HwAccessorMmap(std::string dev_path, UioRegion region, uintptr_t mmap_offs)
+    HwAccessorMmap(std::string dev_path, UioRegion region, uintptr_t mmap_offs, size_t access_offs)
         : HwAccessor(), _region{region} {
         BOOST_LOG_SEV(HwAccessor::_lg, bls::debug) << "dev name = " << dev_path;
 
@@ -128,28 +129,34 @@ class HwAccessorMmap : public HwAccessor {
         BOOST_LOG_SEV(HwAccessor::_lg, bls::trace) << "fd = " << _fd << ", size = " << _region.size;
 
         // create memory mapping
-        _mem = mmap(NULL, _region.size, PROT_READ | PROT_WRITE, MAP_SHARED, _fd, mmap_offs);
+        _mmap_mem = mmap(NULL, _region.size, PROT_READ | PROT_WRITE, MAP_SHARED, _fd, mmap_offs);
+        _access_mem = static_cast<void*>(static_cast<char*>(_mmap_mem) + access_offs);
+
         BOOST_LOG_SEV(HwAccessor::_lg, bls::trace)
-            << "mmap = 0x" << std::hex << mmap_offs << " -> 0x" << _mem << std::dec;
+            << "mmap = 0x" << std::hex << mmap_offs << " -> 0x" << _mmap_mem << std::dec;
 
-        if (_mem == MAP_FAILED) {
-            throw std::runtime_error("mmap failed for uio " + dev_path);
+        if (_mmap_mem == MAP_FAILED) {
+            throw std::runtime_error("mmap failed for uio " + dev_path + ": " + strerror(errno));
         }
+
+        BOOST_LOG_SEV(HwAccessor::_lg, bls::trace)
+            << "access offs = 0x" << std::hex << access_offs << " -> 0x" << _access_mem << std::dec;
     }
 
     virtual ~HwAccessorMmap() {
-        munmap(_mem, _region.size);
+        munmap(_mmap_mem, _region.size);
         ::close(_fd);
     }
 
   protected:
     int _fd;
-    void* _mem;
+    void* _mmap_mem;
+    void* _access_mem;
     const UioRegion _region;
 
     template <typename access_width_t>
     inline volatile access_width_t* _mem_ptr(uint32_t offs) const {
-        return reinterpret_cast<access_width_t*>(static_cast<uint8_t*>(_mem) +
+        return reinterpret_cast<access_width_t*>(static_cast<uint8_t*>(_access_mem) +
                                                  static_cast<ptrdiff_t>(offs));
     }
 
@@ -217,8 +224,12 @@ class HwAccessorMmap : public HwAccessor {
     }
 
   public:
-    UioRegion get_phys_region() const final override { return _region; }
-    void* get_virt_mem() const final override { return _mem; }
+    UioRegion get_phys_region() const final override {
+        const size_t access_offs =
+            static_cast<uint8_t*>(_access_mem) - static_cast<uint8_t*>(_mmap_mem);
+        return {_region.addr + access_offs, _region.size - access_offs};
+    }
+    void* get_virt_mem() const final override { return _access_mem; }
 };
 
 // Hardware accessor for XDMA. Can support either 32 or 64 bit access
@@ -227,13 +238,15 @@ class HwAccessorXdma : public HwAccessorMmap<max_access_width_t> {
     int _fd_int;
 
   public:
+    // TODO: if we ever have to deal w/ unaligned mappings over XDMA (like on UIO), we'll have to pass an access_offs to HwAccessorMmap
     HwAccessorXdma(std::string xdma_path,
                    std::string evt_dev,
                    UioRegion region,
                    uintptr_t pcie_offs)
         : HwAccessorMmap<max_access_width_t>(xdma_path + "/user",
                                              {region.addr | pcie_offs, region.size},
-                                             region.addr) {
+                                             region.addr,
+                                             0) {
         if (!evt_dev.empty()) {
             const auto evt_path = xdma_path + "/" + evt_dev;
             _fd_int = ::open(evt_path.c_str(), O_RDWR);
@@ -259,7 +272,7 @@ class HwAccessorXdma : public HwAccessorMmap<max_access_width_t> {
 // Hardware accessor for AXI. Always supports 64 bit access
 class HwAccessorAxi : public HwAccessorMmap<uint64_t> {
   public:
-    HwAccessorAxi(std::string dev_path, UioRegion region, uintptr_t mmap_offs);
+    HwAccessorAxi(std::string dev_path, UioRegion region, uintptr_t mmap_offs, size_t access_offs);
     virtual ~HwAccessorAxi();
 
     int get_fd_int() const final override { return _fd; }
diff --git a/inc/udmaio/UioConfig.hpp b/inc/udmaio/UioConfig.hpp
@@ -84,7 +84,9 @@ class UioConfigBase {
 /// Creates HwAccessor from UioDeviceLocation (UIO version)
 class UioConfigUio : public UioConfigBase {
     static int _get_uio_number(std::string_view name);
+    static unsigned long long _get_uio_val(const std::string path);
     static UioRegion _get_map_region(int uio_number, int map_index);
+    static size_t _get_map_offset(int uio_number, int map_index);
 
   public:
     DmaMode mode() override { return DmaMode::UIO; };
diff --git a/src/HwAccessor.cpp b/src/HwAccessor.cpp
@@ -75,8 +75,11 @@ uint32_t HwAccessor::wait_for_interrupt() {
     return 0;
 }
 
-HwAccessorAxi::HwAccessorAxi(std::string dev_path, UioRegion region, uintptr_t mmap_offs)
-    : HwAccessorMmap<uint64_t>{dev_path, region, mmap_offs} {}
+HwAccessorAxi::HwAccessorAxi(std::string dev_path,
+                             UioRegion region,
+                             uintptr_t mmap_offs,
+                             size_t access_offs)
+    : HwAccessorMmap<uint64_t>{dev_path, region, mmap_offs, access_offs} {}
 
 HwAccessorAxi::~HwAccessorAxi() {}
 
diff --git a/src/UioConfig.cpp b/src/UioConfig.cpp
@@ -84,25 +84,39 @@ int UioConfigUio::_get_uio_number(std::string_view name) {
     return -1;
 }
 
+unsigned long long UioConfigUio::_get_uio_val(const std::string path) {
+    std::ifstream ifs{path};
+    if (!ifs) {
+        throw std::runtime_error("could not find " + path);
+    }
+    std::string size_str;
+    ifs >> size_str;
+    return std::stoull(size_str, nullptr, 0);
+}
+
 /** @brief gets a region for an uio map */
 UioRegion UioConfigUio::_get_map_region(int uio_number, int map_index) {
     const std::string base_path{"/sys/class/uio/uio" + std::to_string(uio_number) + "/maps/map" +
                                 std::to_string(map_index) + "/"};
 
-    auto get_val = [](const std::string path) -> unsigned long long {
-        std::ifstream ifs{path};
-        if (!ifs) {
-            throw std::runtime_error("could not find " + path);
-        }
-        std::string size_str;
-        ifs >> size_str;
-        return std::stoull(size_str, nullptr, 0);
+    auto region = UioRegion{
+        static_cast<uintptr_t>(_get_uio_val(base_path + "addr")),
+        static_cast<size_t>(_get_uio_val(base_path + "size")),
     };
 
-    return {
-        static_cast<uintptr_t>(get_val(base_path + "addr")),
-        static_cast<size_t>(get_val(base_path + "size")),
-    };
+    std::cout << "UIoRegion is " << region.size << " bytes at 0x" << std::hex << region.addr
+              << std::endl;
+    return region;
+}
+
+size_t UioConfigUio::_get_map_offset(int uio_number, int map_index) {
+    const std::string base_path{"/sys/class/uio/uio" + std::to_string(uio_number) + "/maps/map" +
+                                std::to_string(map_index) + "/"};
+
+    auto offset = static_cast<size_t>(_get_uio_val(base_path + "offset"));
+
+    std::cout << "UIoOffset is 0x" << std::hex << offset << std::endl;
+    return offset;
 }
 
 /** @brief gets device info (mem region, mmap offset, ...) from a uio name
@@ -154,7 +168,8 @@ HwAccessorPtr UioConfigUio::hw_acc(const UioDeviceLocation& dev_loc) const {
     }
     return std::make_shared<HwAccessorAxi>(std::string{"/dev/uio"} + std::to_string(uio_number),
                                            _get_map_region(uio_number, map_index),
-                                           static_cast<uintptr_t>(map_index * getpagesize()));
+                                           static_cast<uintptr_t>(map_index * getpagesize()),
+                                           _get_map_offset(uio_number, map_index));
 }
 
 UioConfigXdma::UioConfigXdma(std::string xdma_path, uintptr_t pcie_offs, bool x7_series_mode)
