lib-fs, global: Rename fs_init() to fs_legacy_init()

diff --git a/src/doveadm/doveadm-fs.c b/src/doveadm/doveadm-fs.c
index c5602c6fb388036567bc85c9b39cb0869709e178..a1f2f521f3ece22b0ede50b097ac53efc6d3bba4 100644 (file)
--- a/src/doveadm/doveadm-fs.c
+++ b/src/doveadm/doveadm-fs.c
@@ -35,8 +35,8 @@ cmd_fs_init(struct doveadm_cmd_context *cctx)
        fs_param.temp_dir = doveadm_settings->mail_temp_dir;
        fs_param.base_dir = doveadm_settings->base_dir;
 
-       if (fs_init(fs_driver, fs_args, cctx->event, &fs_param,
-                   &fs, &error) < 0)
+       if (fs_legacy_init(fs_driver, fs_args, cctx->event, &fs_param,
+                          &fs, &error) < 0)
                i_fatal("fs_init() failed: %s", error);
        return fs;
 }

diff --git a/src/lib-dict-extra/dict-fs.c b/src/lib-dict-extra/dict-fs.c
index 9018ea54d1f5914fcfb2d6eba96962e5ebc6158d..ae24aeb8d74531068dae82bda5ce740f53bc13c9 100644 (file)
--- a/src/lib-dict-extra/dict-fs.c
+++ b/src/lib-dict-extra/dict-fs.c
@@ -45,8 +45,8 @@ fs_dict_init_legacy(struct dict *driver, const char *uri,
 
        i_zero(&fs_param);
        fs_param.base_dir = set->base_dir;
-       if (fs_init(fs_driver, fs_args, set->event_parent, &fs_param,
-                   &fs, error_r) < 0)
+       if (fs_legacy_init(fs_driver, fs_args, set->event_parent, &fs_param,
+                          &fs, error_r) < 0)
                return -1;
 
        dict = i_new(struct fs_dict, 1);

diff --git a/src/lib-fs/fs-api-private.h b/src/lib-fs/fs-api-private.h
index 19343f61a53ddef437a066e1d639a767860072fd..c1d1b21cd36a2b84b2f77d20d22e2bf232d693bd 100644 (file)
--- a/src/lib-fs/fs-api-private.h
+++ b/src/lib-fs/fs-api-private.h
@@ -27,9 +27,9 @@ extern struct fs_api_module_register fs_api_module_register;
 
 struct fs_vfuncs {
        struct fs *(*alloc)(void);
-       int (*init)(struct fs *fs, const char *args,
-                   const struct fs_parameters *params,
-                   const char **error_r);
+       int (*legacy_init)(struct fs *fs, const char *args,
+                          const struct fs_parameters *params,
+                          const char **error_r);
        void (*deinit)(struct fs *fs);
        void (*free)(struct fs *fs);
 

diff --git a/src/lib-fs/fs-api.c b/src/lib-fs/fs-api.c
index 1679518fffbb2e07299037a977361e42120b2570..940443de65ffb08d48dcd945491a502067a57b2e 100644 (file)
--- a/src/lib-fs/fs-api.c
+++ b/src/lib-fs/fs-api.c
@@ -152,9 +152,10 @@ fs_alloc(const char *driver, struct event *event_parent,
        return 0;
 }
 
-int fs_init(const char *driver, const char *args,
-           struct event *event_parent, const struct fs_parameters *params,
-           struct fs **fs_r, const char **error_r)
+int fs_legacy_init(const char *driver, const char *args,
+                  struct event *event_parent,
+                  const struct fs_parameters *params,
+                  struct fs **fs_r, const char **error_r)
 {
        struct fs *fs;
        const char *error;
@@ -164,7 +165,7 @@ int fs_init(const char *driver, const char *args,
                return -1;
 
        T_BEGIN {
-               ret = fs->v.init(fs, args, params, &error);
+               ret = fs->v.legacy_init(fs, args, params, &error);
        } T_END_PASS_STR_IF(ret < 0, &error);
        if (ret < 0) {
                *error_r = t_strdup_printf("%s: %s", fs->name, error);

diff --git a/src/lib-fs/fs-api.h b/src/lib-fs/fs-api.h
index 842a2bf96de9f7f64a0d0ef913447402e3e29064..cff250141ea885c5a3bd6a12a4a3bc1c227c4a1b 100644 (file)
--- a/src/lib-fs/fs-api.h
+++ b/src/lib-fs/fs-api.h
@@ -199,9 +199,10 @@ ARRAY_DEFINE_TYPE(fs_metadata, struct fs_metadata);
 typedef void fs_file_async_callback_t(void *context);
 
 /* event_parent can be overridden by fs_file_init_with_event() */
-int fs_init(const char *driver, const char *args,
-           struct event *event_parent, const struct fs_parameters *params,
-           struct fs **fs_r, const char **error_r);
+int fs_legacy_init(const char *driver, const char *args,
+                  struct event *event_parent,
+                  const struct fs_parameters *params,
+                  struct fs **fs_r, const char **error_r);
 /* same as fs_unref() */
 void fs_deinit(struct fs **fs);
 

diff --git a/src/lib-fs/fs-dict.c b/src/lib-fs/fs-dict.c
index 612672cd95acb24ef6bed6b7c5f4c841aa6d2032..35a1a1b71ff7ec2581d496ad6ba3c6c6ea18abdd 100644 (file)
--- a/src/lib-fs/fs-dict.c
+++ b/src/lib-fs/fs-dict.c
@@ -337,7 +337,7 @@ const struct fs fs_class_dict = {
        .name = "dict",
        .v = {
                .alloc = fs_dict_alloc,
-               .init = fs_dict_init,
+               .legacy_init = fs_dict_init,
                .deinit = NULL,
                .free = fs_dict_free,
                .get_properties = fs_dict_get_properties,

diff --git a/src/lib-fs/fs-metawrap.c b/src/lib-fs/fs-metawrap.c
index 8b2e28e013b4a2dd5bca806c67c6c47b88bb3221..ff0afd91befca6a4a433b68a08a5a277af361c6f 100644 (file)
--- a/src/lib-fs/fs-metawrap.c
+++ b/src/lib-fs/fs-metawrap.c
@@ -65,8 +65,8 @@ fs_metawrap_init(struct fs *_fs, const char *args,
                parent_name = t_strdup_until(args, parent_args);
                parent_args++;
        }
-       if (fs_init(parent_name, parent_args, _fs->event, params,
-                   &_fs->parent, error_r) < 0)
+       if (fs_legacy_init(parent_name, parent_args, _fs->event, params,
+                          &_fs->parent, error_r) < 0)
                return -1;
        if ((fs_get_properties(_fs->parent) & FS_PROPERTY_METADATA) == 0)
                fs->wrap_metadata = TRUE;
@@ -499,7 +499,7 @@ const struct fs fs_class_metawrap = {
        .name = "metawrap",
        .v = {
                .alloc = fs_metawrap_alloc,
-               .init = fs_metawrap_init,
+               .legacy_init = fs_metawrap_init,
                .deinit = NULL,
                .free = fs_metawrap_free,
                .get_properties = fs_metawrap_get_properties,

diff --git a/src/lib-fs/fs-posix.c b/src/lib-fs/fs-posix.c
index 93b0954ce3aec3f353b2c3424ae2ac53ccb598b0..6d75569b077c648a3d570d9f9bc5349ece7518bf 100644 (file)
--- a/src/lib-fs/fs-posix.c
+++ b/src/lib-fs/fs-posix.c
@@ -992,7 +992,7 @@ const struct fs fs_class_posix = {
        .name = "posix",
        .v = {
                .alloc = fs_posix_alloc,
-               .init = fs_posix_init,
+               .legacy_init = fs_posix_init,
                .deinit = NULL,
                .free = fs_posix_free,
                .get_properties = fs_posix_get_properties,

diff --git a/src/lib-fs/fs-randomfail.c b/src/lib-fs/fs-randomfail.c
index 9c7d609ccf5e6bc9b74613a5010d5b7a84a146d6..07b31b9fa1387c53bed0a0a622d1da125fb7a887 100644 (file)
--- a/src/lib-fs/fs-randomfail.c
+++ b/src/lib-fs/fs-randomfail.c
@@ -194,8 +194,8 @@ fs_randomfail_init(struct fs *_fs, const char *args,
                parent_name = t_strdup_until(args, parent_args);
                parent_args++;
        }
-       if (fs_init(parent_name, parent_args, _fs->event, params,
-                   &_fs->parent, error_r) < 0)
+       if (fs_legacy_init(parent_name, parent_args, _fs->event, params,
+                          &_fs->parent, error_r) < 0)
                return -1;
        return 0;
 }
@@ -522,7 +522,7 @@ const struct fs fs_class_randomfail = {
        .name = "randomfail",
        .v = {
                .alloc = fs_randomfail_alloc,
-               .init = fs_randomfail_init,
+               .legacy_init = fs_randomfail_init,
                .deinit = NULL,
                .free = fs_randomfail_free,
                .get_properties = fs_randomfail_get_properties,

diff --git a/src/lib-fs/fs-sis-queue.c b/src/lib-fs/fs-sis-queue.c
index d483ad138c1cc839ca8b6b59051d8831259210db..c763c76a50a4a0b260afb208277196c4b383ac81 100644 (file)
--- a/src/lib-fs/fs-sis-queue.c
+++ b/src/lib-fs/fs-sis-queue.c
@@ -51,8 +51,8 @@ fs_sis_queue_init(struct fs *_fs, const char *args,
                parent_args = "";
        else
                parent_name = t_strdup_until(parent_name, parent_args++);
-       if (fs_init(parent_name, parent_args, _fs->event, params,
-                   &_fs->parent, error_r) < 0)
+       if (fs_legacy_init(parent_name, parent_args, _fs->event, params,
+                          &_fs->parent, error_r) < 0)
                return -1;
        return 0;
 }
@@ -173,7 +173,7 @@ const struct fs fs_class_sis_queue = {
        .name = "sis-queue",
        .v = {
                .alloc = fs_sis_queue_alloc,
-               .init = fs_sis_queue_init,
+               .legacy_init = fs_sis_queue_init,
                .deinit = NULL,
                .free = fs_sis_queue_free,
                .get_properties = fs_wrapper_get_properties,

diff --git a/src/lib-fs/fs-sis.c b/src/lib-fs/fs-sis.c
index 8af9556a3df8b731d6ea5c2c951be7d1a4269bfb..3b723654e44bce45d15e0f9a82971c5263941f22 100644 (file)
--- a/src/lib-fs/fs-sis.c
+++ b/src/lib-fs/fs-sis.c
@@ -60,8 +60,8 @@ fs_sis_init(struct fs *_fs, const char *args,
                parent_name = t_strdup_until(args, parent_args);
                parent_args++;
        }
-       if (fs_init(parent_name, parent_args, _fs->event, params,
-                   &_fs->parent, error_r) < 0)
+       if (fs_legacy_init(parent_name, parent_args, _fs->event, params,
+                          &_fs->parent, error_r) < 0)
                return -1;
        props = fs_get_properties(_fs->parent);
        if ((props & FS_SIS_REQUIRED_PROPS) != FS_SIS_REQUIRED_PROPS) {
@@ -255,7 +255,7 @@ const struct fs fs_class_sis = {
        .name = "sis",
        .v = {
                .alloc = fs_sis_alloc,
-               .init = fs_sis_init,
+               .legacy_init = fs_sis_init,
                .deinit = NULL,
                .free = fs_sis_free,
                .get_properties = fs_wrapper_get_properties,

diff --git a/src/lib-fs/fs-test-async.c b/src/lib-fs/fs-test-async.c
index 916a17b6e591af1c4485433eaa7ad080aeeb7539..b579bebdbcc1bd13781ac96658d2456da04d8395 100644 (file)
--- a/src/lib-fs/fs-test-async.c
+++ b/src/lib-fs/fs-test-async.c
@@ -90,7 +90,7 @@ void test_fs_async(const char *test_name, enum fs_properties properties,
        const char *error;
 
        i_zero(&fs_params);
-       if (fs_init(driver, args, NULL, &fs_params, &fs, &error) < 0)
+       if (fs_legacy_init(driver, args, NULL, &fs_params, &fs, &error) < 0)
                i_fatal("fs_init() failed: %s", error);
 
        test_fs = test_fs_get(fs);

diff --git a/src/lib-fs/fs-test.c b/src/lib-fs/fs-test.c
index 262497b1c4c3e7fcc68eafc9ef238275f65d13cc..0e40c72e3cb9229a3f0fc781d33d5f082ac4ff22 100644 (file)
--- a/src/lib-fs/fs-test.c
+++ b/src/lib-fs/fs-test.c
@@ -407,7 +407,7 @@ const struct fs fs_class_test = {
        .name = "test",
        .v = {
                .alloc = fs_test_alloc,
-               .init = fs_test_init,
+               .legacy_init = fs_test_init,
                .deinit = NULL,
                .free = fs_test_free,
                .get_properties = fs_test_get_properties,

diff --git a/src/lib-fs/test-fs-metawrap.c b/src/lib-fs/test-fs-metawrap.c
index 0940e62bd941a6c9278df4a288a92a26ffdb6aea..ed64667fcaa64ece9b1780ededc921316608e161 100644 (file)
--- a/src/lib-fs/test-fs-metawrap.c
+++ b/src/lib-fs/test-fs-metawrap.c
@@ -21,7 +21,7 @@ static void test_fs_metawrap_stat(void)
 
        test_begin("fs metawrap stat");
 
-       if (fs_init("metawrap", "test", NULL, &fs_params, &fs, &error) < 0)
+       if (fs_legacy_init("metawrap", "test", NULL, &fs_params, &fs, &error) < 0)
                i_fatal("fs_init() failed: %s", error);
 
        for (i = 0; i < 2; i++) {
@@ -60,7 +60,7 @@ static void test_fs_metawrap_write_empty(void)
        const char *error;
 
        test_begin("fs metawrap write empty file");
-       if (fs_init("metawrap", "test", NULL, &fs_params, &fs, &error) < 0)
+       if (fs_legacy_init("metawrap", "test", NULL, &fs_params, &fs, &error) < 0)
                i_fatal("fs_init() failed: %s", error);
        struct fs_file *file = fs_file_init(fs, "foo", FS_OPEN_MODE_REPLACE);
        struct ostream *output = fs_write_stream(file);
@@ -77,7 +77,7 @@ static void test_fs_metawrap_write_fname_rename(void)
        const char *error;
 
        test_begin("fs metawrap write fname rename");
-       if (fs_init("metawrap", "test", NULL, &fs_params, &fs, &error) < 0)
+       if (fs_legacy_init("metawrap", "test", NULL, &fs_params, &fs, &error) < 0)
                i_fatal("fs_init() failed: %s", error);
        struct fs_file *file = fs_file_init(fs, "foo", FS_OPEN_MODE_REPLACE);
        struct ostream *output = fs_write_stream(file);

diff --git a/src/lib-fs/test-fs-posix.c b/src/lib-fs/test-fs-posix.c
index 4bf781e86bd59dba015d3d86f0b9268a8694b126..6b0fe237f8e407ed1f53e90ed082945a439ff1b8 100644 (file)
--- a/src/lib-fs/test-fs-posix.c
+++ b/src/lib-fs/test-fs-posix.c
@@ -32,8 +32,8 @@ static void test_fs_posix(void)
 
        test_begin("test-fs-posix filesystem");
        i_zero(&fs_params);
-       ret = fs_init("posix", t_strdup_printf("prefix=%s/", testdir), NULL,
-                     &fs_params, &fs, &error);
+       ret = fs_legacy_init("posix", t_strdup_printf("prefix=%s/", testdir), NULL,
+                            &fs_params, &fs, &error);
        test_out_quiet("fs_init() failed", ret >= 0);
        if (ret < 0) {
                test_end();

diff --git a/src/lib-storage/mail-storage.c b/src/lib-storage/mail-storage.c
index 66759000b95b843055c570759cf2a76cd0ad356a..65162c155fca52eb0acf4d3cde72754afe91418f 100644 (file)
--- a/src/lib-storage/mail-storage.c
+++ b/src/lib-storage/mail-storage.c
@@ -457,8 +457,9 @@ mail_storage_create_full_real(struct mail_namespace *ns, const char *driver,
                i_zero(&fs_params);
 
                mail_user_init_fs_parameters(storage->user, &fs_params);
-               if (fs_init("posix", "", storage->user->event, &fs_params,
-                           &storage->mailboxes_fs, &error) < 0) {
+               if (fs_legacy_init("posix", "", storage->user->event,
+                                  &fs_params, &storage->mailboxes_fs,
+                                  &error) < 0) {
                        *error_r = t_strdup_printf("fs_init(posix) failed: %s", error);
                        storage->v.destroy(storage);
                        return -1;

diff --git a/src/lib-storage/mailbox-list.c b/src/lib-storage/mailbox-list.c
index a59e18e2a665d8c96da5d53c300c8a6000432be6..bac12574af0ccb04aa9b36ffb9762906925ca9bb 100644 (file)
--- a/src/lib-storage/mailbox-list.c
+++ b/src/lib-storage/mailbox-list.c
@@ -2095,7 +2095,8 @@ int mailbox_list_init_fs(struct mailbox_list *list, struct event *event_parent,
 
        if (event_parent == NULL)
                event_parent = list->ns->user->event;
-       if (fs_init(driver, args, event_parent, &fs_params, fs_r, error_r) < 0)
+       if (fs_legacy_init(driver, args, event_parent, &fs_params,
+                          fs_r, error_r) < 0)
                return -1;
 
        /* add mailbox_list context to the parent fs, which allows

diff --git a/src/plugins/fs-compress/fs-compress.c b/src/plugins/fs-compress/fs-compress.c
index 228b3736148a6cdf3c8b0c3d4e60618064431140..c4d6aff75c6a566399d15425469ba473e0d30594 100644 (file)
--- a/src/plugins/fs-compress/fs-compress.c
+++ b/src/plugins/fs-compress/fs-compress.c
@@ -100,8 +100,8 @@ fs_compress_init(struct fs *_fs, const char *args,
                parent_name = t_strdup_until(args, parent_args);
                parent_args++;
        }
-       return fs_init(parent_name, parent_args, _fs->event, params,
-                      &_fs->parent, error_r);
+       return fs_legacy_init(parent_name, parent_args, _fs->event, params,
+                             &_fs->parent, error_r);
 }
 
 static void fs_compress_free(struct fs *_fs)
@@ -267,7 +267,7 @@ const struct fs fs_class_compress = {
        .name = "compress",
        .v = {
                .alloc = fs_compress_alloc,
-               .init = fs_compress_init,
+               .legacy_init = fs_compress_init,
                .deinit = NULL,
                .free = fs_compress_free,
                .get_properties = fs_wrapper_get_properties,

diff --git a/src/plugins/mail-crypt/fs-crypt-common.c b/src/plugins/mail-crypt/fs-crypt-common.c
index 2001fa901d2098412c175c8181619c141969a213..a9a24e17f5e35b562cd0fc546044455d5e1bf399 100644 (file)
--- a/src/plugins/mail-crypt/fs-crypt-common.c
+++ b/src/plugins/mail-crypt/fs-crypt-common.c
@@ -116,8 +116,8 @@ fs_crypt_init(struct fs *_fs, const char *args,
                parent_name = t_strdup_until(args, parent_args);
                parent_args++;
        }
-       if (fs_init(parent_name, parent_args, _fs->event, params,
-                   &_fs->parent, error_r) < 0)
+       if (fs_legacy_init(parent_name, parent_args, _fs->event, params,
+                          &_fs->parent, error_r) < 0)
                return -1;
        fs->enc_algo = i_strdup(enc_algo);
        fs->set_prefix = i_strdup(set_prefix);

diff --git a/src/plugins/mail-crypt/fs-crypt.c b/src/plugins/mail-crypt/fs-crypt.c
index be29f0988473aec743c0c0c321f4a67443c7e1bd..ccc673e04d2a9668bc32d579f18d7d95f4865934 100644 (file)
--- a/src/plugins/mail-crypt/fs-crypt.c
+++ b/src/plugins/mail-crypt/fs-crypt.c
@@ -29,7 +29,7 @@ const struct fs fs_class_crypt = {
        .name = "crypt",
        .v = {
                .alloc = fs_crypt_alloc,
-               .init = fs_crypt_init,
+               .legacy_init = fs_crypt_init,
                .deinit = NULL,
                .free = fs_crypt_free,
                .get_properties = fs_wrapper_get_properties,

diff --git a/src/plugins/mail-crypt/fs-mail-crypt.c b/src/plugins/mail-crypt/fs-mail-crypt.c
index 94c0520b02b22ae2b95b6764fffb29fcbe9d796b..5669f254dfba2b9ad907808f7381dc981b01d39e 100644 (file)
--- a/src/plugins/mail-crypt/fs-mail-crypt.c
+++ b/src/plugins/mail-crypt/fs-mail-crypt.c
@@ -39,7 +39,7 @@ const struct fs fs_class_mail_crypt = {
        .name = "mail-crypt",
        .v = {
                .alloc = fs_crypt_alloc,
-               .init = fs_crypt_init,
+               .legacy_init = fs_crypt_init,
                .deinit = NULL,
                .free = fs_crypt_free,
                .get_properties = fs_wrapper_get_properties,

diff --git a/src/plugins/mail-crypt/test-fs-crypt.c b/src/plugins/mail-crypt/test-fs-crypt.c
index bec5c7dcc81d6b118d98c9236f968f0a8d1e40f3..c5be722507dabfefa98f91e73a4d505a30603d06 100644 (file)
--- a/src/plugins/mail-crypt/test-fs-crypt.c
+++ b/src/plugins/mail-crypt/test-fs-crypt.c
@@ -43,7 +43,7 @@ static void test_setup(void)
        fs_class_register(&fs_class_posix);
        fs_class_register(&fs_class_crypt);
 
-       if (fs_init("posix", "", NULL, &test_fs_params, &fs, &error) < 0)
+       if (fs_legacy_init("posix", "", NULL, &test_fs_params, &fs, &error) < 0)
                 i_fatal("fs_init(posix) failed: %s", error);
        /* write keys to disk */
        file = fs_file_init(fs, "test_public_key.pem", FS_OPEN_MODE_CREATE);
@@ -67,9 +67,9 @@ static void test_fs_crypt_read_write(void)
        const char *error;
        struct fs *fs;
 
-       if (fs_init("crypt", "public_key_path=test_public_key.pem:"
-                   "private_key_path=test_private_key.pem:posix",
-                   NULL, &test_fs_params, &fs, &error) < 0)
+       if (fs_legacy_init("crypt", "public_key_path=test_public_key.pem:"
+                          "private_key_path=test_private_key.pem:posix",
+                          NULL, &test_fs_params, &fs, &error) < 0)
                i_fatal("fs_init(crypt:posix) failed: %s", error);
 
        i_unlink_if_exists("test_file");
@@ -116,9 +116,9 @@ static void test_fs_crypt_read_write_0(void)
        const char *error;
        struct fs *fs;
 
-       if (fs_init("crypt", "public_key_path=test_public_key.pem:"
-                   "private_key_path=test_private_key.pem:posix",
-                   NULL, &test_fs_params, &fs, &error) < 0)
+       if (fs_legacy_init("crypt", "public_key_path=test_public_key.pem:"
+                          "private_key_path=test_private_key.pem:posix",
+                          NULL, &test_fs_params, &fs, &error) < 0)
                i_fatal("fs_init(crypt:posix) failed: %s", error);
 
        i_unlink_if_exists("test_file");
@@ -157,10 +157,10 @@ static void test_fs_crypt_read_write_unencrypted(void)
        const char *error;
        struct fs *fs;
 
-       if (fs_init("crypt", "public_key_path=:"
-                   "private_key_path=test_private_key.pem:"
-                   "maybe:posix",
-                   NULL, &test_fs_params, &fs, &error) < 0)
+       if (fs_legacy_init("crypt", "public_key_path=:"
+                          "private_key_path=test_private_key.pem:"
+                          "maybe:posix",
+                          NULL, &test_fs_params, &fs, &error) < 0)
                i_fatal("fs_init(crypt:posix) failed: %s", error);
 
        i_unlink_if_exists("test_file");
@@ -199,10 +199,10 @@ static void test_fs_crypt_read_write_unencrypted(void)
        fs_file_deinit(&file);
        fs_deinit(&fs);
 
-       if (fs_init("crypt", "public_key_path=test_public_key.pem:"
-                   "private_key_path=test_private_key.pem:"
-                   "maybe:posix",
-                   NULL, &test_fs_params, &fs, &error) < 0)
+       if (fs_legacy_init("crypt", "public_key_path=test_public_key.pem:"
+                          "private_key_path=test_private_key.pem:"
+                          "maybe:posix",
+                          NULL, &test_fs_params, &fs, &error) < 0)
                i_fatal("fs_init(crypt:posix) failed: %s", error);
 
        i_unlink_if_exists("test_file");

diff --git a/src/util/test-fs.c b/src/util/test-fs.c
index 6aa275a837fa50c818b9dbe451c9f78ebbe53e25..b965ec945fdf0fcee1bab1bdf0ec0e235d36e1cc 100644 (file)
--- a/src/util/test-fs.c
+++ b/src/util/test-fs.c
@@ -421,8 +421,8 @@ int main(int argc, char *argv[])
        master_service_init_finish(master_service);
        dict_drivers_register_builtin();
 
-       if (fs_init(argv[0], argv[1], master_service_get_event(master_service),
-                   &params, &ctx.fs, &error) < 0)
+       if (fs_legacy_init(argv[0], argv[1], master_service_get_event(master_service),
+                          &params, &ctx.fs, &error) < 0)
                i_fatal("fs_init() failed: %s", error);
        ctx.prefix = argv[2];