rgw: switch to std::size_t in the front-end infrastructure.

Signed-off-by: Radoslaw Zarzynski <rzarzynski@mirantis.com>

diff --git a/src/rgw/rgw_asio_client.cc b/src/rgw/rgw_asio_client.cc
index 42251ae1d6be65ab568e8f51776a1abd3c8a78e2..8d6a9c3f858510b6925b02c72e107d28514e3925 100644 (file)
--- a/src/rgw/rgw_asio_client.cc
+++ b/src/rgw/rgw_asio_client.cc
@@ -78,7 +78,8 @@ void RGWAsioClientIO::init_env(CephContext *cct)
   // TODO: set REMOTE_USER if authenticated
 }
 
-int RGWAsioClientIO::write_data(const char* const buf, const int len)
+std::size_t RGWAsioClientIO::write_data(const char* const buf,
+                                        const std::size_t len)
 {
   boost::system::error_code ec;
   auto bytes = boost::asio::write(socket, boost::asio::buffer(buf, len), ec);
@@ -89,7 +90,7 @@ int RGWAsioClientIO::write_data(const char* const buf, const int len)
   return bytes;
 }
 
-int RGWAsioClientIO::read_data(char* const buf, const int max)
+std::size_t RGWAsioClientIO::read_data(char* const buf, const std::size_t max)
 {
   // read data from the body's bufferlist
   auto bytes = std::min<unsigned>(max, body_iter.get_remaining());
@@ -107,8 +108,8 @@ void RGWAsioClientIO::flush()
   return;
 }
 
-int RGWAsioClientIO::send_status(const int status,
-                                 const char* const status_name)
+std::size_t RGWAsioClientIO::send_status(const int status,
+                                         const char* const status_name)
 {
   static constexpr size_t STATUS_BUF_SIZE = 128;
 
@@ -119,7 +120,7 @@ int RGWAsioClientIO::send_status(const int status,
   return write_data(statusbuf, statuslen);
 }
 
-int RGWAsioClientIO::send_100_continue()
+std::size_t RGWAsioClientIO::send_100_continue()
 {
   const char HTTTP_100_CONTINUE[] = "HTTP/1.1 100 CONTINUE\r\n\r\n";
   return write_data(HTTTP_100_CONTINUE, sizeof(HTTTP_100_CONTINUE) - 1);
@@ -138,7 +139,7 @@ static size_t dump_date_header(char (&timestr)[TIME_BUF_SIZE])
                   "Date: %a, %d %b %Y %H:%M:%S %Z\r\n", tmp);
 }
 
-int RGWAsioClientIO::complete_header()
+std::size_t RGWAsioClientIO::complete_header()
 {
   size_t sent = 0;
 
@@ -159,7 +160,7 @@ int RGWAsioClientIO::complete_header()
   return sent + write_data(HEADER_END, sizeof(HEADER_END) - 1);
 }
 
-int RGWAsioClientIO::send_content_length(const uint64_t len)
+std::size_t RGWAsioClientIO::send_content_length(const uint64_t len)
 {
   static constexpr size_t CONLEN_BUF_SIZE = 128;
 

diff --git a/src/rgw/rgw_asio_client.h b/src/rgw/rgw_asio_client.h
index 1f0dbbcdfdbd61bfc5e2f8f50e8d9e51e74e90e1..6f196927705397d744923b38fb80861e191dd4d7 100644 (file)
--- a/src/rgw/rgw_asio_client.h
+++ b/src/rgw/rgw_asio_client.h
@@ -39,8 +39,8 @@ class RGWAsioClientIO : public RGWStreamIOEngine {
   RGWEnv env;
 
   void init_env(CephContext *cct) override;
-  int write_data(const char *buf, int len) override;
-  int read_data(char *buf, int max) override;
+  std::size_t write_data(const char *buf, std::size_t len) override;
+  std::size_t read_data(char *buf, std::size_t max) override;
 
  public:
   RGWAsioClientIO(tcp::socket&& socket, request_type&& request);
@@ -48,10 +48,10 @@ class RGWAsioClientIO : public RGWStreamIOEngine {
 
   int complete_request() override;
   void flush() override;
-  int send_status(int status, const char *status_name) override;
-  int send_100_continue() override;
-  int complete_header() override;
-  int send_content_length(uint64_t len) override;
+  std::size_t send_status(int status, const char *status_name) override;
+  std::size_t send_100_continue() override;
+  std::size_t complete_header() override;
+  std::size_t send_content_length(uint64_t len) override;
 
   RGWEnv& get_env() noexcept override {
     return env;

diff --git a/src/rgw/rgw_civetweb.cc b/src/rgw/rgw_civetweb.cc
index 1ef15641fd2870addee095b14c76ba7ae2aa8a31..7cc8bd1e70fdb1ecf7a0fa7787f55ea4e2611d2e 100644 (file)
--- a/src/rgw/rgw_civetweb.cc
+++ b/src/rgw/rgw_civetweb.cc
@@ -12,7 +12,7 @@
 
 #define dout_subsys ceph_subsys_rgw
 
-int RGWCivetWeb::write_data(const char *buf, int len)
+std::size_t RGWCivetWeb::write_data(const char *buf, std::size_t len)
 {
   const int ret = mg_write(conn, buf, len);
   if (ret == 0) {
@@ -32,7 +32,7 @@ RGWCivetWeb::RGWCivetWeb(mg_connection* const conn, const int port)
 {
 }
 
-int RGWCivetWeb::read_data(char *buf, int len)
+std::size_t RGWCivetWeb::read_data(char *buf, std::size_t len)
 {
   const int ret = mg_read(conn, buf, len);
   if (ret < 0) {
@@ -128,7 +128,7 @@ static inline std::size_t safe_mg_printf(Args&&... args)
   return static_cast<std::size_t>(ret);
 }
 
-int RGWCivetWeb::send_status(int status, const char *status_name)
+std::size_t RGWCivetWeb::send_status(int status, const char *status_name)
 {
   mg_set_http_status(conn, status);
 
@@ -136,13 +136,13 @@ int RGWCivetWeb::send_status(int status, const char *status_name)
                         status_name ? status_name : "");
 }
 
-int RGWCivetWeb::send_100_continue()
+std::size_t RGWCivetWeb::send_100_continue()
 {
   const char HTTTP_100_CONTINUE[] = "HTTP/1.1 100 CONTINUE\r\n\r\n";
   return write_data(HTTTP_100_CONTINUE, sizeof(HTTTP_100_CONTINUE) - 1);
 }
 
-int RGWCivetWeb::dump_date_header()
+std::size_t RGWCivetWeb::dump_date_header()
 {
   char timestr[TIME_BUF_SIZE];
 
@@ -162,9 +162,9 @@ int RGWCivetWeb::dump_date_header()
   return write_data(timestr, strlen(timestr));
 }
 
-int RGWCivetWeb::complete_header()
+std::size_t RGWCivetWeb::complete_header()
 {
-  size_t sent = dump_date_header();
+  std::size_t sent = dump_date_header();
 
   if (explicit_keepalive) {
     constexpr char CONN_KEEP_ALIVE[] = "Connection: Keep-Alive\r\n";
@@ -178,7 +178,7 @@ int RGWCivetWeb::complete_header()
   return sent + write_data(HEADER_END, sizeof(HEADER_END) - 1);
 }
 
-int RGWCivetWeb::send_content_length(uint64_t len)
+std::size_t RGWCivetWeb::send_content_length(uint64_t len)
 {
   return safe_mg_printf(conn, "Content-Length: %" PRIu64 "\r\n", len);
 }

diff --git a/src/rgw/rgw_civetweb.h b/src/rgw/rgw_civetweb.h
index 0072d99c306f362424d31d3dec5bc570e355de4a..b0e9a0f41a1abf06a59e6884a9fb36d4e5beec50 100644 (file)
--- a/src/rgw/rgw_civetweb.h
+++ b/src/rgw/rgw_civetweb.h
@@ -20,17 +20,17 @@ class RGWCivetWeb : public RGWStreamIOEngine
   bool explicit_keepalive;
   bool explicit_conn_close;
 
-  int dump_date_header();
+  std::size_t dump_date_header();
 public:
   void init_env(CephContext *cct);
 
-  int write_data(const char *buf, int len) override;
-  int read_data(char *buf, int len) override;
+  std::size_t write_data(const char *buf, std::size_t len) override;
+  std::size_t read_data(char *buf, std::size_t len) override;
 
-  int send_status(int status, const char *status_name) override;
-  int send_100_continue() override;
-  int send_content_length(uint64_t len) override;
-  int complete_header() override;
+  std::size_t send_status(int status, const char *status_name) override;
+  std::size_t send_100_continue() override;
+  std::size_t send_content_length(uint64_t len) override;
+  std::size_t complete_header() override;
   int complete_request() override;
 
   void flush() override;

diff --git a/src/rgw/rgw_client_io.h b/src/rgw/rgw_client_io.h
index afb8461ce9156abbe7a88e5f760473761eebbcbd..62a99d9e8953d3304681b10aa666bf810a9aefda 100644 (file)
--- a/src/rgw/rgw_client_io.h
+++ b/src/rgw/rgw_client_io.h
@@ -43,8 +43,8 @@ class RGWStreamIOEngine : public RGWClientIO {
   friend class RGWStreamIOLegacyWrapper;
 
 protected:
-  virtual int read_data(char *buf, int max) = 0;
-  virtual int write_data(const char *buf, int len) = 0;
+  virtual std::size_t read_data(char *buf, std::size_t max) = 0;
+  virtual std::size_t write_data(const char *buf, std::size_t len) = 0;
 
 public:
   class Exception : public std::exception {
@@ -60,20 +60,22 @@ public:
     }
   };
 
-  virtual int send_status(int status, const char *status_name) = 0;
-  virtual int send_100_continue() = 0;
-  virtual int complete_header() = 0;
-  virtual int send_content_length(uint64_t len) = 0;
+  virtual std::size_t send_status(int status, const char *status_name) = 0;
+  virtual std::size_t send_100_continue() = 0;
+  virtual std::size_t complete_header() = 0;
+  virtual std::size_t send_content_length(uint64_t len) = 0;
   virtual void flush() = 0;
 };
 
 
+class RGWStreamIO;
+
 class RGWStreamIOFacade {
 protected:
-  RGWStreamIOEngine& engine;
+  RGWStreamIO& engine;
 
 public:
-  RGWStreamIOFacade(RGWStreamIOEngine* const engine)
+  RGWStreamIOFacade(RGWStreamIO* const engine)
     : engine(*engine) {
   }
 
@@ -87,7 +89,7 @@ public:
 
 
 /* HTTP IO: compatibility layer */
-class RGWStreamIO : public RGWStreamIOEngine,
+class RGWStreamIO : public RGWClientIO,
                     public RGWStreamIOFacade,
                     public RGWClientIOAccounter {
   bool _account;
@@ -104,6 +106,13 @@ protected:
   RGWEnv env;
 
 public:
+  virtual int read_data(char *buf, int max) = 0;
+  virtual int write_data(const char *buf, int len) = 0;
+  virtual int send_status(int status, const char *status_name) = 0;
+  virtual int send_100_continue() = 0;
+  virtual int complete_header() = 0;
+  virtual int send_content_length(uint64_t len) = 0;
+  virtual void flush() = 0;
   virtual ~RGWStreamIO() {}
   RGWStreamIO()
     : RGWStreamIOFacade(this),

diff --git a/src/rgw/rgw_client_io_decoimpl.h b/src/rgw/rgw_client_io_decoimpl.h
index ebb48820d032e9c2f3d9b0c7599a5556b1790ea6..8f963fe6b62e4d8efef17e0e4519f66e1fb7bb97 100644 (file)
--- a/src/rgw/rgw_client_io_decoimpl.h
+++ b/src/rgw/rgw_client_io_decoimpl.h
@@ -46,11 +46,13 @@ protected:
     return get_decoratee().init_env(cct);
   }
 
-  int read_data(char* const buf, const int max) override {
+  std::size_t read_data(char* const buf,
+                        const std::size_t max) override {
     return get_decoratee().read_data(buf, max);
   }
 
-  int write_data(const char* const buf, const int len) override {
+  std::size_t write_data(const char* const buf,
+                         const std::size_t len) override {
     return get_decoratee().write_data(buf, len);
   }
 
@@ -59,19 +61,20 @@ public:
     : decoratee(decoratee) {
   }
 
-  int send_status(const int status, const char* const status_name) override {
+  std::size_t send_status(const int status,
+                          const char* const status_name) override {
     return get_decoratee().send_status(status, status_name);
   }
 
-  int send_100_continue() override {
+  std::size_t send_100_continue() override {
     return get_decoratee().send_100_continue();
   }
 
-  int send_content_length(const uint64_t len) override {
+  std::size_t send_content_length(const uint64_t len) override {
     return get_decoratee().send_content_length(len);
   }
 
-  int complete_header() override {
+  std::size_t complete_header() override {
     return get_decoratee().complete_header();
   }
 
@@ -97,7 +100,7 @@ class RGWStreamIOAccountingEngine : public RGWDecoratedStreamIO<T>,
   uint64_t total_received;
 
 protected:
-  int read_data(char* const buf, const int max) override {
+  std::size_t read_data(char* const buf, const std::size_t max) override {
     const auto received = RGWDecoratedStreamIO<T>::read_data(buf, max);
     if (enabled) {
       total_received += received;
@@ -105,7 +108,8 @@ protected:
     return received;
   }
 
-  int write_data(const char* const buf, const int len) override {
+  std::size_t write_data(const char* const buf,
+                         const std::size_t len) override {
     const auto sent = RGWDecoratedStreamIO<T>::write_data(buf, len);
     if (enabled) {
       total_sent += sent;
@@ -122,7 +126,8 @@ public:
       total_received(0) {
   }
 
-  int send_status(const int status, const char* const status_name) override {
+  std::size_t send_status(const int status,
+                          const char* const status_name) override {
     const auto sent = RGWDecoratedStreamIO<T>::send_status(status, status_name);
     if (enabled) {
       total_sent += sent;
@@ -130,7 +135,7 @@ public:
     return sent;
   }
 
-  int send_100_continue() override {
+  std::size_t send_100_continue() override {
     const auto sent = RGWDecoratedStreamIO<T>::send_100_continue();
     if (enabled) {
       total_sent += sent;
@@ -138,7 +143,7 @@ public:
     return sent;
   }
 
-  int send_content_length(const uint64_t len) override {
+  std::size_t send_content_length(const uint64_t len) override {
     const auto sent = RGWDecoratedStreamIO<T>::send_content_length(len);
     if (enabled) {
       total_sent += sent;
@@ -146,7 +151,7 @@ public:
     return sent;
   }
 
-  int complete_header() override {
+  std::size_t complete_header() override {
     const auto sent = RGWDecoratedStreamIO<T>::complete_header();
     if (enabled) {
       total_sent += sent;
@@ -179,7 +184,7 @@ protected:
   bool has_content_length;
   bool buffer_data;
 
-  int write_data(const char* buf, const int len) override;
+  std::size_t write_data(const char* buf, const std::size_t len) override;
 
 public:
   template <typename U>
@@ -189,14 +194,14 @@ public:
       buffer_data(false) {
   }
 
-  int send_content_length(const uint64_t len) override;
-  int complete_header() override;
+  std::size_t send_content_length(const uint64_t len) override;
+  std::size_t complete_header() override;
   int complete_request() override;
 };
 
 template <typename T>
-int RGWStreamIOBufferingEngine<T>::write_data(const char* buf,
-                                              const int len)
+std::size_t RGWStreamIOBufferingEngine<T>::write_data(const char* buf,
+                                                      const std::size_t len)
 {
   if (buffer_data) {
     data.append(buf, len);
@@ -207,14 +212,14 @@ int RGWStreamIOBufferingEngine<T>::write_data(const char* buf,
 }
 
 template <typename T>
-int RGWStreamIOBufferingEngine<T>::send_content_length(const uint64_t len)
+std::size_t RGWStreamIOBufferingEngine<T>::send_content_length(const uint64_t len)
 {
   has_content_length = true;
   return RGWDecoratedStreamIO<T>::send_content_length(len);
 }
 
 template <typename T>
-int RGWStreamIOBufferingEngine<T>::complete_header()
+std::size_t RGWStreamIOBufferingEngine<T>::complete_header()
 {
   if (! has_content_length) {
     /* We will dump everything in complete_request(). */
@@ -257,7 +262,8 @@ protected:
   bool has_content_length;
   bool chunking_enabled;
 
-  int write_data(const char* const buf, const int len) override {
+  std::size_t write_data(const char* const buf,
+                         const std::size_t len) override {
     if (! chunking_enabled) {
       return RGWDecoratedStreamIO<T>::write_data(buf, len);
     } else {
@@ -279,13 +285,12 @@ public:
       chunking_enabled(false) {
   }
 
-  using RGWDecoratedStreamIO<T>::send_content_length;
-  int send_content_length(const uint64_t len) override {
+  std::size_t send_content_length(const uint64_t len) override {
     has_content_length = true;
     return RGWDecoratedStreamIO<T>::send_content_length(len);
   }
 
-  int complete_header() override {
+  std::size_t complete_header() override {
     size_t sent = 0;
 
     if (! has_content_length) {
@@ -325,7 +330,8 @@ public:
       action(ContentLengthAction::UNKNOWN) {
   }
 
-  int send_status(const int status, const char* const status_name) override {
+  std::size_t send_status(const int status,
+                          const char* const status_name) override {
     if (204 == status || 304 == status) {
       action = ContentLengthAction::INHIBIT;
     } else {
@@ -335,7 +341,7 @@ public:
     return RGWDecoratedStreamIO<T>::send_status(status, status_name);
   }
 
-  int send_content_length(const uint64_t len) override {
+  std::size_t send_content_length(const uint64_t len) override {
     switch(action) {
     case ContentLengthAction::FORWARD:
       return RGWDecoratedStreamIO<T>::send_content_length(len);
@@ -370,7 +376,8 @@ protected:
   ceph::bufferlist early_header_data;
   ceph::bufferlist header_data;
 
-  int write_data(const char* const buf, const int len) override {
+  std::size_t write_data(const char* const buf,
+                         const std::size_t len) override {
     switch (phase) {
     case ReorderState::RGW_EARLY_HEADERS:
       early_header_data.append(buf, len);
@@ -392,13 +399,14 @@ public:
       phase(ReorderState::RGW_EARLY_HEADERS) {
   }
 
-  int send_status(const int status, const char* const status_name) override {
+  std::size_t send_status(const int status,
+                          const char* const status_name) override {
     phase = ReorderState::RGW_STATUS_SEEN;
 
     return RGWDecoratedStreamIO<T>::send_status(status, status_name);
   }
 
-  int send_content_length(const uint64_t len) override {
+  std::size_t send_content_length(const uint64_t len) override {
     if (ReorderState::RGW_EARLY_HEADERS == phase) {
       /* Oh great, someone tries to send content length before status. */
       content_length = len;
@@ -408,7 +416,7 @@ public:
     }
   }
 
-  int complete_header() override {
+  std::size_t complete_header() override {
     size_t sent = 0;
 
     /* Change state in order to immediately send everything we get. */

diff --git a/src/rgw/rgw_fcgi.cc b/src/rgw/rgw_fcgi.cc
index 5b59f717b5bec48e24d2fdcdda35d4dd876cd4be..13722a77492f6ddac193c8563d253dcfa95bcfa5 100644 (file)
--- a/src/rgw/rgw_fcgi.cc
+++ b/src/rgw/rgw_fcgi.cc
@@ -5,7 +5,7 @@
 
 #include "acconfig.h"
 
-int RGWFCGX::write_data(const char* const buf, const int len)
+std::size_t RGWFCGX::write_data(const char* const buf, const std::size_t len)
 {
   const auto ret = FCGX_PutStr(buf, len, fcgx->out);
   if (ret < 0) {
@@ -14,7 +14,7 @@ int RGWFCGX::write_data(const char* const buf, const int len)
   return ret;
 }
 
-int RGWFCGX::read_data(char* const buf, const int len)
+std::size_t RGWFCGX::read_data(char* const buf, const std::size_t len)
 {
   const auto ret = FCGX_GetStr(buf, len, fcgx->in);
   if (ret < 0) {
@@ -33,7 +33,7 @@ void RGWFCGX::init_env(CephContext* const cct)
   env.init(cct, (char **)fcgx->envp);
 }
 
-int RGWFCGX::send_status(const int status, const char* const status_name)
+std::size_t RGWFCGX::send_status(const int status, const char* const status_name)
 {
   static constexpr size_t STATUS_BUF_SIZE = 128;
 
@@ -44,16 +44,12 @@ int RGWFCGX::send_status(const int status, const char* const status_name)
   return write_data(statusbuf, statuslen);
 }
 
-int RGWFCGX::send_100_continue()
+std::size_t RGWFCGX::send_100_continue()
 {
-  int r = send_status(100, "Continue");
-  if (r >= 0) {
-    flush();
-  }
-  return r;
+  return send_status(100, "Continue");
 }
 
-int RGWFCGX::send_content_length(const uint64_t len)
+std::size_t RGWFCGX::send_content_length(const uint64_t len)
 {
   static constexpr size_t CONLEN_BUF_SIZE = 128;
 
@@ -64,7 +60,7 @@ int RGWFCGX::send_content_length(const uint64_t len)
   return write_data(sizebuf, sizelen);
 }
 
-int RGWFCGX::complete_header()
+std::size_t RGWFCGX::complete_header()
 {
   constexpr char HEADER_END[] = "\r\n";
   return write_data(HEADER_END, sizeof(HEADER_END) - 1);

diff --git a/src/rgw/rgw_fcgi.h b/src/rgw/rgw_fcgi.h
index 4f235714e341f3980b63a87eac4e810313a4f7e8..6f5e4fdb9930a7a6d6553ccda3880baaf413666e 100644 (file)
--- a/src/rgw/rgw_fcgi.h
+++ b/src/rgw/rgw_fcgi.h
@@ -22,13 +22,13 @@ public:
   }
 
   void init_env(CephContext* cct) override;
-  int read_data(char* buf, int len) override;
-  int write_data(const char* buf, int len) override;
+  std::size_t read_data(char* buf, std::size_t len) override;
+  std::size_t write_data(const char* buf, std::size_t len) override;
 
-  int send_status(int status, const char* status_name) override;
-  int send_100_continue() override;
-  int send_content_length(uint64_t len) override;
-  int complete_header() override;
+  std::size_t send_status(int status, const char* status_name) override;
+  std::size_t send_100_continue() override;
+  std::size_t send_content_length(uint64_t len) override;
+  std::size_t complete_header() override;
 
   void flush();
 

diff --git a/src/rgw/rgw_loadgen.cc b/src/rgw/rgw_loadgen.cc
index 634afafda7dd7e19e3a6ff7f051414330671926e..0f54bca44fdc08a80b3d5685aa886a0c22d642c9 100644 (file)
--- a/src/rgw/rgw_loadgen.cc
+++ b/src/rgw/rgw_loadgen.cc
@@ -46,16 +46,18 @@ int RGWLoadGenRequestEnv::sign(RGWAccessKey& access_key)
   return 0;
 }
 
-int RGWLoadGenIO::write_data(const char* const buf, const int len)
+std::size_t RGWLoadGenIO::write_data(const char* const buf,
+                                     const std::size_t len)
 {
   return len;
 }
 
-int RGWLoadGenIO::read_data(char* const buf, const int len)
+std::size_t RGWLoadGenIO::read_data(char* const buf, const std::size_t len)
 {
-  const int read_len = std::min(left_to_read, static_cast<uint64_t>(len));
+  const std::size_t read_len = std::min(left_to_read,
+                                        static_cast<uint64_t>(len));
   left_to_read -= read_len;
-  return static_cast<int>(read_len);
+  return read_len;
 }
 
 void RGWLoadGenIO::flush()
@@ -94,22 +96,23 @@ void RGWLoadGenIO::init_env(CephContext *cct)
   env.set("SERVER_PORT", port_buf);
 }
 
-int RGWLoadGenIO::send_status(const int status, const char* const status_name)
+std::size_t RGWLoadGenIO::send_status(const int status,
+                                      const char* const status_name)
 {
   return 0;
 }
 
-int RGWLoadGenIO::send_100_continue()
+std::size_t RGWLoadGenIO::send_100_continue()
 {
   return 0;
 }
 
-int RGWLoadGenIO::complete_header()
+std::size_t RGWLoadGenIO::complete_header()
 {
   return 0;
 }
 
-int RGWLoadGenIO::send_content_length(const uint64_t len)
+std::size_t RGWLoadGenIO::send_content_length(const uint64_t len)
 {
   return 0;
 }

diff --git a/src/rgw/rgw_loadgen.h b/src/rgw/rgw_loadgen.h
index 173e493b122cbe9bf9f5fedeec821aa1e2cb648e..5f269c8ad371879e6a1b4cbcd1bbd20281ebd2b2 100644 (file)
--- a/src/rgw/rgw_loadgen.h
+++ b/src/rgw/rgw_loadgen.h
@@ -45,13 +45,13 @@ public:
   }
 
   void init_env(CephContext *cct);
-  int read_data(char *buf, int len);
-  int write_data(const char *buf, int len);
+  std::size_t read_data(char *buf, std::size_t len);
+  std::size_t write_data(const char *buf, std::size_t len);
 
-  int send_status(int status, const char *status_name);
-  int send_100_continue();
-  int complete_header();
-  int send_content_length(uint64_t len);
+  std::size_t send_status(int status, const char *status_name);
+  std::size_t send_100_continue();
+  std::size_t complete_header();
+  std::size_t send_content_length(uint64_t len);
 
   void flush();