[PATCH 09/41] libstore: Port to x86_64

[Sergey Bugaev]

---
 libstore/argp.c   |  6 ++++--
 libstore/copy.c   | 16 ++++++++++++----
 libstore/device.c | 28 +++++++++++++++++-----------
 libstore/file.c   | 32 ++++++++++++++++++++++++--------
 libstore/nbd.c    |  5 +++--
 libstore/store.h  |  9 ++++-----
 libstore/task.c   |  8 +++++++-
 7 files changed, 71 insertions(+), 33 deletions(-)

diff --git a/libstore/argp.c b/libstore/argp.c
index 31bae116..f2c99bae 100644
--- a/libstore/argp.c
+++ b/libstore/argp.c
@@ -24,6 +24,7 @@
 #include <hurd.h>
 #include <argp.h>
 #include <argz.h>
+#include <inttypes.h>
 
 #include "store.h"
 
@@ -88,7 +89,7 @@ store_parsed_append_args (const struct store_parsed *parsed,
   if (!err && num_names > 1 && (parsed->interleave || parsed->layer))
     {
       if (parsed->interleave)
-       snprintf (buf, sizeof buf, "--interleave=%Ld", parsed->interleave);
+       snprintf (buf, sizeof buf, "--interleave=%" PRIi64, parsed->interleave);
       else
        snprintf (buf, sizeof buf, "--layer=%d", parsed->layer);
       err = argz_add (args, args_len, buf);
@@ -131,7 +132,8 @@ store_parsed_name (const struct store_parsed *parsed, char 
**name)
     {
       if (parsed->interleave)
        {
-         snprintf (buf, sizeof buf, "interleave(%Ld,", parsed->interleave);
+         snprintf (buf, sizeof buf, "interleave(%" PRIi64 ",",
+                   parsed->interleave);
          pfx = buf;
        }
       else if (parsed->layer)
diff --git a/libstore/copy.c b/libstore/copy.c
index c670ebf3..16b99390 100644
--- a/libstore/copy.c
+++ b/libstore/copy.c
@@ -36,10 +36,18 @@ copy_read (struct store *store, store_offset_t addr, size_t 
index,
   char *data = store->hook + (addr * store->block_size);
 
   if (page_aligned (data) && page_aligned (amount))
-    /* When reading whole pages, we can avoid any real copying.  */
-    return vm_read (mach_task_self (),
-                   (vm_address_t) data, amount,
-                   (pointer_t *) buf, len);
+    {
+      /* When reading whole pages, we can avoid any real copying.  */
+      error_t err;
+      mach_msg_type_number_t nread;
+      err = vm_read (mach_task_self (),
+                     (vm_address_t) data, amount,
+                     (pointer_t *) buf, &nread);
+      if (err)
+        return err;
+      *len = nread;
+      return 0;
+    }
 
   if (*len < amount)
     /* Have to allocate memory for the return value.  */
diff --git a/libstore/device.c b/libstore/device.c
index 098506a0..c7b9d756 100644
--- a/libstore/device.c
+++ b/libstore/device.c
@@ -48,24 +48,30 @@ dev_error (error_t err)
 }
 
 static error_t
-dev_read (struct store *store,
-         store_offset_t addr, size_t index, mach_msg_type_number_t amount,
-         void **buf, mach_msg_type_number_t *len)
+dev_read (struct store *store, store_offset_t addr,
+          size_t index, size_t amount,
+          void **buf, size_t *len)
 {
+  error_t err;
   recnum_t recnum = addr;
+  mach_msg_type_number_t nread;
 
   if (recnum != addr)
     return EOVERFLOW;
 
-  return dev_error (device_read (store->port, 0, recnum, amount,
-                                (io_buf_ptr_t *)buf, len));
+  err = device_read (store->port, 0, recnum, amount,
+                     (io_buf_ptr_t *) buf, &nread);
+  if (err)
+    return dev_error (err);
+
+  *len = nread;
+  return 0;
 }
 
 static error_t
-dev_write (struct store *store,
-          store_offset_t addr, size_t index,
-          const void *buf, mach_msg_type_number_t len,
-          mach_msg_type_number_t *amount)
+dev_write (struct store *store, store_offset_t addr,
+           size_t index, const void *buf,
+           size_t len, size_t *amount)
 {
   recnum_t recnum = addr;
   error_t err;
@@ -195,7 +201,7 @@ enforced (struct store *store)
 {
   error_t err;
   dev_status_data_t sizes;
-  size_t sizes_len = DEV_STATUS_MAX;
+  mach_msg_type_number_t sizes_len = DEV_STATUS_MAX;
 
   if (store->num_runs != 1 || store->runs[0].start != 0)
     /* Can't enforce non-contiguous ranges, or one not starting at 0.  */
@@ -324,7 +330,7 @@ store_device_create (device_t device, int flags, struct 
store **store)
   struct store_run run;
   size_t block_size = 0;
   dev_status_data_t sizes;
-  size_t sizes_len = DEV_STATUS_MAX;
+  mach_msg_type_number_t sizes_len = DEV_STATUS_MAX;
   error_t err;
 
 #ifdef DEV_GET_RECORDS
diff --git a/libstore/file.c b/libstore/file.c
index ce02f1f4..c54eee91 100644
--- a/libstore/file.c
+++ b/libstore/file.c
@@ -51,12 +51,20 @@ enforced (struct store *store)
 }
 
 static error_t
-file_read (struct store *store,
-          store_offset_t addr, size_t index, size_t amount, void **buf,
-          size_t *len)
+file_read (struct store *store, store_offset_t addr,
+           size_t index, size_t amount,
+           void **buf, size_t *len)
 {
+  error_t err;
   size_t bsize = store->block_size;
-  return io_read (store->port, (char **)buf, len, addr * bsize, amount);
+  mach_msg_type_number_t nread = *len;
+
+  err = io_read (store->port, (char **) buf, &nread, addr * bsize, amount);
+  if (err)
+    return err;
+
+  *len = nread;
+  return 0;
 }
 
 static error_t
@@ -222,11 +230,19 @@ store_file_class =
 STORE_STD_CLASS (file);
 
 static error_t
-file_byte_read (struct store *store,
-               store_offset_t addr, size_t index, size_t amount,
-               void **buf, size_t *len)
+file_byte_read (struct store *store, store_offset_t addr,
+                size_t index, size_t amount,
+                void **buf, size_t *len)
 {
-  return io_read (store->port, (char **)buf, len, addr, amount);
+  error_t err;
+  mach_msg_type_number_t nread = *len;
+
+  err = io_read (store->port, (char **) buf, &nread, addr, amount);
+  if (err)
+    return err;
+
+  *len = nread;
+  return 0;
 }
 
 static error_t
diff --git a/libstore/nbd.c b/libstore/nbd.c
index 8e0892e3..df949a78 100644
--- a/libstore/nbd.c
+++ b/libstore/nbd.c
@@ -171,12 +171,13 @@ nbd_read (struct store *store,
   error_t err;
   size_t ofs, chunk;
   char *databuf, *piecebuf;
-  size_t databuflen, piecelen;
+  size_t databuflen;
+  mach_msg_type_number_t piecelen;
 
   /* Send a request for the largest possible piece of remaining data and
      read the first piece of its reply into PIECEBUF, PIECELEN.  The amount
      requested can be found in CHUNK.  */
-  inline error_t request_chunk (char **buf, size_t *len)
+  inline error_t request_chunk (char **buf, mach_msg_type_number_t *len)
     {
       vm_size_t cc;
 
diff --git a/libstore/store.h b/libstore/store.h
index ae334a1d..f4697460 100644
--- a/libstore/store.h
+++ b/libstore/store.h
@@ -127,13 +127,12 @@ struct store
 
 typedef error_t (*store_write_meth_t)(struct store *store,
                                      store_offset_t addr, size_t index,
-                                     const void *buf,
-                                     mach_msg_type_number_t len,
-                                     mach_msg_type_number_t *amount);
+                                     const void *buf, size_t len,
+                                     size_t *amount);
 typedef error_t (*store_read_meth_t)(struct store *store,
                                     store_offset_t addr, size_t index,
-                                    mach_msg_type_number_t amount,
-                                    void **buf, mach_msg_type_number_t *len);
+                                    size_t amount,
+                                    void **buf, size_t *len);
 typedef error_t (*store_set_size_meth_t)(struct store *store,
                                         size_t newsize);
 
diff --git a/libstore/task.c b/libstore/task.c
index 4908ce5d..977cdc77 100644
--- a/libstore/task.c
+++ b/libstore/task.c
@@ -59,8 +59,14 @@ static error_t
 task_read (struct store *store,
           store_offset_t addr, size_t index, size_t amount, void **buf, size_t 
*len)
 {
+  error_t err;
   size_t bsize = store->block_size;
-  return vm_read (store->port, addr * bsize, amount, (vm_address_t *)buf, len);
+  mach_msg_type_number_t nread;
+  err = vm_read (store->port, addr * bsize, amount, (vm_address_t *) buf, 
&nread);
+  if (err)
+    return err;
+  *len = nread;
+  return 0;
 }
 
 static error_t
-- 
2.40.1