review

src/aio/aio_provider.h

@@ -61,8 +61,8 @@ class aio_provider
 
     virtual error_code close(dsn_handle_t fh) = 0;
     virtual error_code flush(dsn_handle_t fh) = 0;
-    virtual error_code write(aio_context *aio_ctx, uint32_t *processed_bytes) = 0;
-    virtual error_code read(aio_context *aio_ctx, uint32_t *processed_bytes) = 0;
+    virtual error_code write(const aio_context &aio_ctx, /*out*/ uint32_t *processed_bytes) = 0;
+    virtual error_code read(const aio_context &aio_ctx, /*out*/ uint32_t *processed_bytes) = 0;
 
     // Submits the aio_task to the underlying disk-io executor.
     // This task may not be executed immediately, call `aio_task::wait`

src/aio/native_linux_aio_provider.cpp

@@ -63,25 +63,27 @@ error_code native_linux_aio_provider::flush(dsn_handle_t fh)
     }
 }
 
-error_code native_linux_aio_provider::write(aio_context *aio_ctx, uint32_t *processed_bytes)
+error_code native_linux_aio_provider::write(const aio_context &aio_ctx,
+                                            /*out*/ uint32_t *processed_bytes)
 {
-    ssize_t ret = pwrite(static_cast<int>((ssize_t)aio_ctx->file),
-                         aio_ctx->buffer,
-                         aio_ctx->buffer_size,
-                         aio_ctx->file_offset);
+    ssize_t ret = pwrite(static_cast<int>((ssize_t)aio_ctx.file),
+                         aio_ctx.buffer,
+                         aio_ctx.buffer_size,
+                         aio_ctx.file_offset);
     if (ret < 0) {
         return ERR_FILE_OPERATION_FAILED;
     }
     *processed_bytes = static_cast<uint32_t>(ret);
     return ERR_OK;
 }
 
-error_code native_linux_aio_provider::read(aio_context *aio_ctx, uint32_t *processed_bytes)
+error_code native_linux_aio_provider::read(const aio_context &aio_ctx,
+                                           /*out*/ uint32_t *processed_bytes)
 {
-    ssize_t ret = pread(static_cast<int>((ssize_t)aio_ctx->file),
-                        aio_ctx->buffer,
-                        aio_ctx->buffer_size,
-                        aio_ctx->file_offset);
+    ssize_t ret = pread(static_cast<int>((ssize_t)aio_ctx.file),
+                        aio_ctx.buffer,
+                        aio_ctx.buffer_size,
+                        aio_ctx.file_offset);
     if (ret < 0) {
         return ERR_FILE_OPERATION_FAILED;
     }
@@ -109,10 +111,10 @@ error_code native_linux_aio_provider::aio_internal(aio_task *aio_tsk,
     uint32_t processed_bytes = 0;
     switch (aio_ctx->type) {
     case AIO_Read:
-        err = read(aio_ctx, &processed_bytes);
+        err = read(*aio_ctx, &processed_bytes);
         break;
     case AIO_Write:
-        err = write(aio_ctx, &processed_bytes);
+        err = write(*aio_ctx, &processed_bytes);
         break;
     default:
         return err;

src/aio/native_linux_aio_provider.h

@@ -39,8 +39,8 @@ class native_linux_aio_provider : public aio_provider
     dsn_handle_t open(const char *file_name, int flag, int pmode) override;
     error_code close(dsn_handle_t fh) override;
     error_code flush(dsn_handle_t fh) override;
-    error_code write(aio_context *aio_ctx, uint32_t *processed_bytes) override;
-    error_code read(aio_context *aio_ctx, uint32_t *processed_bytes) override;
+    error_code write(const aio_context &aio_ctx, /*out*/ uint32_t *processed_bytes) override;
+    error_code read(const aio_context &aio_ctx, /*out*/ uint32_t *processed_bytes) override;
 
     void submit_aio_task(aio_task *aio) override;
     aio_context *prepare_aio_context(aio_task *tsk) override { return new aio_context; }

src/nfs/nfs_client_impl.cpp

@@ -268,6 +268,7 @@ void nfs_client_impl::continue_copy()
             zauto_lock l(req->lock);
             const user_request_ptr &ureq = req->file_ctx->user_req;
             if (req->is_valid) {
+                // todo(jiashuo1) use non-block api `consumeWithBorrowNonBlocking` or `consume`
                 _copy_token_bucket->consumeWithBorrowAndWait(req->size);
 
                 copy_request copy_req;