From 5693c8f2110e236772bf7abe7b3ea390f029c697 Mon Sep 17 00:00:00 2001

From: rpm-build <rpm-build>

Date: Thu, 22 Sep 2022 16:08:55 -0300

Subject: [PATCH] fix compilation on i386 and ppc64

Signed-off-by: Thanos Makatos <thanos.makatos@nutanix.com>

Reported-by: Eduardo Lima <eblima@gmail.com>

Signed-off-by: rpm-build <rpm-build>

---

 subprojects/libvfio-user/lib/dma.c            |  28 +++--

 subprojects/libvfio-user/lib/dma.h            |   3 +-

 subprojects/libvfio-user/lib/libvfio-user.c   |  81 ++++++++-----

 subprojects/libvfio-user/lib/migration.c      |  18 +--

 subprojects/libvfio-user/lib/pci.c            |  12 +-

 subprojects/libvfio-user/lib/pci_caps.c       |  12 +-

 subprojects/libvfio-user/lib/private.h        |   4 +

 subprojects/libvfio-user/lib/tran.c           |   2 +-

 subprojects/libvfio-user/lib/tran_pipe.c      |   2 +-

 subprojects/libvfio-user/samples/client.c     |  77 +++++++-----

 subprojects/libvfio-user/samples/server.c     |  15 ++-

 subprojects/libvfio-user/test/mocks.c         |   4 +-

 .../libvfio-user/test/py/libvfio_user.py      |  29 +++--

 .../test/py/test_device_get_region_info.py    |  18 +--

 .../libvfio-user/test/py/test_dirty_pages.py  | 110 ++++++++++--------

 .../libvfio-user/test/py/test_dma_map.py      |  28 ++---

 .../libvfio-user/test/py/test_dma_unmap.py    |  41 ++++---

 .../libvfio-user/test/py/test_migration.py    |   4 +-

 .../libvfio-user/test/py/test_pci_caps.py     |   7 +-

 .../libvfio-user/test/py/test_pci_ext_caps.py |   9 ++

 .../test/py/test_request_errors.py            |   6 +-

 subprojects/libvfio-user/test/unit-tests.c    |  10 +-

 22 files changed, 316 insertions(+), 204 deletions(-)

diff --git a/subprojects/libvfio-user/lib/dma.c b/subprojects/libvfio-user/lib/dma.c

index ac3ddfe..1ee8704 100644

--- a/subprojects/libvfio-user/lib/dma.c

+++ b/subprojects/libvfio-user/lib/dma.c

@@ -249,7 +249,7 @@ dma_map_region(dma_controller_t *dma, dma_memory_region_t *region)

     region->info.vaddr = mmap_base + (region->offset - offset);

     vfu_log(dma->vfu_ctx, LOG_DEBUG, "mapped DMA region iova=[%p, %p) "

-            "vaddr=%p page_size=%#lx mapping=[%p, %p)",

+            "vaddr=%p page_size=%zx mapping=[%p, %p)",

             region->info.iova.iov_base, iov_end(&region->info.iova),

             region->info.vaddr, region->info.page_size,

             region->info.mapping.iov_base, iov_end(&region->info.mapping));

@@ -290,7 +290,7 @@ dirty_page_logging_start_on_region(dma_memory_region_t *region, size_t pgsize)

 int

 MOCK_DEFINE(dma_controller_add_region)(dma_controller_t *dma,

-                                       vfu_dma_addr_t dma_addr, size_t size,

+                                       vfu_dma_addr_t dma_addr, uint64_t size,

                                        int fd, off_t offset, uint32_t prot)

 {

     dma_memory_region_t *region;

@@ -300,12 +300,12 @@ MOCK_DEFINE(dma_controller_add_region)(dma_controller_t *dma,

     assert(dma != NULL);

-    snprintf(rstr, sizeof(rstr), "[%p, %p) fd=%d offset=%#lx prot=%#x",

-             dma_addr, (char *)dma_addr + size, fd, offset, prot);

+    snprintf(rstr, sizeof(rstr), "[%p, %p) fd=%d offset=%#llx prot=%#x",

+             dma_addr, dma_addr + size, fd, (unsigned long long)offset, prot);

     if (size > dma->max_size) {

-        vfu_log(dma->vfu_ctx, LOG_ERR, "DMA region size %zu > max %zu",

-                size, dma->max_size);

+        vfu_log(dma->vfu_ctx, LOG_ERR, "DMA region size %llu > max %zu",

+                (unsigned long long)size, dma->max_size);

         return ERROR_INT(ENOSPC);

     }

@@ -317,7 +317,8 @@ MOCK_DEFINE(dma_controller_add_region)(dma_controller_t *dma,

             region->info.iova.iov_len == size) {

             if (offset != region->offset) {

                 vfu_log(dma->vfu_ctx, LOG_ERR, "bad offset for new DMA region "

-                        "%s; existing=%#lx", rstr, region->offset);

+                        "%s; existing=%#llx", rstr,

+                        (unsigned long long)region->offset);

                 return ERROR_INT(EINVAL);

             }

             if (!fds_are_same_file(region->fd, fd)) {

@@ -568,12 +569,19 @@ dma_controller_dirty_page_get(dma_controller_t *dma, vfu_dma_addr_t addr,

      * IOVAs.

      */

     ret = dma_addr_to_sgl(dma, addr, len, &sg, 1, PROT_NONE);

-    if (ret != 1 || sg.dma_addr != addr || sg.length != len) {

+    if (unlikely(ret != 1)) {

+        vfu_log(dma->vfu_ctx, LOG_DEBUG, "failed to translate %#llx-%#llx: %m",

+                (unsigned long long)(uintptr_t)addr,

+		(unsigned long long)(uintptr_t)addr + len - 1);

+        return ret;

+    }

+

+    if (unlikely(sg.dma_addr != addr || sg.length != len)) {

         return ERROR_INT(ENOTSUP);

     }

     if (pgsize != dma->dirty_pgsize) {

-        vfu_log(dma->vfu_ctx, LOG_ERR, "bad page size %ld", pgsize);

+        vfu_log(dma->vfu_ctx, LOG_ERR, "bad page size %zu", pgsize);

         return ERROR_INT(EINVAL);

     }

@@ -588,7 +596,7 @@ dma_controller_dirty_page_get(dma_controller_t *dma, vfu_dma_addr_t addr,

      * receive.

      */

     if (size != (size_t)bitmap_size) {

-        vfu_log(dma->vfu_ctx, LOG_ERR, "bad bitmap size %ld != %ld", size,

+        vfu_log(dma->vfu_ctx, LOG_ERR, "bad bitmap size %zu != %zu", size,

                 bitmap_size);

         return ERROR_INT(EINVAL);

     }

diff --git a/subprojects/libvfio-user/lib/dma.h b/subprojects/libvfio-user/lib/dma.h

index 089f973..e59c5ad 100644

--- a/subprojects/libvfio-user/lib/dma.h

+++ b/subprojects/libvfio-user/lib/dma.h

@@ -125,7 +125,7 @@ dma_controller_destroy(dma_controller_t *dma);

  * - On failure, -1 with errno set.

  */

 MOCK_DECLARE(int, dma_controller_add_region, dma_controller_t *dma,

-             vfu_dma_addr_t dma_addr, size_t size, int fd, off_t offset,

+             vfu_dma_addr_t dma_addr, uint64_t size, int fd, off_t offset,

              uint32_t prot);

 MOCK_DECLARE(int, dma_controller_remove_region, dma_controller_t *dma,

@@ -209,6 +209,7 @@ dma_init_sg(const dma_controller_t *dma, dma_sg_t *sg, vfu_dma_addr_t dma_addr,

     const dma_memory_region_t *const region = &dma->regions[region_index];

     if ((prot & PROT_WRITE) && !(region->info.prot & PROT_WRITE)) {

+        vfu_log(dma->vfu_ctx, LOG_DEBUG, "read-only region");

         return ERROR_INT(EACCES);

     }

diff --git a/subprojects/libvfio-user/lib/libvfio-user.c b/subprojects/libvfio-user/lib/libvfio-user.c

index ac04d3b..bc49618 100644

--- a/subprojects/libvfio-user/lib/libvfio-user.c

+++ b/subprojects/libvfio-user/lib/libvfio-user.c

@@ -47,7 +47,7 @@

 #include <sys/param.h>

 #include <sys/socket.h>

 #include <sys/stat.h>

-

+#include <inttypes.h>

 #include <sys/eventfd.h>

 #include "dma.h"

@@ -183,17 +183,19 @@ debug_region_access(vfu_ctx_t *vfu_ctx, size_t region, char *buf,

     case 2: val = *((uint16_t *)buf); break;

     case 1: val = *((uint8_t *)buf); break;

     default:

-            vfu_log(vfu_ctx, LOG_DEBUG, "region%zu: %s %zu bytes at %#lx",

-                    region, verb, count, offset);

+            vfu_log(vfu_ctx, LOG_DEBUG, "region%zu: %s %zu bytes at %#llx",

+                    region, verb, count, (unsigned long long)offset);

             return;

     }

     if (is_write) {

-        vfu_log(vfu_ctx, LOG_DEBUG, "region%zu: wrote %#zx to (%#lx:%zu)",

-                region, val, offset, count);

+        vfu_log(vfu_ctx, LOG_DEBUG, "region%zu: wrote %#llx to (%#llx:%zu)",

+                region, (unsigned long long)val, (unsigned long long)offset,

+                count);

     } else {

-        vfu_log(vfu_ctx, LOG_DEBUG, "region%zu: read %#zx from (%#lx:%zu)",

-                region, val, offset, count);

+        vfu_log(vfu_ctx, LOG_DEBUG, "region%zu: read %#llx from (%#llx:%zu)",

+                region, (unsigned long long)val, (unsigned long long)offset,

+                count);

     }

 }

@@ -235,8 +237,8 @@ region_access(vfu_ctx_t *vfu_ctx, size_t region, char *buf,

 out:

     if (ret != (ssize_t)count) {

-        vfu_log(vfu_ctx, LOG_DEBUG, "region%zu: %s (%#lx:%zu) failed: %m",

-                region, verb, offset, count);

+        vfu_log(vfu_ctx, LOG_DEBUG, "region%zu: %s (%#llx:%zu) failed: %m",

+                region, verb, (unsigned long long)offset, count);

     } else {

         debug_region_access(vfu_ctx, region, buf, count, offset, is_write);

     }

@@ -266,7 +268,7 @@ is_valid_region_access(vfu_ctx_t *vfu_ctx, size_t size, uint16_t cmd,

     if (cmd == VFIO_USER_REGION_WRITE && size - sizeof(*ra) != ra->count) {

         vfu_log(vfu_ctx, LOG_ERR, "region write count too small: "

-                "expected %lu, got %u", size - sizeof(*ra), ra->count);

+                "expected %zu, got %u", size - sizeof(*ra), ra->count);

         return false;

     }

@@ -278,8 +280,10 @@ is_valid_region_access(vfu_ctx_t *vfu_ctx, size_t size, uint16_t cmd,

     }

     if (satadd_u64(ra->offset, ra->count) > vfu_ctx->reg_info[index].size) {

-        vfu_log(vfu_ctx, LOG_ERR, "out of bounds region access %#lx-%#lx "

-                "(size %u)", ra->offset, ra->offset + ra->count,

+        vfu_log(vfu_ctx, LOG_ERR,

+                "out of bounds region access %#llx-%#llx (size %u)",

+                (unsigned long long)ra->offset,

+                (unsigned long long)(ra->offset + ra->count),

                 vfu_ctx->reg_info[index].size);

         return false;

@@ -337,7 +341,7 @@ handle_region_access(vfu_ctx_t *vfu_ctx, vfu_msg_t *msg)

     ret = region_access(vfu_ctx, in_ra->region, buf, in_ra->count,

                         in_ra->offset, msg->hdr.cmd == VFIO_USER_REGION_WRITE);

-    if (ret != in_ra->count) {

+    if (ret != (ssize_t)in_ra->count) {

         /* FIXME we should return whatever has been accessed, not an error */

         if (ret >= 0) {

             ret = ERROR_INT(EINVAL);

@@ -458,8 +462,10 @@ handle_device_get_region_info(vfu_ctx_t *vfu_ctx, vfu_msg_t *msg)

     }

     vfu_log(vfu_ctx, LOG_DEBUG, "region_info[%d] offset %#llx flags %#x "

-            "size %llu " "argsz %u", out_info->index, out_info->offset,

-            out_info->flags, out_info->size, out_info->argsz);

+            "size %llu argsz %u", out_info->index,

+            (unsigned long long)out_info->offset,

+            out_info->flags, (unsigned long long)out_info->size,

+            out_info->argsz);

     return 0;

 }

@@ -671,8 +677,10 @@ handle_dma_map(vfu_ctx_t *vfu_ctx, vfu_msg_t *msg,

         return ERROR_INT(EINVAL);

     }

-    snprintf(rstr, sizeof(rstr), "[%#lx, %#lx) offset=%#lx flags=%#x",

-             dma_map->addr, dma_map->addr + dma_map->size, dma_map->offset,

+    snprintf(rstr, sizeof(rstr), "[%#llx, %#llx) offset=%#llx flags=%#x",

+             (unsigned long long)dma_map->addr,

+             (unsigned long long)(dma_map->addr + dma_map->size),

+             (unsigned long long)dma_map->offset,

              dma_map->flags);

     vfu_log(vfu_ctx, LOG_DEBUG, "adding DMA region %s", rstr);

@@ -700,7 +708,8 @@ handle_dma_map(vfu_ctx_t *vfu_ctx, vfu_msg_t *msg,

         }

     }

-    ret = dma_controller_add_region(vfu_ctx->dma, (void *)dma_map->addr,

+    ret = dma_controller_add_region(vfu_ctx->dma,

+                                    (vfu_dma_addr_t)(uintptr_t)dma_map->addr,

                                     dma_map->size, fd, dma_map->offset,

                                     prot);

     if (ret < 0) {

@@ -747,8 +756,9 @@ is_valid_unmap(vfu_ctx_t *vfu_ctx, vfu_msg_t *msg,

     case VFIO_DMA_UNMAP_FLAG_ALL:

         if (dma_unmap->addr || dma_unmap->size) {

-            vfu_log(vfu_ctx, LOG_ERR, "bad addr=%#lx or size=%#lx, expected "

-                    "both to be zero", dma_unmap->addr, dma_unmap->size);

+            vfu_log(vfu_ctx, LOG_ERR, "bad addr=%#llx or size=%#llx, expected "

+                    "both to be zero", (unsigned long long)dma_unmap->addr,

+                    (unsigned long long)dma_unmap->size);

             errno = EINVAL;

             return false;

         }

@@ -791,8 +801,10 @@ handle_dma_unmap(vfu_ctx_t *vfu_ctx, vfu_msg_t *msg,

         return -1;

     }

-    snprintf(rstr, sizeof(rstr), "[%#lx, %#lx) flags=%#x",

-             dma_unmap->addr, dma_unmap->addr + dma_unmap->size, dma_unmap->flags);

+    snprintf(rstr, sizeof(rstr), "[%#llx, %#llx) flags=%#x",

+             (unsigned long long)dma_unmap->addr,

+             (unsigned long long)(dma_unmap->addr + dma_unmap->size),

+             dma_unmap->flags);

     vfu_log(vfu_ctx, LOG_DEBUG, "removing DMA region %s", rstr);

@@ -817,7 +829,7 @@ handle_dma_unmap(vfu_ctx_t *vfu_ctx, vfu_msg_t *msg,

     if (dma_unmap->flags & VFIO_DMA_UNMAP_FLAG_GET_DIRTY_BITMAP) {

         memcpy(msg->out.iov.iov_base + sizeof(*dma_unmap), dma_unmap->bitmap, sizeof(*dma_unmap->bitmap));

         ret = dma_controller_dirty_page_get(vfu_ctx->dma,

-                                            (vfu_dma_addr_t)dma_unmap->addr,

+                                            (vfu_dma_addr_t)(uintptr_t)dma_unmap->addr,

                                             dma_unmap->size,

                                             dma_unmap->bitmap->pgsize,

                                             dma_unmap->bitmap->size,

@@ -829,7 +841,7 @@ handle_dma_unmap(vfu_ctx_t *vfu_ctx, vfu_msg_t *msg,

     }

     ret = dma_controller_remove_region(vfu_ctx->dma,

-                                       (void *)dma_unmap->addr,

+                                       (vfu_dma_addr_t)(uintptr_t)dma_unmap->addr,

                                        dma_unmap->size,

                                        vfu_ctx->dma_unregister,

                                        vfu_ctx);

@@ -924,7 +936,7 @@ handle_dirty_pages_get(vfu_ctx_t *vfu_ctx, vfu_msg_t *msg)

         range_out = msg->out.iov.iov_base + sizeof(*dirty_pages_out);

         memcpy(range_out, range_in, sizeof(*range_out));

         ret = dma_controller_dirty_page_get(vfu_ctx->dma,

-                                            (vfu_dma_addr_t)range_in->iova,

+                                            (vfu_dma_addr_t)(uintptr_t)range_in->iova,

                                             range_in->size,

                                             range_in->bitmap.pgsize,

                                             range_in->bitmap.size, bitmap_out);

@@ -939,8 +951,8 @@ handle_dirty_pages_get(vfu_ctx_t *vfu_ctx, vfu_msg_t *msg)

         }

     } else {

         vfu_log(vfu_ctx, LOG_ERR,

-                "dirty pages: get [%#lx, %#lx): buffer too small (%u < %lu)",

-                range_in->iova, range_in->iova + range_in->size,

+                "dirty pages: get [%#llx, %#llx): buffer too small (%u < %zu)",

+                (unsigned long long)range_in->iova, (unsigned long long)range_in->iova + range_in->size,

                 dirty_pages_in->argsz, argsz);

     }

@@ -1873,6 +1885,10 @@ vfu_setup_region(vfu_ctx_t *vfu_ctx, int region_idx, size_t size,

     for (i = 0; i < nr_mmap_areas; i++) {

         struct iovec *iov = &mmap_areas[i];

         if ((size_t)iov_end(iov) > size) {

+            vfu_log(vfu_ctx, LOG_ERR, "mmap area #%zu %#llx-%#llx exceeds region size of %#llx\n",

+                    i, (unsigned long long)(uintptr_t)iov->iov_base,

+		    (unsigned long long)(uintptr_t)(iov->iov_base) + iov->iov_len - 1,

+		    (unsigned long long)size);

             return ERROR_INT(EINVAL);

         }

     }

@@ -2124,7 +2140,7 @@ vfu_dma_transfer(vfu_ctx_t *vfu_ctx, enum vfio_user_command cmd,

     while (remaining > 0) {

         int ret;

-        dma_req->addr = (uint64_t)sg->dma_addr + count;

+        dma_req->addr = (uintptr_t)sg->dma_addr + count;

         dma_req->count = MIN(remaining, vfu_ctx->client_max_data_xfer_size);

         if (cmd == VFIO_USER_DMA_WRITE) {

@@ -2153,10 +2169,13 @@ vfu_dma_transfer(vfu_ctx_t *vfu_ctx, enum vfio_user_command cmd,

         if (dma_reply->addr != dma_req->addr ||

             dma_reply->count != dma_req->count) {

+            /* TODO shouldn't we use %#llx for both and also use the range format? */

             vfu_log(vfu_ctx, LOG_ERR, "bad reply to DMA transfer: "

-                    "request:%#lx,%lu reply:%#lx,%lu",

-                    dma_req->addr, dma_req->count,

-                    dma_reply->addr, dma_reply->count);

+                    "request:%#llx,%llu reply:%#llx,%llu",

+                    (unsigned long long)dma_req->addr,

+                    (unsigned long long)dma_req->count,

+                    (unsigned long long)dma_reply->addr,

+                    (unsigned long long)dma_reply->count);

             free(rbuf);

             return ERROR_INT(EINVAL);

         }

diff --git a/subprojects/libvfio-user/lib/migration.c b/subprojects/libvfio-user/lib/migration.c

index 2936768..62ac082 100644

--- a/subprojects/libvfio-user/lib/migration.c

+++ b/subprojects/libvfio-user/lib/migration.c

@@ -413,7 +413,7 @@ MOCK_DEFINE(migration_region_access_registers)(vfu_ctx_t *vfu_ctx, char *buf,

     case offsetof(struct vfio_user_migration_info, device_state):

         if (count != sizeof(migr->info.device_state)) {

             vfu_log(vfu_ctx, LOG_ERR,

-                    "bad device_state access size %ld", count);

+                    "bad device_state access size %zu", count);

             return ERROR_INT(EINVAL);

         }

         device_state = (uint32_t *)buf;

@@ -443,7 +443,7 @@ MOCK_DEFINE(migration_region_access_registers)(vfu_ctx_t *vfu_ctx, char *buf,

     case offsetof(struct vfio_user_migration_info, pending_bytes):

         if (count != sizeof(migr->info.pending_bytes)) {

             vfu_log(vfu_ctx, LOG_ERR,

-                    "bad pending_bytes access size %ld", count);

+                    "bad pending_bytes access size %zu", count);

             return ERROR_INT(EINVAL);

         }

         ret = handle_pending_bytes(vfu_ctx, migr, (uint64_t *)buf, is_write);

@@ -451,7 +451,7 @@ MOCK_DEFINE(migration_region_access_registers)(vfu_ctx_t *vfu_ctx, char *buf,

     case offsetof(struct vfio_user_migration_info, data_offset):

         if (count != sizeof(migr->info.data_offset)) {

             vfu_log(vfu_ctx, LOG_ERR,

-                    "bad data_offset access size %ld", count);

+                    "bad data_offset access size %zu", count);

             return ERROR_INT(EINVAL);

         }

         ret = handle_data_offset(vfu_ctx, migr, (uint64_t *)buf, is_write);

@@ -459,14 +459,15 @@ MOCK_DEFINE(migration_region_access_registers)(vfu_ctx_t *vfu_ctx, char *buf,

     case offsetof(struct vfio_user_migration_info, data_size):

         if (count != sizeof(migr->info.data_size)) {

             vfu_log(vfu_ctx, LOG_ERR,

-                    "bad data_size access size %ld", count);

+                    "bad data_size access size %zu", count);

             return ERROR_INT(EINVAL);

         }

         ret = handle_data_size(vfu_ctx, migr, (uint64_t *)buf, is_write);

         break;

     default:

-        vfu_log(vfu_ctx, LOG_ERR, "bad migration region register offset %#lx",

-               pos);

+        vfu_log(vfu_ctx, LOG_ERR,

+                "bad migration region register offset %#llx",

+                (unsigned long long)pos);

         return ERROR_INT(EINVAL);

     }

     return ret;

@@ -502,8 +503,9 @@ migration_region_access(vfu_ctx_t *vfu_ctx, char *buf, size_t count,

              * any access to the data region properly.

              */

             vfu_log(vfu_ctx, LOG_WARNING,

-                    "bad access to dead space %#lx-%#lx in migration region",

-                    pos, pos + count - 1);

+                    "bad access to dead space %#llx - %#llx in migration region",

+                    (unsigned long long)pos,

+                    (unsigned long long)(pos + count - 1));

             return ERROR_INT(EINVAL);

         }

diff --git a/subprojects/libvfio-user/lib/pci.c b/subprojects/libvfio-user/lib/pci.c

index 21db6e4..beacd5c 100644

--- a/subprojects/libvfio-user/lib/pci.c

+++ b/subprojects/libvfio-user/lib/pci.c

@@ -264,8 +264,8 @@ pci_hdr_write(vfu_ctx_t *vfu_ctx, const char *buf, loff_t offset)

         ret = handle_erom_write(vfu_ctx, cfg_space, buf);

         break;

     default:

-        vfu_log(vfu_ctx, LOG_ERR, "PCI config write %#lx not handled",

-                offset);

+        vfu_log(vfu_ctx, LOG_ERR, "PCI config write %#llx not handled",

+                (unsigned long long)offset);

         ret = ERROR_INT(EINVAL);

     }

@@ -315,7 +315,7 @@ pci_nonstd_access(vfu_ctx_t *vfu_ctx, char *buf, size_t count,

     if (is_write) {

         vfu_log(vfu_ctx, LOG_ERR, "no callback for write to config space "

-                "offset %lu size %zu", offset, count);

+                "offset %#llx size %zu", (unsigned long long)offset, count);

         return ERROR_INT(EINVAL);

     }

@@ -429,8 +429,10 @@ pci_config_space_access(vfu_ctx_t *vfu_ctx, char *buf, size_t count,

         size = pci_config_space_next_segment(vfu_ctx, count, offset, is_write,

                                              &cb;;

         if (cb == NULL) {

-            vfu_log(vfu_ctx, LOG_ERR, "bad write to PCI config space %#lx-%#lx",

-                    offset, offset + count - 1);

+            vfu_log(vfu_ctx, LOG_ERR,

+                    "bad write to PCI config space %#llx-%#llx",

+                    (unsigned long long)offset,

+                    (unsigned long long)(offset + count - 1));

             return size;

         }

diff --git a/subprojects/libvfio-user/lib/pci_caps.c b/subprojects/libvfio-user/lib/pci_caps.c

index e9dc5ac..50eb29b 100644

--- a/subprojects/libvfio-user/lib/pci_caps.c

+++ b/subprojects/libvfio-user/lib/pci_caps.c

@@ -483,7 +483,7 @@ cap_place(vfu_ctx_t *vfu_ctx, struct pci_cap *cap, void *data)

     if (cap->off != 0) {

         if (cap->off < PCI_STD_HEADER_SIZEOF) {

-            vfu_log(vfu_ctx, LOG_ERR, "invalid offset %#lx for capability "

+            vfu_log(vfu_ctx, LOG_ERR, "invalid offset %zx for capability "

                     "%u (%s)", cap->off, cap->id, cap->name);

             return ERROR_INT(EINVAL);

         }

@@ -516,11 +516,11 @@ cap_place(vfu_ctx_t *vfu_ctx, struct pci_cap *cap, void *data)

     if (cap->off + cap->size > pci_config_space_size(vfu_ctx)) {

         vfu_log(vfu_ctx, LOG_ERR, "no config space left for capability "

-                "%u (%s) of size %zu bytes at offset %#lx", cap->id,

+                "%u (%s) of size %zu bytes at offset %zx", cap->id,

                 cap->name, cap->size, cap->off);

         return ERROR_INT(ENOSPC);

     }

-

+ 

     memcpy(cap_data(vfu_ctx, cap), data, cap->size);

     /* Make sure the previous cap's PCI_CAP_LIST_NEXT points to us. */

     *prevp = cap->off;

@@ -547,7 +547,7 @@ ext_cap_place(vfu_ctx_t *vfu_ctx, struct pci_cap *cap, void *data)

     if (cap->off != 0) {

         if (cap->off < PCI_CFG_SPACE_SIZE) {

-            vfu_log(vfu_ctx, LOG_ERR, "invalid offset %#lx for capability "

+            vfu_log(vfu_ctx, LOG_ERR, "invalid offset %zx for capability "

                     "%u (%s)", cap->off, cap->id, cap->name);

             return ERROR_INT(EINVAL);

         }

@@ -581,7 +581,7 @@ ext_cap_place(vfu_ctx_t *vfu_ctx, struct pci_cap *cap, void *data)

     if (cap->off + cap->size > pci_config_space_size(vfu_ctx)) {

         vfu_log(vfu_ctx, LOG_ERR, "no config space left for capability "

-                "%u (%s) of size %zu bytes at offset %#lx", cap->id,

+                "%u (%s) of size %zu bytes at offset %zu", cap->id,

                 cap->name, cap->size, cap->off);

         return ERROR_INT(ENOSPC);

     }

@@ -700,7 +700,7 @@ vfu_pci_add_capability(vfu_ctx_t *vfu_ctx, size_t pos, int flags, void *data)

         if (cap.off + cap.size >= pci_config_space_size(vfu_ctx)) {

                 vfu_log(vfu_ctx, LOG_DEBUG,

-                        "PCI capability past end of config space, %#lx >= %#lx",

+                        "PCI capability past end of config space, %zx >= %zx",

                         cap.off + cap.size, pci_config_space_size(vfu_ctx));

             return ERROR_INT(EINVAL);

         }

diff --git a/subprojects/libvfio-user/lib/private.h b/subprojects/libvfio-user/lib/private.h

index 7ffd6be..7c18c95 100644

--- a/subprojects/libvfio-user/lib/private.h

+++ b/subprojects/libvfio-user/lib/private.h

@@ -45,7 +45,11 @@

  * is to limit the size of the dirty bitmaps: this corresponds to 256MB at a 4K

  * page size.

  */

+#if defined(__x86_64__) || defined(__ppc64__)

 #define MAX_DMA_SIZE (8 * ONE_TB)

+#else

+#define MAX_DMA_SIZE UINT32_MAX /* FIXME check for __i386__ etc? */

+#endif

 #define MAX_DMA_REGIONS 16

 #define SERVER_MAX_DATA_XFER_SIZE (VFIO_USER_DEFAULT_MAX_DATA_XFER_SIZE)

diff --git a/subprojects/libvfio-user/lib/tran.c b/subprojects/libvfio-user/lib/tran.c

index ba49fd6..a183877 100644

--- a/subprojects/libvfio-user/lib/tran.c

+++ b/subprojects/libvfio-user/lib/tran.c

@@ -176,7 +176,7 @@ recv_version(vfu_ctx_t *vfu_ctx, uint16_t *msg_idp,

     if (msg.in.iov.iov_len < sizeof(*cversion)) {

         vfu_log(vfu_ctx, LOG_ERR,

-                "msg%#hx: VFIO_USER_VERSION: invalid size %lu",

+                "msg%#hx: VFIO_USER_VERSION: invalid size %zu",

                 *msg_idp, msg.in.iov.iov_len);

         ret = EINVAL;

         goto out;

diff --git a/subprojects/libvfio-user/lib/tran_pipe.c b/subprojects/libvfio-user/lib/tran_pipe.c

index dea2c3c..d1428ab 100644

--- a/subprojects/libvfio-user/lib/tran_pipe.c

+++ b/subprojects/libvfio-user/lib/tran_pipe.c

@@ -83,7 +83,7 @@ tran_pipe_send_iovec(int fd, uint16_t msg_id, bool is_reply,

             return ERROR_INT(ECONNRESET);

         }

         return -1;

-    } else if (ret < hdr.msg_size) {

+    } else if (ret < (ssize_t)hdr.msg_size) {

         return ERROR_INT(ECONNRESET);

     }

diff --git a/subprojects/libvfio-user/samples/client.c b/subprojects/libvfio-user/samples/client.c

index da211b8..e65bb61 100644

--- a/subprojects/libvfio-user/samples/client.c

+++ b/subprojects/libvfio-user/samples/client.c

@@ -110,7 +110,7 @@ send_version(int sock)

                 "\"max_msg_fds\":%u,"

                 "\"max_data_xfer_size\":%u,"

                 "\"migration\":{"

-                    "\"pgsize\":%zu"

+                    "\"pgsize\":%ld"

                 "}"

             "}"

          "}", CLIENT_MAX_FDS, CLIENT_MAX_DATA_XFER_SIZE, sysconf(_SC_PAGESIZE));

@@ -155,7 +155,7 @@ recv_version(int sock, int *server_max_fds, size_t *server_max_data_xfer_size,

     }

     if (vlen < sizeof(*sversion)) {

-        errx(EXIT_FAILURE, "VFIO_USER_VERSION: invalid size %lu", vlen);

+        errx(EXIT_FAILURE, "VFIO_USER_VERSION: invalid size %zu", vlen);

     }

     if (sversion->major != LIB_VFIO_USER_MAJOR) {

@@ -229,8 +229,9 @@ get_region_vfio_caps(struct vfio_info_cap_header *header,

                        (*sparse)->nr_areas);

                 for (i = 0; i < (*sparse)->nr_areas; i++) {

                     printf("client: %s: area %d offset %#llx size %llu\n",

-                           __func__, i, (*sparse)->areas[i].offset,

-                           (*sparse)->areas[i].size);

+                           __func__, i,

+			   (unsigned long long)(*sparse)->areas[i].offset,

+                           (unsigned long long)(*sparse)->areas[i].size);

                 }

                 break;

             case VFIO_REGION_INFO_CAP_TYPE:

@@ -290,9 +291,9 @@ mmap_sparse_areas(int *fds, struct vfio_region_info *region_info,

                     sparse->areas[i].offset);

         if (addr == MAP_FAILED) {

             err(EXIT_FAILURE,

-                "failed to mmap sparse region #%lu in %s (%#llx-%#llx)",

-                i, buf, sparse->areas[i].offset,

-                sparse->areas[i].offset + sparse->areas[i].size - 1);

+                "failed to mmap sparse region %zu in %s (%#llx-%#llx)",

+                i, buf, (unsigned long long)sparse->areas[i].offset,

+                (unsigned long long)sparse->areas[i].offset + sparse->areas[i].size - 1);

         }

         ret = munmap(addr, sparse->areas[i].size);

@@ -310,7 +311,11 @@ get_device_region_info(int sock, uint32_t index)

     size_t nr_fds = ARRAY_SIZE(fds);

-    region_info = alloca(size);

+    region_info = malloc(size);

+    if (region_info == NULL) {

+        err(EXIT_FAILURE, "%m\n");

+    }

+

     memset(region_info, 0, size);

     region_info->argsz = size;

     region_info->index = index;

@@ -318,7 +323,10 @@ get_device_region_info(int sock, uint32_t index)

     do_get_device_region_info(sock, region_info, NULL, 0);

     if (region_info->argsz > size) {

         size = region_info->argsz;

-        region_info = alloca(size);

+        region_info = malloc(size);

+        if (region_info == NULL) {

+            err(EXIT_FAILURE, "%m\n");

+        }

         memset(region_info, 0, size);

         region_info->argsz = size;

         region_info->index = index;

@@ -329,9 +337,11 @@ get_device_region_info(int sock, uint32_t index)

     }

     cap_sz = region_info->argsz - sizeof(struct vfio_region_info);

-    printf("client: %s: region_info[%d] offset %#llx flags %#x size %llu "

-           "cap_sz %lu #FDs %lu\n", __func__, index, region_info->offset,

-           region_info->flags, region_info->size, cap_sz, nr_fds);

+    printf("client: %s: region_info[%d] offset %#llx flags %#x "

+           "size %llu cap_sz %zu #FDs %zu\n", __func__, index,

+           (unsigned long long)region_info->offset, region_info->flags,

+           (unsigned long long)region_info->size, cap_sz,

+           nr_fds);

     if (cap_sz) {

         struct vfio_region_info_cap_sparse_mmap *sparse = NULL;

         if (get_region_vfio_caps((struct vfio_info_cap_header*)(region_info + 1),

@@ -343,7 +353,9 @@ get_device_region_info(int sock, uint32_t index)

                 mmap_sparse_areas(fds, region_info, sparse);

             }

         }

+

     }

+    free(region_info);

 }

 static void

@@ -487,14 +499,15 @@ access_region(int sock, int region, bool is_write, uint64_t offset,

                               recv_data, recv_data_len, NULL, 0);

     pthread_mutex_unlock(&mutex);

     if (ret != 0) {

-        warn("failed to %s region %d %#lx-%#lx",

-             is_write ? "write to" : "read from", region, offset,

-             offset + data_len - 1);

+        warn("failed to %s region %d %#llx-%#llx",

+             is_write ? "write to" : "read from", region,

+             (unsigned long long)offset,

+             (unsigned long long)(offset + data_len - 1));

         free(recv_data);

         return ret;

     }

     if (recv_data->count != data_len) {

-        warnx("bad %s data count, expected=%lu, actual=%d",

+        warnx("bad %s data count, expected=%zu, actual=%d",

              is_write ? "write" : "read", data_len,

              recv_data->count);

         free(recv_data);

@@ -585,8 +598,9 @@ handle_dma_write(int sock, struct vfio_user_dma_map *dma_regions,

         c = pwrite(dma_region_fds[i], data, dma_access.count, offset);

         if (c != (ssize_t)dma_access.count) {

-            err(EXIT_FAILURE, "failed to write to fd=%d at [%#lx-%#lx)",

-                    dma_region_fds[i], offset, offset + dma_access.count);

+            err(EXIT_FAILURE, "failed to write to fd=%d at [%#llx-%#llx)",

+                    dma_region_fds[i], (unsigned long long)offset,

+                    (unsigned long long)(offset + dma_access.count));

         }

         break;

     }

@@ -640,8 +654,9 @@ handle_dma_read(int sock, struct vfio_user_dma_map *dma_regions,

         c = pread(dma_region_fds[i], data, dma_access.count, offset);

         if (c != (ssize_t)dma_access.count) {

-            err(EXIT_FAILURE, "failed to read from fd=%d at [%#lx-%#lx)",

-                    dma_region_fds[i], offset, offset + dma_access.count);

+            err(EXIT_FAILURE, "failed to read from fd=%d at [%#llx-%#llx)",

+                    dma_region_fds[i], (unsigned long long)offset,

+                    (unsigned long long)offset + dma_access.count);

         }

         break;

     }

@@ -706,8 +721,9 @@ get_dirty_bitmap(int sock, struct vfio_user_dma_map *dma_region)

         err(EXIT_FAILURE, "failed to get dirty page bitmap");

     }

-    printf("client: %s: %#lx-%#lx\t%#x\n", __func__, range->iova,

-           range->iova + range->size - 1, bitmap[0]);

+    printf("client: %s: %#llx-%#llx\t%#x\n", __func__,

+           (unsigned long long)range->iova,

+           (unsigned long long)(range->iova + range->size - 1), bitmap[0]);

     free(data);

 }

@@ -900,7 +916,7 @@ migrate_from(int sock, size_t *nr_iters, struct iovec **migr_iters,

     _nr_iters += do_migrate(sock, 1, (*migr_iters) + _nr_iters);

     if (_nr_iters != 2) {

         errx(EXIT_FAILURE,

-             "expected 2 iterations instead of %ld while in stop-and-copy state",

+             "expected 2 iterations instead of %zu while in stop-and-copy state",

              _nr_iters);

     }

@@ -1000,8 +1016,9 @@ migrate_to(char *old_sock_path, int *server_max_fds,

          * TODO write half of migration data via regular write and other half via

          * memopy map.

          */

-        printf("client: writing migration device data %#lx-%#lx\n",

-               data_offset, data_offset + migr_iters[i].iov_len - 1);

+        printf("client: writing migration device data %#llx-%#llx\n",

+               (unsigned long long)data_offset,

+               (unsigned long long)(data_offset + migr_iters[i].iov_len - 1));

         ret = access_region(sock, VFU_PCI_DEV_MIGR_REGION_IDX, true,

                             data_offset, migr_iters[i].iov_base,

                             migr_iters[i].iov_len);

@@ -1162,8 +1179,11 @@ int main(int argc, char *argv[])

     unlink(template);

-    dma_regions = alloca(sizeof(*dma_regions) * nr_dma_regions);

-    dma_region_fds = alloca(sizeof(*dma_region_fds) * nr_dma_regions);

+    dma_regions = calloc(nr_dma_regions, sizeof(*dma_regions));

+    dma_region_fds = calloc(nr_dma_regions, sizeof(*dma_region_fds));

+    if (dma_regions == NULL || dma_region_fds == NULL) {

+        err(EXIT_FAILURE, "%m\n");

+    }

     for (i = 0; i < nr_dma_regions; i++) {

         dma_regions[i].argsz = sizeof(struct vfio_user_dma_map);

@@ -1310,6 +1330,9 @@ int main(int argc, char *argv[])

         err(EXIT_FAILURE, "failed to unmap all DMA regions");

     }

+    free(dma_regions);

+    free(dma_region_fds);

+

     return 0;

 }

diff --git a/subprojects/libvfio-user/samples/server.c b/subprojects/libvfio-user/samples/server.c

index e994ac1..e059d9c 100644

--- a/subprojects/libvfio-user/samples/server.c

+++ b/subprojects/libvfio-user/samples/server.c

@@ -93,8 +93,9 @@ bar0_access(vfu_ctx_t *vfu_ctx, char * const buf, size_t count, loff_t offset,

     struct server_data *server_data = vfu_get_private(vfu_ctx);

     if (count != sizeof(time_t) || offset != 0) {

-        vfu_log(vfu_ctx, LOG_ERR, "bad BAR0 access %#lx-%#lx",

-                offset, offset + count - 1);

+        vfu_log(vfu_ctx, LOG_ERR, "bad BAR0 access %#llx-%#llx",

+                (unsigned long long)offset,

+                (unsigned long long)offset + count - 1);

         errno = EINVAL;

         return -1;

     }

@@ -123,8 +124,9 @@ bar1_access(vfu_ctx_t *vfu_ctx, char * const buf,

     struct server_data *server_data = vfu_get_private(vfu_ctx);

     if (offset + count > server_data->bar1_size) {

-        vfu_log(vfu_ctx, LOG_ERR, "bad BAR1 access %#lx-%#lx",

-                offset, offset + count - 1);

+        vfu_log(vfu_ctx, LOG_ERR, "bad BAR1 access %#llx-%#llx",

+                (unsigned long long)offset,

+                (unsigned long long)offset + count - 1);

         errno = EINVAL;

         return -1;

     }

@@ -353,8 +355,9 @@ migration_write_data(vfu_ctx_t *vfu_ctx, void *data,

     assert(data != NULL);

     if (offset != 0 || size < server_data->bar1_size) {

-        vfu_log(vfu_ctx, LOG_DEBUG, "XXX bad migration data write %#lx-%#lx",

-                offset, offset + size - 1);

+        vfu_log(vfu_ctx, LOG_DEBUG, "XXX bad migration data write %#llx-%#llx",

+                (unsigned long long)offset,

+                (unsigned long long)offset + size - 1);

         errno = EINVAL;

         return -1;

     }

diff --git a/subprojects/libvfio-user/test/mocks.c b/subprojects/libvfio-user/test/mocks.c

index 619ccf9..2ae14b4 100644

--- a/subprojects/libvfio-user/test/mocks.c

+++ b/subprojects/libvfio-user/test/mocks.c

@@ -113,7 +113,7 @@ unpatch_all(void)

 int

 dma_controller_add_region(dma_controller_t *dma, void *dma_addr,

-                          size_t size, int fd, off_t offset,

+                          uint64_t size, int fd, off_t offset,

                           uint32_t prot)

 {

     if (!is_patched("dma_controller_add_region")) {

@@ -122,7 +122,7 @@ dma_controller_add_region(dma_controller_t *dma, void *dma_addr,

     }

     check_expected_ptr(dma);

-    check_expected(dma_addr);

+    check_expected_ptr(dma_addr);

     check_expected(size);

     check_expected(fd);

     check_expected(offset);

diff --git a/subprojects/libvfio-user/test/py/libvfio_user.py b/subprojects/libvfio-user/test/py/libvfio_user.py

index 0ebf773..a63296c 100644

--- a/subprojects/libvfio-user/test/py/libvfio_user.py

+++ b/subprojects/libvfio-user/test/py/libvfio_user.py

@@ -43,6 +43,12 @@

 import syslog

 import copy

 import tempfile

+import sys

+from resource import getpagesize

+from math import log2

+

+PAGE_SIZE = getpagesize()

+PAGE_SHIFT = int(log2(PAGE_SIZE))

 UINT64_MAX = 18446744073709551615

@@ -140,8 +146,14 @@

 SERVER_MAX_DATA_XFER_SIZE = VFIO_USER_DEFAULT_MAX_DATA_XFER_SIZE

 SERVER_MAX_MSG_SIZE = SERVER_MAX_DATA_XFER_SIZE + 16 + 16

+

+def is_32bit():

+    return (1 << 31) - 1 == sys.maxsize

+

+

 MAX_DMA_REGIONS = 16

-MAX_DMA_SIZE = (8 * ONE_TB)

+# FIXME get from libvfio-user.h

+MAX_DMA_SIZE = sys.maxsize << 1 if is_32bit() else (8 * ONE_TB)

 # enum vfio_user_command

 VFIO_USER_VERSION = 1

@@ -583,7 +595,7 @@ class vfio_user_migration_info(Structure):

                                      c.c_ulong, c.c_long, c.c_bool)

 lib.vfu_setup_region.argtypes = (c.c_void_p, c.c_int, c.c_ulong,

                                  vfu_region_access_cb_t, c.c_int, c.c_void_p,

-                                 c.c_uint32, c.c_int, c.c_ulong)

+                                 c.c_uint32, c.c_int, c.c_uint64)

 vfu_reset_cb_t = c.CFUNCTYPE(c.c_int, c.c_void_p, c.c_int)

 lib.vfu_setup_device_reset_cb.argtypes = (c.c_void_p, vfu_reset_cb_t)

 lib.vfu_pci_get_config_space.argtypes = (c.c_void_p,)

@@ -769,7 +781,6 @@ def get_pci_ext_cfg_space(ctx):

 def read_pci_cfg_space(ctx, buf, count, offset, extended=False):

     space = get_pci_ext_cfg_space(ctx) if extended else get_pci_cfg_space(ctx)

-

     for i in range(count):

         buf[i] = space[offset+i]

     return count

@@ -783,6 +794,8 @@ def write_pci_cfg_space(ctx, buf, count, offset, extended=False):

     space = c.cast(lib.vfu_pci_get_config_space(ctx), c.POINTER(c.c_char))

     for i in range(count):

+        # FIXME this assignment doesn't update the actual config space, it

+        # works fine on x86_64

         space[offset+i] = buf[i]

     return count

@@ -897,11 +910,13 @@ def prepare_ctx_for_dma(dma_register=__dma_register,

         assert ret == 0

     f = tempfile.TemporaryFile()

-    f.truncate(0x2000)

+    migr_region_size = 2 << PAGE_SHIFT

+    f.truncate(migr_region_size)

-    mmap_areas = [(0x1000, 0x1000)]

+    mmap_areas = [(PAGE_SIZE, PAGE_SIZE)]

-    ret = vfu_setup_region(ctx, index=VFU_PCI_DEV_MIGR_REGION_IDX, size=0x2000,

+    ret = vfu_setup_region(ctx, index=VFU_PCI_DEV_MIGR_REGION_IDX,

+                           size=migr_region_size,

                            flags=VFU_REGION_FLAG_RW, mmap_areas=mmap_areas,