lib-master: Rename config_mmap variables to mmap

master_service.config_mmap is kept for now.

diff --git a/src/lib-master/master-service-settings.c b/src/lib-master/master-service-settings.c
index f2a72d2a1b4a821cfaa5c8fa7a6e7cc44aa1ed5b..7f77eb85adb2e6caa7507762125db18939c4fb75 100644 (file)
--- a/src/lib-master/master-service-settings.c
+++ b/src/lib-master/master-service-settings.c
@@ -454,7 +454,7 @@ filter_string_parse_protocol(const char *filter_string,
 }
 
 static int
-settings_block_read_size(struct master_settings_mmap *config_mmap,
+settings_block_read_size(struct master_settings_mmap *mmap,
                         size_t *offset, size_t end_offset,
                         const char *name, uint64_t *size_r,
                         const char **error_r)
@@ -463,16 +463,16 @@ settings_block_read_size(struct master_settings_mmap *config_mmap,
                *error_r = t_strdup_printf(
                        "Area too small when reading size of '%s' "
                        "(offset=%zu, end_offset=%zu, file_size=%zu)", name,
-                       *offset, end_offset, config_mmap->mmap_size);
+                       *offset, end_offset, mmap->mmap_size);
                return -1;
        }
-       *size_r = be64_to_cpu_unaligned(CONST_PTR_OFFSET(config_mmap->mmap_base, *offset));
+       *size_r = be64_to_cpu_unaligned(CONST_PTR_OFFSET(mmap->mmap_base, *offset));
        if (*size_r > end_offset - *offset - sizeof(*size_r)) {
                *error_r = t_strdup_printf(
                        "'%s' points outside area "
                        "(offset=%zu, size=%"PRIu64", end_offset=%zu, file_size=%zu)",
                        name, *offset, *size_r, end_offset,
-                       config_mmap->mmap_size);
+                       mmap->mmap_size);
                return -1;
        }
        *offset += sizeof(*size_r);
@@ -480,23 +480,23 @@ settings_block_read_size(struct master_settings_mmap *config_mmap,
 }
 
 static int
-settings_block_read_str(struct master_settings_mmap *config_mmap,
+settings_block_read_str(struct master_settings_mmap *mmap,
                        uoff_t *offset, uoff_t end_offset, const char *name,
                        const char **str_r, const char **error_r)
 {
-       *str_r = (const char *)config_mmap->mmap_base + *offset;
+       *str_r = (const char *)mmap->mmap_base + *offset;
        *offset += strlen(*str_r) + 1;
        if (*offset > end_offset) {
                *error_r = t_strdup_printf("'%s' points outside area "
                        "(offset=%zu, end_offset=%zu, file_size=%zu)",
-                       name, *offset, end_offset, config_mmap->mmap_size);
+                       name, *offset, end_offset, mmap->mmap_size);
                return -1;
        }
        return 0;
 }
 
 static int
-settings_block_read(struct master_settings_mmap *config_mmap, uoff_t *_offset,
+settings_block_read(struct master_settings_mmap *mmap, uoff_t *_offset,
                    ARRAY_TYPE(const_string) *protocols, const char **error_r)
 {
        uoff_t offset = *_offset;
@@ -505,8 +505,7 @@ settings_block_read(struct master_settings_mmap *config_mmap, uoff_t *_offset,
 
        /* <block size> */
        uint64_t block_size;
-       if (settings_block_read_size(config_mmap, &offset,
-                                    config_mmap->mmap_size,
+       if (settings_block_read_size(mmap, &offset, mmap->mmap_size,
                                     "block size", &block_size, error_r) < 0)
                return -1;
        size_t block_end_offset = offset + block_size;
@@ -515,7 +514,7 @@ settings_block_read(struct master_settings_mmap *config_mmap, uoff_t *_offset,
           later on and we know it won't read past the mmaped memory area and
           cause a crash. The NUL is either from the last settings value or
           from the last error string. */
-       if (((const char *)config_mmap->mmap_base)[block_end_offset-1] != '\0') {
+       if (((const char *)mmap->mmap_base)[block_end_offset-1] != '\0') {
                *error_r = t_strdup_printf(
                        "Settings block doesn't end with NUL at offset %zu",
                        block_end_offset-1);
@@ -524,12 +523,12 @@ settings_block_read(struct master_settings_mmap *config_mmap, uoff_t *_offset,
 
        /* <block name> */
        const char *block_name;
-       if (settings_block_read_str(config_mmap, &offset, block_end_offset,
+       if (settings_block_read_str(mmap, &offset, block_end_offset,
                                    "block name", &block_name, error_r) < 0)
                return -1;
 
        struct master_service_mmap_block *block =
-               hash_table_lookup(config_mmap->blocks, block_name);
+               hash_table_lookup(mmap->blocks, block_name);
        if (block != NULL) {
                *error_r = t_strdup_printf(
                        "Duplicate block name '%s' (offset=%zu)",
@@ -538,18 +537,18 @@ settings_block_read(struct master_settings_mmap *config_mmap, uoff_t *_offset,
        }
        block = i_new(struct master_service_mmap_block, 1);
        block->name = block_name;
-       hash_table_insert(config_mmap->blocks, block->name, block);
+       hash_table_insert(mmap->blocks, block->name, block);
 
        /* <base settings size> */
        uint64_t base_settings_size;
-       if (settings_block_read_size(config_mmap, &offset, block_end_offset,
+       if (settings_block_read_size(mmap, &offset, block_end_offset,
                                     "base settings size", &base_settings_size,
                                     error_r) < 0)
                return -1;
        block->base_end_offset = offset + base_settings_size;
 
        /* <base settings error string> */
-       if (settings_block_read_str(config_mmap, &offset,
+       if (settings_block_read_str(mmap, &offset,
                                    block->base_end_offset,
                                    "base settings error", &error,
                                    error_r) < 0)
@@ -565,7 +564,7 @@ settings_block_read(struct master_settings_mmap *config_mmap, uoff_t *_offset,
        while (offset < block_end_offset) {
                /* <filter settings size> */
                uint64_t filter_settings_size;
-               if (settings_block_read_size(config_mmap, &offset,
+               if (settings_block_read_size(mmap, &offset,
                                block_end_offset, "filter settings size",
                                &filter_settings_size, error_r) < 0)
                        return -1;
@@ -573,14 +572,14 @@ settings_block_read(struct master_settings_mmap *config_mmap, uoff_t *_offset,
 
                /* <filter string> */
                const char *filter_string;
-               if (settings_block_read_str(config_mmap, &offset,
+               if (settings_block_read_str(mmap, &offset,
                                            filter_end_offset, "filter string",
                                            &filter_string, error_r) < 0)
                        return -1;
 
                /* <filter settings error string> */
                const char *filter_error;
-               if (settings_block_read_str(config_mmap, &offset,
+               if (settings_block_read_str(mmap, &offset,
                                            filter_end_offset,
                                            "filter settings error",
                                            &filter_error, error_r) < 0)
@@ -615,14 +614,14 @@ settings_block_read(struct master_settings_mmap *config_mmap, uoff_t *_offset,
        return 0;
 }
 
-static void config_mmap_free_blocks(struct master_settings_mmap *config_mmap)
+static void config_mmap_free_blocks(struct master_settings_mmap *mmap)
 {
        struct hash_iterate_context *iter =
-               hash_table_iterate_init(config_mmap->blocks);
+               hash_table_iterate_init(mmap->blocks);
        const char *name;
        struct master_service_mmap_block *block;
 
-       while (hash_table_iterate(iter, config_mmap->blocks, &name, &block)) {
+       while (hash_table_iterate(iter, mmap->blocks, &name, &block)) {
                if (array_is_created(&block->filters)) {
                        struct master_service_mmap_filter *config_filter;
                        array_foreach_modifiable(&block->filters, config_filter)
@@ -632,11 +631,11 @@ static void config_mmap_free_blocks(struct master_settings_mmap *config_mmap)
                i_free(block);
        }
        hash_table_iterate_deinit(&iter);
-       hash_table_clear(config_mmap->blocks, FALSE);
+       hash_table_clear(mmap->blocks, FALSE);
 }
 
 static int
-master_service_settings_mmap_parse(struct master_settings_mmap *config_mmap,
+master_service_settings_mmap_parse(struct master_settings_mmap *mmap,
                                   struct master_service_settings_output *output_r,
                                   const char **error_r)
 {
@@ -646,8 +645,8 @@ master_service_settings_mmap_parse(struct master_settings_mmap *config_mmap,
 
           Settings are read until the blob size is reached. There is no
           padding/alignment. */
-       const unsigned char *mmap_base = config_mmap->mmap_base;
-       size_t mmap_size = config_mmap->mmap_size;
+       const unsigned char *mmap_base = mmap->mmap_base;
+       size_t mmap_size = mmap->mmap_size;
        ARRAY_TYPE(const_string) protocols;
 
        t_array_init(&protocols, 8);
@@ -670,7 +669,7 @@ master_service_settings_mmap_parse(struct master_settings_mmap *config_mmap,
        }
 
        /* <settings full size> */
-       config_mmap_free_blocks(config_mmap);
+       config_mmap_free_blocks(mmap);
 
        size_t full_size_offset = eol - mmap_base + 1;
        uint64_t settings_full_size =
@@ -686,7 +685,7 @@ master_service_settings_mmap_parse(struct master_settings_mmap *config_mmap,
 
        uoff_t offset = full_size_offset + sizeof(settings_full_size);
        do {
-               if (settings_block_read(config_mmap, &offset,
+               if (settings_block_read(mmap, &offset,
                                        &protocols, error_r) < 0)
                        return -1;
        } while (offset < mmap_size);
@@ -699,7 +698,7 @@ master_service_settings_mmap_parse(struct master_settings_mmap *config_mmap,
 }
 
 static int
-master_service_settings_mmap_apply_blob(struct master_settings_mmap *config_mmap,
+master_service_settings_mmap_apply_blob(struct master_settings_mmap *mmap,
                                        struct setting_parser_context *parser,
                                        size_t start_offset, size_t end_offset,
                                        const char **error_r)
@@ -710,23 +709,23 @@ master_service_settings_mmap_apply_blob(struct master_settings_mmap *config_mmap
        while (offset < end_offset) {
                /* We already checked that settings blob ends with NUL, so
                   strlen() can be used safely. */
-               const char *key = (const char *)config_mmap->mmap_base + offset;
+               const char *key = (const char *)mmap->mmap_base + offset;
                offset += strlen(key)+1;
                if (offset >= end_offset) {
                        /* if offset==end_offset, the value is missing. */
                        *error_r = t_strdup_printf(
                                "Settings key/value points outside blob "
                                "(offset=%zu, end_offset=%zu, file_size=%zu)",
-                               offset, end_offset, config_mmap->mmap_size);
+                               offset, end_offset, mmap->mmap_size);
                        return -1;
                }
-               const char *value = (const char *)config_mmap->mmap_base + offset;
+               const char *value = (const char *)mmap->mmap_base + offset;
                offset += strlen(value)+1;
                if (offset > end_offset) {
                        *error_r = t_strdup_printf(
                                "Settings value points outside blob "
                                "(offset=%zu, end_offset=%zu, file_size=%zu)",
-                               offset, end_offset, config_mmap->mmap_size);
+                               offset, end_offset, mmap->mmap_size);
                        return -1;
                }
                int ret;
@@ -745,14 +744,14 @@ master_service_settings_mmap_apply_blob(struct master_settings_mmap *config_mmap
 }
 
 static int
-master_service_settings_mmap_apply(struct master_settings_mmap *config_mmap,
+master_service_settings_mmap_apply(struct master_settings_mmap *mmap,
                                   struct event *event,
                                   struct setting_parser_context *parser,
                                   const struct setting_parser_info *info,
                                   const char **error_r)
 {
        struct master_service_mmap_block *block =
-               hash_table_lookup(config_mmap->blocks, info->name);
+               hash_table_lookup(mmap->blocks, info->name);
        if (block == NULL) {
                *error_r = t_strdup_printf(
                        "BUG: Configuration has no settings struct named '%s'",
@@ -764,7 +763,7 @@ master_service_settings_mmap_apply(struct master_settings_mmap *config_mmap,
                return -1;
        }
 
-       if (master_service_settings_mmap_apply_blob(config_mmap, parser,
+       if (master_service_settings_mmap_apply_blob(mmap, parser,
                                                    block->base_start_offset,
                                                    block->base_end_offset,
                                                    error_r) < 0)
@@ -787,7 +786,7 @@ master_service_settings_mmap_apply(struct master_settings_mmap *config_mmap,
                                return -1;
                        }
                        if (master_service_settings_mmap_apply_blob(
-                                       config_mmap, parser,
+                                       mmap, parser,
                                        config_filter->start_offset,
                                        config_filter->end_offset,
                                        error_r) < 0)
@@ -863,20 +862,19 @@ int master_service_settings_read(struct master_service *service,
                }
        }
        if (fd != -1) {
-               struct master_settings_mmap *config_mmap;
+               struct master_settings_mmap *mmap;
                master_settings_mmap_unref(&service->config_mmap);
-               config_mmap = i_new(struct master_settings_mmap, 1);
-               config_mmap->refcount = 1;
-               config_mmap->service = service;
-               config_mmap->mmap_base =
-                       mmap_ro_file(fd, &config_mmap->mmap_size);
-               if (config_mmap->mmap_base == MAP_FAILED)
+               mmap = i_new(struct master_settings_mmap, 1);
+               mmap->refcount = 1;
+               mmap->service = service;
+               mmap->mmap_base = mmap_ro_file(fd, &mmap->mmap_size);
+               if (mmap->mmap_base == MAP_FAILED)
                        i_fatal("Failed to read config: mmap(%s) failed: %m", path);
-               if (config_mmap->mmap_size == 0)
+               if (mmap->mmap_size == 0)
                        i_fatal("Failed to read config: %s file size is empty", path);
 
-               service->config_mmap = config_mmap;
-               hash_table_create(&config_mmap->blocks, default_pool, 0,
+               service->config_mmap = mmap;
+               hash_table_create(&mmap->blocks, default_pool, 0,
                                  str_hash, strcmp);
 
                if (input->return_config_fd)