lib-fs: fs_wait_async() can't fail, so make it return void.

The individual requests can timeout, but not the waiting itself.

diff --git a/src/doveadm/doveadm-fs.c b/src/doveadm/doveadm-fs.c
index b0e066d8b7dc4d6a8f97e6043cde9c494353eecd..26ca69774ebd4482c991681f65b475a4292d8c2f 100644 (file)
--- a/src/doveadm/doveadm-fs.c
+++ b/src/doveadm/doveadm-fs.c
@@ -296,11 +296,8 @@ static int doveadm_fs_delete_async_fname(struct fs_delete_ctx *ctx,
        if ((ret = cmd_fs_delete_ctx_run(ctx)) < 0)
                return -1;
        if (fname != NULL) {
-               if (ret > 0 && fs_wait_async(ctx->fs) < 0) {
-                       i_error("fs_wait_async() failed: %s", fs_last_error(ctx->fs));
-                       doveadm_exit_code = EX_TEMPFAIL;
-                       return -1;;
-               }
+               if (ret > 0)
+                       fs_wait_async(ctx->fs);
                return doveadm_fs_delete_async_fname(ctx, fname);
        }
        return 0;
@@ -311,11 +308,7 @@ static void doveadm_fs_delete_async_finish(struct fs_delete_ctx *ctx)
        unsigned int i;
 
        while (doveadm_exit_code == 0 && cmd_fs_delete_ctx_run(ctx) > 0) {
-               if (fs_wait_async(ctx->fs) < 0) {
-                       i_error("fs_wait_async() failed: %s", fs_last_error(ctx->fs));
-                       doveadm_exit_code = EX_TEMPFAIL;
-                       break;
-               }
+               fs_wait_async(ctx->fs);
        }
        for (i = 0; i < ctx->files_count; i++) {
                if (ctx->files[i] != NULL)

diff --git a/src/lib-fs/fs-api-private.h b/src/lib-fs/fs-api-private.h
index c98b4b2bae5a4a084f64989d7dc2759399b9da2f..8172b1ac760f5d35f3c38330b4cad25665babdf3 100644 (file)
--- a/src/lib-fs/fs-api-private.h
+++ b/src/lib-fs/fs-api-private.h
@@ -34,7 +34,7 @@ struct fs_vfuncs {
        void (*set_async_callback)(struct fs_file *file,
                                   fs_file_async_callback_t *callback,
                                   void *context);
-       int (*wait_async)(struct fs *fs);
+       void (*wait_async)(struct fs *fs);
 
        void (*set_metadata)(struct fs_file *file, const char *key,
                             const char *value);

diff --git a/src/lib-fs/fs-api.c b/src/lib-fs/fs-api.c
index cebcfdbe370ce93f544f10193abc7214269ddde6..83ba17b3d649f05d9177b14a3d428406db622723 100644 (file)
--- a/src/lib-fs/fs-api.c
+++ b/src/lib-fs/fs-api.c
@@ -570,13 +570,8 @@ struct istream *fs_read_stream(struct fs_file *file, size_t max_buffer_size)
                /* read the whole input stream before returning */
                while ((ret = i_stream_read_more(input, &data, &size)) >= 0) {
                        i_stream_skip(input, size);
-                       if (ret == 0) {
-                               if (fs_wait_async(file->fs) < 0) {
-                                       input->stream_errno = errno;
-                                       input->eof = TRUE;
-                                       break;
-                               }
-                       }
+                       if (ret == 0)
+                               fs_wait_async(file->fs);
                }
                i_stream_seek(input, 0);
        }
@@ -738,22 +733,17 @@ void fs_file_set_async_callback(struct fs_file *file,
                callback(context);
 }
 
-int fs_wait_async(struct fs *fs)
+void fs_wait_async(struct fs *fs)
 {
-       int ret;
-
        /* recursion not allowed */
        i_assert(fs->prev_ioloop == NULL);
 
-       if (fs->v.wait_async == NULL)
-               ret = 0;
-       else T_BEGIN {
+       if (fs->v.wait_async != NULL) T_BEGIN {
                fs->prev_ioloop = current_ioloop;
-               ret = fs->v.wait_async(fs);
+               fs->v.wait_async(fs);
                i_assert(current_ioloop == fs->prev_ioloop);
                fs->prev_ioloop = NULL;
        } T_END;
-       return ret;
 }
 
 int fs_lock(struct fs_file *file, unsigned int secs, struct fs_lock **lock_r)

diff --git a/src/lib-fs/fs-api.h b/src/lib-fs/fs-api.h
index d5702533f876a87f334f93f3b94b06fc65eb6622..c041364fb14cdb1ec6b48ed79a3260abf73e8df9 100644 (file)
--- a/src/lib-fs/fs-api.h
+++ b/src/lib-fs/fs-api.h
@@ -285,9 +285,8 @@ void fs_file_set_async_callback(struct fs_file *file,
                                fs_file_async_callback_t *callback,
                                void *context);
 /* Wait until some file can be read/written to more before returning.
-   It's an error to call this when there are no pending async operations.
-   Returns 0 if ok, -1 if timed out. */
-int fs_wait_async(struct fs *fs);
+   It's an error to call this when there are no pending async operations. */
+void fs_wait_async(struct fs *fs);
 
 /* Returns 1 if file exists, 0 if not, -1 if error occurred. */
 int fs_exists(struct fs_file *file);

diff --git a/src/lib-fs/fs-metawrap.c b/src/lib-fs/fs-metawrap.c
index 29f147879e3604b5c09da9b194540f5aad94ff81..9071e1fa3158d31a249ee5ab95db774655b0d987 100644 (file)
--- a/src/lib-fs/fs-metawrap.c
+++ b/src/lib-fs/fs-metawrap.c
@@ -173,9 +173,9 @@ fs_metawrap_set_async_callback(struct fs_file *_file,
        fs_file_set_async_callback(file->super, callback, context);
 }
 
-static int fs_metawrap_wait_async(struct fs *_fs)
+static void fs_metawrap_wait_async(struct fs *_fs)
 {
-       return fs_wait_async(_fs->parent);
+       fs_wait_async(_fs->parent);
 }
 
 static void
@@ -215,8 +215,7 @@ fs_metawrap_get_metadata(struct fs_file *_file,
                                break;
 
                        i_assert(!file->input->blocking);
-                       if (fs_wait_async(_file->fs) < 0)
-                               return -1;
+                       fs_wait_async(_file->fs);
                }
                if (ret == -1 && file->input->stream_errno != 0) {
                        fs_set_error(_file->fs, "read(%s) failed: %s",

diff --git a/src/lib-fs/fs-randomfail.c b/src/lib-fs/fs-randomfail.c
index 9423b0e205991ef1297fc83b1e2c3fbf001282eb..0182f408f9f78c9da7f59b7a3cfc572f87815288 100644 (file)
--- a/src/lib-fs/fs-randomfail.c
+++ b/src/lib-fs/fs-randomfail.c
@@ -303,11 +303,9 @@ fs_random_fail_range(struct fs *_fs, enum fs_op op, uoff_t *offset_r)
        return TRUE;
 }
 
-static int fs_randomfail_wait_async(struct fs *_fs)
+static void fs_randomfail_wait_async(struct fs *_fs)
 {
-       if (fs_random_fail(_fs, 1, FS_OP_WAIT))
-               return -1;
-       return fs_wait_async(_fs->parent);
+       fs_wait_async(_fs->parent);
 }
 
 static void

diff --git a/src/lib-fs/fs-sis-queue.c b/src/lib-fs/fs-sis-queue.c
index 9b330229d0c7117da940b0f7e838bbcd36ffe68f..152b313dff19cd4ca26eb7eac5d26b39a66db775 100644 (file)
--- a/src/lib-fs/fs-sis-queue.c
+++ b/src/lib-fs/fs-sis-queue.c
@@ -142,11 +142,11 @@ fs_sis_queue_set_async_callback(struct fs_file *_file,
        fs_file_set_async_callback(file->super, callback, context);
 }
 
-static int fs_sis_queue_wait_async(struct fs *_fs)
+static void fs_sis_queue_wait_async(struct fs *_fs)
 {
        struct sis_queue_fs *fs = (struct sis_queue_fs *)_fs;
 
-       return fs_wait_async(fs->super);
+       fs_wait_async(fs->super);
 }
 
 static void

diff --git a/src/lib-fs/fs-sis.c b/src/lib-fs/fs-sis.c
index 1563c29592acaf7b1354354fb1280a15c3f623bc..ca3fea288adfb9d741c922d28e9589d4d35004e1 100644 (file)
--- a/src/lib-fs/fs-sis.c
+++ b/src/lib-fs/fs-sis.c
@@ -179,11 +179,11 @@ fs_sis_set_async_callback(struct fs_file *_file,
        fs_file_set_async_callback(file->super, callback, context);
 }
 
-static int fs_sis_wait_async(struct fs *_fs)
+static void fs_sis_wait_async(struct fs *_fs)
 {
        struct sis_fs *fs = (struct sis_fs *)_fs;
 
-       return fs_wait_async(fs->super);
+       fs_wait_async(fs->super);
 }
 
 static void

diff --git a/src/lib-fs/fs-test.c b/src/lib-fs/fs-test.c
index e0627797df91d9fb855939d42f6bcc2127070293..66d46421b07b474220dd04bde59f4292777cb246 100644 (file)
--- a/src/lib-fs/fs-test.c
+++ b/src/lib-fs/fs-test.c
@@ -88,9 +88,8 @@ fs_test_set_async_callback(struct fs_file *_file,
        file->async_context = context;
 }
 
-static int fs_test_wait_async(struct fs *_fs ATTR_UNUSED)
+static void fs_test_wait_async(struct fs *_fs ATTR_UNUSED)
 {
-       return 0;
 }
 
 static void

diff --git a/src/plugins/fs-compress/fs-compress.c b/src/plugins/fs-compress/fs-compress.c
index 66e61b80387c4a5541988bab600753bf20cdc421..bf71746717365533a2dec8af49c68c84b82c6cb6 100644 (file)
--- a/src/plugins/fs-compress/fs-compress.c
+++ b/src/plugins/fs-compress/fs-compress.c
@@ -177,9 +177,9 @@ fs_compress_set_async_callback(struct fs_file *_file,
        fs_file_set_async_callback(file->super, callback, context);
 }
 
-static int fs_compress_wait_async(struct fs *_fs)
+static void fs_compress_wait_async(struct fs *_fs)
 {
-       return fs_wait_async(_fs->parent);
+       fs_wait_async(_fs->parent);
 }
 
 static void