drop use of __u* types (#438)

As we are now pure userspace, there is no need for us to use non-standard
integer types. This leaves the copied defines from Linux's vfio.h alone,
however.

Signed-off-by: John Levon <john.levon@nutanix.com>
Reviewed-by: Thanos Makatos <thanos.makatos@nutanix.com>

9 files changed, 48 insertions, 48 deletions

diff --git a/include/libvfio-user.h b/include/libvfio-user.h
index f2876a1..fa21bc2 100644
--- a/include/libvfio-user.h
+++ b/include/libvfio-user.h
@@ -512,7 +512,7 @@ typedef struct {
      * function returns 0 then migration has finished and this function won't
      * be called again.
      */
-    __u64 (*get_pending_bytes)(vfu_ctx_t *vfu_ctx);
+    uint64_t (*get_pending_bytes)(vfu_ctx_t *vfu_ctx);
 
     /*
      * Function that is called to instruct the device to prepare migration data
@@ -525,7 +525,7 @@ typedef struct {
      * When in resuming state, @offset must be set to where migration data must
      * written. @size points to NULL.
      */
-    int (*prepare_data)(vfu_ctx_t *vfu_ctx, __u64 *offset, __u64 *size);
+    int (*prepare_data)(vfu_ctx_t *vfu_ctx, uint64_t *offset, uint64_t *size);
 
     /*
      * Function that is called to read migration data. offset and size can be
@@ -539,7 +539,7 @@ typedef struct {
      * Does this mean that reading data_offset/data_size updates the values?
      */
     ssize_t (*read_data)(vfu_ctx_t *vfu_ctx, void *buf,
-                         __u64 count, __u64 offset);
+                         uint64_t count, uint64_t offset);
 
     /* Callbacks for restoring device state */
 
@@ -548,14 +548,14 @@ typedef struct {
      * function must return the amount of data written or -1 on error, setting
      * errno.
      */
-    ssize_t (*write_data)(vfu_ctx_t *vfu_ctx, void *buf, __u64 count,
-                          __u64 offset);
+    ssize_t (*write_data)(vfu_ctx_t *vfu_ctx, void *buf, uint64_t count,
+                          uint64_t offset);
 
     /*
      * Function that is called when client has written some previously stored
      * device state.
      */
-    int (*data_written)(vfu_ctx_t *vfu_ctx, __u64 count);
+    int (*data_written)(vfu_ctx_t *vfu_ctx, uint64_t count);
 
 } vfu_migration_callbacks_t;
 
diff --git a/lib/irq.c b/lib/irq.c
index 3547df5..25eb31b 100644
--- a/lib/irq.c
+++ b/lib/irq.c
@@ -162,7 +162,7 @@ static int
 irqs_set_data_none(vfu_ctx_t *vfu_ctx, struct vfio_irq_set *irq_set)
 {
     int efd;
-    __u32 i;
+    uint32_t i;
     long ret;
     eventfd_t val;
 
@@ -187,7 +187,7 @@ irqs_set_data_bool(vfu_ctx_t *vfu_ctx, struct vfio_irq_set *irq_set, void *data)
 {
     uint8_t *d8;
     int efd;
-    __u32 i;
+    uint32_t i;
     long ret;
     eventfd_t val;
 
@@ -214,7 +214,7 @@ irqs_set_data_eventfd(vfu_ctx_t *vfu_ctx, struct vfio_irq_set *irq_set,
                       int *data)
 {
     int efd;
-    __u32 i;
+    uint32_t i;
     size_t j;
 
     assert(data != NULL);
diff --git a/lib/migration.c b/lib/migration.c
index 93703a0..ff6913b 100644
--- a/lib/migration.c
+++ b/lib/migration.c
@@ -39,11 +39,8 @@
 #include "private.h"
 #include "migration_priv.h"
 
-/* FIXME no need to use __u32 etc., use uint32_t etc */
-
-
 bool
-vfio_migr_state_transition_is_valid(__u32 from, __u32 to)
+vfio_migr_state_transition_is_valid(uint32_t from, uint32_t to)
 {
     return migr_states[from].state & (1 << to);
 }
@@ -111,7 +108,7 @@ migr_state_transition(struct migration *migr, enum migr_iter_state state)
 
 static ssize_t
 handle_device_state(vfu_ctx_t *vfu_ctx, struct migration *migr,
-                    __u32 *device_state, bool is_write) {
+                    uint32_t *device_state, bool is_write) {
 
     int ret;
 
@@ -178,7 +175,7 @@ handle_device_state(vfu_ctx_t *vfu_ctx, struct migration *migr,
 
 static ssize_t
 handle_pending_bytes(vfu_ctx_t *vfu_ctx, struct migration *migr,
-                     __u64 *pending_bytes, bool is_write)
+                     uint64_t *pending_bytes, bool is_write)
 {
     assert(migr != NULL);
     assert(pending_bytes != NULL);
@@ -273,7 +270,7 @@ handle_data_offset_when_saving(vfu_ctx_t *vfu_ctx, struct migration *migr,
 
 static ssize_t
 handle_data_offset(vfu_ctx_t *vfu_ctx, struct migration *migr,
-                   __u64 *offset, bool is_write)
+                   uint64_t *offset, bool is_write)
 {
     int ret;
 
@@ -331,7 +328,7 @@ handle_data_size_when_saving(vfu_ctx_t *vfu_ctx, struct migration *migr,
 
 static ssize_t
 handle_data_size_when_resuming(vfu_ctx_t *vfu_ctx, struct migration *migr,
-                               __u64 size, bool is_write)
+                               uint64_t size, bool is_write)
 {
     assert(migr != NULL);
 
@@ -343,7 +340,7 @@ handle_data_size_when_resuming(vfu_ctx_t *vfu_ctx, struct migration *migr,
 
 static ssize_t
 handle_data_size(vfu_ctx_t *vfu_ctx, struct migration *migr,
-                 __u64 *size, bool is_write)
+                 uint64_t *size, bool is_write)
 {
     int ret;
 
@@ -382,7 +379,7 @@ migration_region_access_registers(vfu_ctx_t *vfu_ctx, char *buf, size_t count,
                     "bad device_state access size %ld", count);
             return -EINVAL;
         }
-        ret = handle_device_state(vfu_ctx, migr, (__u32*)buf, is_write);
+        ret = handle_device_state(vfu_ctx, migr, (uint32_t *)buf, is_write);
         break;
     case offsetof(struct vfio_device_migration_info, pending_bytes):
         if (count != sizeof(migr->info.pending_bytes)) {
@@ -390,7 +387,7 @@ migration_region_access_registers(vfu_ctx_t *vfu_ctx, char *buf, size_t count,
                     "bad pending_bytes access size %ld", count);
             return -EINVAL;
         }
-        ret = handle_pending_bytes(vfu_ctx, migr, (__u64*)buf, is_write);
+        ret = handle_pending_bytes(vfu_ctx, migr, (uint64_t *)buf, is_write);
         break;
     case offsetof(struct vfio_device_migration_info, data_offset):
         if (count != sizeof(migr->info.data_offset)) {
@@ -398,7 +395,7 @@ migration_region_access_registers(vfu_ctx_t *vfu_ctx, char *buf, size_t count,
                     "bad data_offset access size %ld", count);
             return -EINVAL;
         }
-        ret = handle_data_offset(vfu_ctx, migr, (__u64*)buf, is_write);
+        ret = handle_data_offset(vfu_ctx, migr, (uint64_t *)buf, is_write);
         break;
     case offsetof(struct vfio_device_migration_info, data_size):
         if (count != sizeof(migr->info.data_size)) {
@@ -406,7 +403,7 @@ migration_region_access_registers(vfu_ctx_t *vfu_ctx, char *buf, size_t count,
                     "bad data_size access size %ld", count);
             return -EINVAL;
         }
-        ret = handle_data_size(vfu_ctx, migr, (__u64*)buf, is_write);
+        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",
diff --git a/lib/migration.h b/lib/migration.h
index 498cae0..aeaca66 100644
--- a/lib/migration.h
+++ b/lib/migration.h
@@ -66,7 +66,7 @@ int
 migration_set_pgsize(struct migration *migr, size_t pgsize);
 
 bool
-vfio_migr_state_transition_is_valid(__u32 from, __u32 to);
+vfio_migr_state_transition_is_valid(uint32_t from, uint32_t to);
 
 #endif /* LIB_VFIO_USER_MIGRATION_H */
 
diff --git a/lib/migration_priv.h b/lib/migration_priv.h
index b8a8734..bf47621 100644
--- a/lib/migration_priv.h
+++ b/lib/migration_priv.h
@@ -59,14 +59,14 @@ struct migration {
      */
     struct {
         enum migr_iter_state state;
-        __u64 pending_bytes;
-        __u64 offset;
-        __u64 size;
+        uint64_t pending_bytes;
+        uint64_t offset;
+        uint64_t size;
     } iter;
 };
 
 struct migr_state_data {
-    __u32 state;
+    uint32_t state;
     const char *name;
 };
 
diff --git a/samples/client.c b/samples/client.c
index ea0c73e..b2008fd 100644
--- a/samples/client.c
+++ b/samples/client.c
@@ -734,7 +734,7 @@ do_migrate(int sock, int migr_reg_index, size_t nr_iters,
            struct iovec *migr_iter)
 {
     int ret;
-    __u64 pending_bytes, data_offset, data_size;
+    uint64_t pending_bytes, data_offset, data_size;
     size_t i = 0;
 
     assert(nr_iters > 0);
@@ -843,7 +843,7 @@ static size_t
 migrate_from(int sock, int migr_reg_index, size_t *nr_iters,
              struct iovec **migr_iters, unsigned char *md5sum, size_t bar1_size)
 {
-    __u32 device_state;
+    uint32_t device_state;
     int ret;
     size_t _nr_iters;
     pthread_t thread;
@@ -930,8 +930,8 @@ migrate_to(char *old_sock_path, int *server_max_fds,
     int ret, sock;
     char *sock_path;
     struct stat sb;
-    __u32 device_state = VFIO_DEVICE_STATE_RESUMING;
-    __u64 data_offset, data_len;
+    uint32_t device_state = VFIO_DEVICE_STATE_RESUMING;
+    uint64_t data_offset, data_len;
     size_t i;
 	MD5_CTX md5_ctx;
     char buf[bar1_size];
@@ -1008,7 +1008,7 @@ 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 %#llx-%#llx\n",
+        printf("client: writing migration device data %#lx-%#lx\n",
                data_offset, data_offset + migr_iters[i].iov_len - 1);
         ret = access_region(sock, migr_reg_index, true,
                             data_offset, migr_iters[i].iov_base,
diff --git a/samples/gpio-pci-idio-16.c b/samples/gpio-pci-idio-16.c
index 6c4206f..86ea083 100644
--- a/samples/gpio-pci-idio-16.c
+++ b/samples/gpio-pci-idio-16.c
@@ -78,7 +78,7 @@ migration_device_state_transition(vfu_ctx_t *vfu_ctx, vfu_migr_state_t state)
     return 0;
 }
 
-static __u64
+static uint64_t
 migration_get_pending_bytes(UNUSED vfu_ctx_t *vfu_ctx)
 {
     if (dirty) {
@@ -88,7 +88,8 @@ migration_get_pending_bytes(UNUSED vfu_ctx_t *vfu_ctx)
 }
 
 static int
-migration_prepare_data(UNUSED vfu_ctx_t *vfu_ctx, __u64 *offset, __u64 *size)
+migration_prepare_data(UNUSED vfu_ctx_t *vfu_ctx,
+                       uint64_t *offset, uint64_t *size)
 {
     *offset = 0;
     if (size != NULL) { /* null means resuming */
@@ -98,8 +99,8 @@ migration_prepare_data(UNUSED vfu_ctx_t *vfu_ctx, __u64 *offset, __u64 *size)
 }
 
 static ssize_t
-migration_read_data(UNUSED vfu_ctx_t *vfu_ctx, void *buf, __u64 size,
-                    __u64 offset)
+migration_read_data(UNUSED vfu_ctx_t *vfu_ctx, void *buf,
+                    uint64_t size, uint64_t offset)
 {
     assert(offset == 0);
     assert(size == sizeof(pin));
@@ -109,15 +110,15 @@ migration_read_data(UNUSED vfu_ctx_t *vfu_ctx, void *buf, __u64 size,
 }
 
 static int
-migration_data_written(UNUSED vfu_ctx_t *vfu_ctx, __u64 count)
+migration_data_written(UNUSED vfu_ctx_t *vfu_ctx, uint64_t count)
 {
     assert(count == sizeof(pin));
     return 0;
 }
 
 static ssize_t
-migration_write_data(UNUSED vfu_ctx_t *vfu_ctx, void *buf, __u64 size,
-                     __u64 offset)
+migration_write_data(UNUSED vfu_ctx_t *vfu_ctx, void *buf,
+                     uint64_t size, uint64_t offset)
 {
     assert(offset == 0);
     assert(size == sizeof(pin));
diff --git a/samples/server.c b/samples/server.c
index a449bb6..1ab184e 100644
--- a/samples/server.c
+++ b/samples/server.c
@@ -61,7 +61,7 @@ struct server_data {
     size_t bar1_size;
     struct dma_regions regions[NR_DMA_REGIONS];
     struct {
-        __u64 pending_bytes;
+        uint64_t pending_bytes;
         vfu_migr_state_t state;
     } migration;
 };
@@ -296,7 +296,7 @@ migration_device_state_transition(vfu_ctx_t *vfu_ctx, vfu_migr_state_t state)
     return 0;
 }
 
-static __u64
+static uint64_t
 migration_get_pending_bytes(vfu_ctx_t *vfu_ctx)
 {
     struct server_data *server_data = vfu_get_private(vfu_ctx);
@@ -304,7 +304,7 @@ migration_get_pending_bytes(vfu_ctx_t *vfu_ctx)
 }
 
 static int
-migration_prepare_data(vfu_ctx_t *vfu_ctx, __u64 *offset, __u64 *size)
+migration_prepare_data(vfu_ctx_t *vfu_ctx, uint64_t *offset, uint64_t *size)
 {
     struct server_data *server_data = vfu_get_private(vfu_ctx);
 
@@ -316,7 +316,8 @@ migration_prepare_data(vfu_ctx_t *vfu_ctx, __u64 *offset, __u64 *size)
 }
 
 static ssize_t
-migration_read_data(vfu_ctx_t *vfu_ctx, void *buf, __u64 size, __u64 offset)
+migration_read_data(vfu_ctx_t *vfu_ctx, void *buf,
+                    uint64_t size, uint64_t offset)
 {
     struct server_data *server_data = vfu_get_private(vfu_ctx);
 
@@ -354,7 +355,8 @@ migration_read_data(vfu_ctx_t *vfu_ctx, void *buf, __u64 size, __u64 offset)
 }
 
 static ssize_t
-migration_write_data(vfu_ctx_t *vfu_ctx, void *data, __u64 size, __u64 offset)
+migration_write_data(vfu_ctx_t *vfu_ctx, void *data,
+                     uint64_t size, uint64_t offset)
 {
     struct server_data *server_data = vfu_get_private(vfu_ctx);
     char *buf = data;
@@ -364,7 +366,7 @@ migration_write_data(vfu_ctx_t *vfu_ctx, void *data, __u64 size, __u64 offset)
     assert(data != NULL);
 
     if (offset != 0 || size < server_data->bar1_size) {
-        vfu_log(vfu_ctx, LOG_DEBUG, "XXX bad migration data write %#llx-%#llx",
+        vfu_log(vfu_ctx, LOG_DEBUG, "XXX bad migration data write %#lx-%#lx",
                 offset, offset + size - 1);
         errno = EINVAL;
         return -1;
@@ -389,7 +391,7 @@ migration_write_data(vfu_ctx_t *vfu_ctx, void *data, __u64 size, __u64 offset)
 
 
 static int
-migration_data_written(UNUSED vfu_ctx_t *vfu_ctx, UNUSED __u64 count)
+migration_data_written(UNUSED vfu_ctx_t *vfu_ctx, UNUSED uint64_t count)
 {
     /*
      * We apply migration state directly in the migration_write_data callback,
diff --git a/test/unit-tests.c b/test/unit-tests.c
index 4a628a0..5d92e5f 100644
--- a/test/unit-tests.c
+++ b/test/unit-tests.c
@@ -1333,8 +1333,8 @@ test_vfu_setup_device_dma(void **state UNUSED)
 static void
 test_migration_state_transitions(void **state UNUSED)
 {
-    bool (*f)(__u32, __u32) = vfio_migr_state_transition_is_valid;
-    __u32 i, j;
+    bool (*f)(uint32_t, uint32_t) = vfio_migr_state_transition_is_valid;
+    uint32_t i, j;
 
     /* from stopped (000b): all transitions are invalid */
     assert_true(f(0, 0));