Kouhei Sutou 2019-01-28 17:36:48 +0900 (Mon, 28 Jan 2019) Revision: 855fdb79b7c70271e24088f15ee68555577faf71 https://github.com/groonga/groonga/commit/855fdb79b7c70271e24088f15ee68555577faf71 Message: alloc: always build fail malloc But fail malloc is disabled by default. You need to define GRN_FAIL_MALLOC_ENABLE=yes environment variable. Here are environment variables for fail malloc: * GRN_FAIL_MALLOC_PROB=[0,1) * Probability to fail * GRN_FAIL_MALLOC_SEED=NUMBER * Seed for rand() * GRN_FAIL_MALLOC_FUNC=NAME * Restrict fail targets to the function * GRN_FAIL_MALLOC_FILE=FILE * Restrict fail targets to all location in the file * GRN_FAIL_MALLOC_LINE=LINE * Restrict fail targets to the line Dynamic malloc change feature is removed. Because it's not used. Modified files: config.h.cmake configure.ac lib/alloc.c lib/grn_alloc.h lib/grn_ctx_impl.h lib/io.c Modified: config.h.cmake (+0 -3) =================================================================== --- config.h.cmake 2019-01-28 16:29:12 +0900 (e899f3444) +++ config.h.cmake 2019-01-28 17:36:48 +0900 (81fced427) @@ -53,16 +53,13 @@ #cmakedefine USE_MEMORY_DEBUG #cmakedefine USE_MAP_HUGETLB #cmakedefine USE_AIO -#cmakedefine USE_DYNAMIC_MALLOC_CHANGE #cmakedefine USE_EPOLL #cmakedefine USE_EXACT_ALLOC_COUNT -#cmakedefine USE_FAIL_MALLOC #cmakedefine USE_FUTEX #cmakedefine USE_KQUEUE #cmakedefine USE_MSG_MORE #cmakedefine USE_MSG_NOSIGNAL #cmakedefine USE_POLL -#cmakedefine USE_QUERY_ABORT #cmakedefine USE_SELECT /* compiler specific build options */ Modified: configure.ac (+0 -49) =================================================================== --- configure.ac 2019-01-28 16:29:12 +0900 (3865feb55) +++ configure.ac 2019-01-28 17:36:48 +0900 (5e20390fa) @@ -531,9 +531,6 @@ AC_ARG_ENABLE(uyield, [enable_uyield="no"]) AC_MSG_RESULT($enable_uyield) -## malloc -force_enable_dynamic_malloc_change="no" - # exact-alloc-count AC_MSG_CHECKING([whether enable exact-alloc-count]) AC_ARG_ENABLE(exact-alloc-count, @@ -545,52 +542,6 @@ if test "x$enable_exact_alloc_count" != "xno"; then fi AC_MSG_RESULT($enable_exact_alloc_count) -# failmalloc -AC_MSG_CHECKING([whether enable fmalloc]) -AC_ARG_ENABLE(fmalloc, - [AS_HELP_STRING([--enable-fmalloc], - [make memory allocation failed in specified condition for debug. [default=no]])], - , - [enable_fmalloc="no"]) -if test "x$enable_fmalloc" != "xno"; then - force_enable_dynamic_malloc_change="yes" - AC_DEFINE(USE_FAIL_MALLOC, [1], [use fmalloc]) -fi -AC_MSG_RESULT($enable_fmalloc) - -# abort -AC_MSG_CHECKING([whether enable abort]) -AC_ARG_ENABLE(abort, - [AS_HELP_STRING([--enable-abort], - [enable query abortion. [default=no]])], - , - [enable_abort="no"]) -if test "x$enable_abort" != "xno"; then - force_enable_dynamic_malloc_change="yes" - AC_DEFINE(USE_QUERY_ABORT, [1], [use abort]) -fi -AC_MSG_RESULT($enable_abort) - -# dynamic malloc change -AC_MSG_CHECKING([whether allow dynamic memory allocation change]) -AC_ARG_ENABLE(dynamic-malloc-change, - [AS_HELP_STRING([--enable-dynamic-malloc-change], - [allow dynamic memory allocation change for testing. [default=no]])], - , - [enable_dynamic_malloc_change="no"]) -if test "x$enable_dynamic_malloc_change" != "xyes" -a \ - "x$force_enable_dynamic_malloc_change" = "xyes"; then - enable_dynamic_malloc_change="yes" - AC_MSG_RESULT([$enable_dynamic_malloc_change (force)]) -else - AC_MSG_RESULT([$enable_dynamic_malloc_change]) -fi - -if test "x$enable_dynamic_malloc_change" = "xyes"; then - AC_DEFINE(USE_DYNAMIC_MALLOC_CHANGE, [1], - [Define to 1 if you enable dynamic malloc change]) -fi - # memory debug AC_MSG_CHECKING([whether debug memory management]) AC_ARG_ENABLE(memory-debug, Modified: lib/alloc.c (+107 -177) =================================================================== --- lib/alloc.c 2019-01-28 16:29:12 +0900 (0c02f2ee2) +++ lib/alloc.c 2019-01-28 17:36:48 +0900 (21dfb0394) @@ -1,6 +1,7 @@ /* -*- c-basic-offset: 2 -*- */ /* Copyright(C) 2009-2016 Brazil + Copyright(C) 2019 Kouhei Sutou <kou****@clear*****> This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public @@ -22,12 +23,12 @@ static int alloc_count = 0; -#ifdef USE_FAIL_MALLOC -static int grn_fmalloc_prob = 0; -static char *grn_fmalloc_func = NULL; -static char *grn_fmalloc_file = NULL; -static int grn_fmalloc_line = 0; -#endif /* USE_FAIL_MALLOC */ +static grn_bool grn_fail_malloc_enable = GRN_FALSE; +static int grn_fail_malloc_prob = 0; +static grn_bool grn_fail_malloc_location = GRN_FALSE; +static char *grn_fail_malloc_func = NULL; +static char *grn_fail_malloc_file = NULL; +static int grn_fail_malloc_line = 0; #ifdef USE_EXACT_ALLOC_COUNT # define GRN_ADD_ALLOC_COUNT(count) do { \ @@ -40,56 +41,74 @@ static int grn_fmalloc_line = 0; } while (0) #endif +int +grn_alloc_count(void) +{ + return alloc_count; +} + void grn_alloc_init_from_env(void) { -#ifdef USE_FAIL_MALLOC { - char grn_fmalloc_prob_env[GRN_ENV_BUFFER_SIZE]; - grn_getenv("GRN_FMALLOC_PROB", - grn_fmalloc_prob_env, + char grn_fail_malloc_enable_env[GRN_ENV_BUFFER_SIZE]; + grn_getenv("GRN_FAIL_MALLOC_ENABLE", + grn_fail_malloc_enable_env, + GRN_ENV_BUFFER_SIZE); + if (strcmp(grn_fail_malloc_enable_env, "yes") == 0) { + grn_fail_malloc_enable = GRN_TRUE; + } else { + grn_fail_malloc_enable = GRN_FALSE; + } + } + { + char grn_fail_malloc_prob_env[GRN_ENV_BUFFER_SIZE]; + grn_getenv("GRN_FAIL_MALLOC_PROB", + grn_fail_malloc_prob_env, GRN_ENV_BUFFER_SIZE); - if (grn_fmalloc_prob_env[0]) { - char grn_fmalloc_seed_env[GRN_ENV_BUFFER_SIZE]; - grn_fmalloc_prob = strtod(grn_fmalloc_prob_env, 0) * RAND_MAX; - grn_getenv("GRN_FMALLOC_SEED", - grn_fmalloc_seed_env, + if (grn_fail_malloc_prob_env[0]) { + char grn_fail_malloc_seed_env[GRN_ENV_BUFFER_SIZE]; + grn_fail_malloc_prob = strtod(grn_fail_malloc_prob_env, 0) * RAND_MAX; + grn_getenv("GRN_FAIL_MALLOC_SEED", + grn_fail_malloc_seed_env, GRN_ENV_BUFFER_SIZE); - if (grn_fmalloc_seed_env[0]) { - srand((unsigned int)atoi(grn_fmalloc_seed_env)); + if (grn_fail_malloc_seed_env[0]) { + srand((unsigned int)atoi(grn_fail_malloc_seed_env)); } else { srand((unsigned int)time(NULL)); } } } { - static char grn_fmalloc_func_env[GRN_ENV_BUFFER_SIZE]; - grn_getenv("GRN_FMALLOC_FUNC", - grn_fmalloc_func_env, + static char grn_fail_malloc_func_env[GRN_ENV_BUFFER_SIZE]; + grn_getenv("GRN_FAIL_MALLOC_FUNC", + grn_fail_malloc_func_env, GRN_ENV_BUFFER_SIZE); - if (grn_fmalloc_func_env[0]) { - grn_fmalloc_func = grn_fmalloc_func_env; + if (grn_fail_malloc_func_env[0]) { + grn_fail_malloc_location = GRN_TRUE; + grn_fail_malloc_func = grn_fail_malloc_func_env; } } { - static char grn_fmalloc_file_env[GRN_ENV_BUFFER_SIZE]; - grn_getenv("GRN_FMALLOC_FILE", - grn_fmalloc_file_env, + static char grn_fail_malloc_file_env[GRN_ENV_BUFFER_SIZE]; + grn_getenv("GRN_FAIL_MALLOC_FILE", + grn_fail_malloc_file_env, GRN_ENV_BUFFER_SIZE); - if (grn_fmalloc_file_env[0]) { - grn_fmalloc_file = grn_fmalloc_file_env; + if (grn_fail_malloc_file_env[0]) { + grn_fail_malloc_location = GRN_TRUE; + grn_fail_malloc_file = grn_fail_malloc_file_env; } } { - char grn_fmalloc_line_env[GRN_ENV_BUFFER_SIZE]; - grn_getenv("GRN_FMALLOC_LINE", - grn_fmalloc_line_env, + char grn_fail_malloc_line_env[GRN_ENV_BUFFER_SIZE]; + grn_getenv("GRN_FAIL_MALLOC_LINE", + grn_fail_malloc_line_env, GRN_ENV_BUFFER_SIZE); - if (grn_fmalloc_line_env[0]) { - grn_fmalloc_line = atoi(grn_fmalloc_line_env); + if (grn_fail_malloc_line_env[0]) { + grn_fail_malloc_location = GRN_TRUE; + grn_fail_malloc_line = atoi(grn_fail_malloc_line_env); } } -#endif /* USE_FAIL_MALLOC */ } #ifdef USE_MEMORY_DEBUG @@ -321,20 +340,6 @@ grn_alloc_info_free(grn_ctx *ctx) void grn_alloc_init_ctx_impl(grn_ctx *ctx) { -#ifdef USE_DYNAMIC_MALLOC_CHANGE -# ifdef USE_FAIL_MALLOC - ctx->impl->malloc_func = grn_malloc_fail; - ctx->impl->calloc_func = grn_calloc_fail; - ctx->impl->realloc_func = grn_realloc_fail; - ctx->impl->strdup_func = grn_strdup_fail; -# else - ctx->impl->malloc_func = grn_malloc_default; - ctx->impl->calloc_func = grn_calloc_default; - ctx->impl->realloc_func = grn_realloc_default; - ctx->impl->strdup_func = grn_strdup_default; -# endif -#endif - #ifdef USE_MEMORY_DEBUG ctx->impl->alloc_info = NULL; #endif @@ -644,83 +649,12 @@ grn_ctx_free_lifo(grn_ctx *ctx, void *ptr, } } -#if USE_DYNAMIC_MALLOC_CHANGE -grn_malloc_func -grn_ctx_get_malloc(grn_ctx *ctx) -{ - if (!ctx || !ctx->impl) { return NULL; } - return ctx->impl->malloc_func; -} - -void -grn_ctx_set_malloc(grn_ctx *ctx, grn_malloc_func malloc_func) -{ - if (!ctx || !ctx->impl) { return; } - ctx->impl->malloc_func = malloc_func; -} - -grn_calloc_func -grn_ctx_get_calloc(grn_ctx *ctx) -{ - if (!ctx || !ctx->impl) { return NULL; } - return ctx->impl->calloc_func; -} - -void -grn_ctx_set_calloc(grn_ctx *ctx, grn_calloc_func calloc_func) -{ - if (!ctx || !ctx->impl) { return; } - ctx->impl->calloc_func = calloc_func; -} - -grn_realloc_func -grn_ctx_get_realloc(grn_ctx *ctx) -{ - if (!ctx || !ctx->impl) { return NULL; } - return ctx->impl->realloc_func; -} - -void -grn_ctx_set_realloc(grn_ctx *ctx, grn_realloc_func realloc_func) -{ - if (!ctx || !ctx->impl) { return; } - ctx->impl->realloc_func = realloc_func; -} - -grn_strdup_func -grn_ctx_get_strdup(grn_ctx *ctx) -{ - if (!ctx || !ctx->impl) { return NULL; } - return ctx->impl->strdup_func; -} - -void -grn_ctx_set_strdup(grn_ctx *ctx, grn_strdup_func strdup_func) -{ - if (!ctx || !ctx->impl) { return; } - ctx->impl->strdup_func = strdup_func; -} - -grn_free_func -grn_ctx_get_free(grn_ctx *ctx) -{ - if (!ctx || !ctx->impl) { return NULL; } - return ctx->impl->free_func; -} - -void -grn_ctx_set_free(grn_ctx *ctx, grn_free_func free_func) -{ - if (!ctx || !ctx->impl) { return; } - ctx->impl->free_func = free_func; -} - void * grn_malloc(grn_ctx *ctx, size_t size, const char* file, int line, const char *func) { - if (ctx && ctx->impl && ctx->impl->malloc_func) { - return ctx->impl->malloc_func(ctx, size, file, line, func); + if (grn_fail_malloc_should_fail(size, file, line, func)) { + return grn_malloc_fail(ctx, size, file, line, func); } else { return grn_malloc_default(ctx, size, file, line, func); } @@ -730,8 +664,8 @@ void * grn_calloc(grn_ctx *ctx, size_t size, const char* file, int line, const char *func) { - if (ctx && ctx->impl && ctx->impl->calloc_func) { - return ctx->impl->calloc_func(ctx, size, file, line, func); + if (grn_fail_malloc_should_fail(size, file, line, func)) { + return grn_calloc_fail(ctx, size, file, line, func); } else { return grn_calloc_default(ctx, size, file, line, func); } @@ -741,8 +675,8 @@ void * grn_realloc(grn_ctx *ctx, void *ptr, size_t size, const char* file, int line, const char *func) { - if (ctx && ctx->impl && ctx->impl->realloc_func) { - return ctx->impl->realloc_func(ctx, ptr, size, file, line, func); + if (grn_fail_malloc_should_fail(size, file, line, func)) { + return grn_realloc_fail(ctx, ptr, size, file, line, func); } else { return grn_realloc_default(ctx, ptr, size, file, line, func); } @@ -752,8 +686,10 @@ char * grn_strdup(grn_ctx *ctx, const char *string, const char* file, int line, const char *func) { - if (ctx && ctx->impl && ctx->impl->strdup_func) { - return ctx->impl->strdup_func(ctx, string, file, line, func); + /* TODO: strlen(string) when we use size in grn_fail_malloc_should_fail(). */ + size_t size = 0; + if (grn_fail_malloc_should_fail(size, file, line, func)) { + return grn_strdup_fail(ctx, string, file, line, func); } else { return grn_strdup_default(ctx, string, file, line, func); } @@ -763,13 +699,8 @@ void grn_free(grn_ctx *ctx, void *ptr, const char* file, int line, const char *func) { - if (ctx && ctx->impl && ctx->impl->free_func) { - return ctx->impl->free_func(ctx, ptr, file, line, func); - } else { - return grn_free_default(ctx, ptr, file, line, func); - } + grn_free_default(ctx, ptr, file, line, func); } -#endif void * grn_malloc_default(grn_ctx *ctx, size_t size, @@ -864,12 +795,6 @@ grn_realloc_default(grn_ctx *ctx, void *ptr, size_t size, return res; } -int -grn_alloc_count(void) -{ - return alloc_count; -} - char * grn_strdup_default(grn_ctx *ctx, const char *s, const char* file, int line, const char *func) @@ -892,70 +817,75 @@ grn_strdup_default(grn_ctx *ctx, const char *s, } } -#ifdef USE_FAIL_MALLOC -int -grn_fail_malloc_check(size_t size, - const char *file, int line, const char *func) +grn_bool +grn_fail_malloc_should_fail(size_t size, + const char *file, int line, const char *func) { - if ((grn_fmalloc_file && strcmp(file, grn_fmalloc_file)) || - (grn_fmalloc_line && line != grn_fmalloc_line) || - (grn_fmalloc_func && strcmp(func, grn_fmalloc_func))) { - return 1; + if (!grn_fail_malloc_enable) { + return GRN_FALSE; } - if (grn_fmalloc_prob && grn_fmalloc_prob >= rand()) { - return 0; + + if (grn_fail_malloc_location) { + if (grn_fail_malloc_file) { + if (strcmp(file, grn_fail_malloc_file) != 0) { + return GRN_FALSE; + } + } + if (grn_fail_malloc_line > 0) { + if (line != grn_fail_malloc_line) { + return GRN_FALSE; + } + } + if (grn_fail_malloc_func) { + if (strcmp(func, grn_fail_malloc_func) != 0) { + return GRN_FALSE; + } + } + return GRN_TRUE; } - return 1; + + if (grn_fail_malloc_prob > 0 && grn_fail_malloc_prob >= rand()) { + return GRN_TRUE; + } + + return GRN_FALSE; } void * grn_malloc_fail(grn_ctx *ctx, size_t size, const char* file, int line, const char *func) { - if (grn_fail_malloc_check(size, file, line, func)) { - return grn_malloc_default(ctx, size, file, line, func); - } else { - MERR("fail_malloc (%" GRN_FMT_SIZE ") (%s:%d@%s) <%d>", - size, file, line, func, alloc_count); - return NULL; - } + MERR("[alloc][fail][malloc] <%d>: <%" GRN_FMT_SIZE ">: %s:%d: %s", + alloc_count, size, file, line, func); + return NULL; } void * grn_calloc_fail(grn_ctx *ctx, size_t size, const char* file, int line, const char *func) { - if (grn_fail_malloc_check(size, file, line, func)) { - return grn_calloc_default(ctx, size, file, line, func); - } else { - MERR("fail_calloc (%" GRN_FMT_SIZE ") (%s:%d@%s) <%d>", - size, file, line, func, alloc_count); - return NULL; - } + MERR("[alloc][fail][calloc] <%d>: <%" GRN_FMT_SIZE ">: %s:%d: %s", + alloc_count, size, file, line, func); + return NULL; } void * grn_realloc_fail(grn_ctx *ctx, void *ptr, size_t size, const char* file, int line, const char *func) { - if (grn_fail_malloc_check(size, file, line, func)) { - return grn_realloc_default(ctx, ptr, size, file, line, func); - } else { - MERR("fail_realloc (%p,%" GRN_FMT_SIZE ") (%s:%d@%s) <%d>", - ptr, size, file, line, func, alloc_count); - return NULL; - } + MERR("[alloc][fail][realloc] <%d>: <%p:%" GRN_FMT_SIZE ">: %s:%d: %s", + alloc_count, ptr, size, file, line, func); + return NULL; } char * grn_strdup_fail(grn_ctx *ctx, const char *s, const char* file, int line, const char *func) { - if (grn_fail_malloc_check(strlen(s), file, line, func)) { - return grn_strdup_default(ctx, s, file, line, func); - } else { - MERR("fail_strdup(%p) (%s:%d@%s) <%d>", s, file, line, func, alloc_count); - return NULL; - } + MERR("[alloc][fail][strdup] <%d>: <%" GRN_FMT_SIZE ">: %s:%d: %s: <%s>", + alloc_count, + s ? strlen(s) : 0, + file, line, func, + s ? s : "(null)"); + return NULL; } -#endif /* USE_FAIL_MALLOC */ Modified: lib/grn_alloc.h (+7 -34) =================================================================== --- lib/grn_alloc.h 2019-01-28 16:29:12 +0900 (8ea98cdb9) +++ lib/grn_alloc.h 2019-01-28 17:36:48 +0900 (630ce2bdc) @@ -1,6 +1,7 @@ /* -*- c-basic-offset: 2 -*- */ /* Copyright(C) 2009-2016 Brazil + Copyright(C) 2019 Kouhei Sutou <kou****@clear*****> This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public @@ -24,6 +25,8 @@ extern "C" { #endif +int grn_alloc_count(void); + void grn_alloc_init_from_env(void); void grn_alloc_init_ctx_impl(grn_ctx *ctx); @@ -81,28 +84,6 @@ void *grn_ctx_alloc_lifo(grn_ctx *ctx, void grn_ctx_free_lifo(grn_ctx *ctx, void *ptr, const char* file, int line, const char *func); -#ifdef USE_DYNAMIC_MALLOC_CHANGE -typedef void *(*grn_malloc_func) (grn_ctx *ctx, size_t size, - const char *file, int line, const char *func); -typedef void *(*grn_calloc_func) (grn_ctx *ctx, size_t size, - const char *file, int line, const char *func); -typedef void *(*grn_realloc_func) (grn_ctx *ctx, void *ptr, size_t size, - const char *file, int line, const char *func); -typedef char *(*grn_strdup_func) (grn_ctx *ctx, const char *string, - const char *file, int line, const char *func); -typedef void (*grn_free_func) (grn_ctx *ctx, void *ptr, - const char *file, int line, const char *func); -grn_malloc_func grn_ctx_get_malloc(grn_ctx *ctx); -void grn_ctx_set_malloc(grn_ctx *ctx, grn_malloc_func malloc_func); -grn_calloc_func grn_ctx_get_calloc(grn_ctx *ctx); -void grn_ctx_set_calloc(grn_ctx *ctx, grn_calloc_func calloc_func); -grn_realloc_func grn_ctx_get_realloc(grn_ctx *ctx); -void grn_ctx_set_realloc(grn_ctx *ctx, grn_realloc_func realloc_func); -grn_strdup_func grn_ctx_get_strdup(grn_ctx *ctx); -void grn_ctx_set_strdup(grn_ctx *ctx, grn_strdup_func strdup_func); -grn_free_func grn_ctx_get_free(grn_ctx *ctx); -void grn_ctx_set_free(grn_ctx *ctx, grn_free_func free_func); - void *grn_malloc(grn_ctx *ctx, size_t size, const char *file, @@ -121,13 +102,6 @@ void *grn_realloc(grn_ctx *ctx, const char *func) GRN_ATTRIBUTE_ALLOC_SIZE(3); char *grn_strdup(grn_ctx *ctx, const char *s, const char* file, int line, const char *func); void grn_free(grn_ctx *ctx, void *ptr, const char *file, int line, const char *func); -#else -# define grn_malloc grn_malloc_default -# define grn_calloc grn_calloc_default -# define grn_realloc grn_realloc_default -# define grn_strdup grn_strdup_default -# define grn_free grn_free_default -#endif GRN_API void *grn_malloc_default(grn_ctx *ctx, size_t size, @@ -148,15 +122,14 @@ void *grn_realloc_default(grn_ctx *ctx, GRN_API char *grn_strdup_default(grn_ctx *ctx, const char *s, const char* file, int line, const char *func); GRN_API void grn_free_default(grn_ctx *ctx, void *ptr, const char* file, int line, const char *func); -#ifdef USE_FAIL_MALLOC -int grn_fail_malloc_check(size_t size, const char *file, int line, const char *func); +grn_bool grn_fail_malloc_should_fail(size_t size, + const char *file, + int line, + const char *func); void *grn_malloc_fail(grn_ctx *ctx, size_t size, const char* file, int line, const char *func); void *grn_calloc_fail(grn_ctx *ctx, size_t size, const char* file, int line, const char *func); void *grn_realloc_fail(grn_ctx *ctx, void *ptr, size_t size, const char* file, int line, const char *func); char *grn_strdup_fail(grn_ctx *ctx, const char *s, const char* file, int line, const char *func); -#endif - -int grn_alloc_count(void); #ifdef __cplusplus } Modified: lib/grn_ctx_impl.h (+1 -10) =================================================================== --- lib/grn_ctx_impl.h 2019-01-28 16:29:12 +0900 (ffd2199eb) +++ lib/grn_ctx_impl.h 2019-01-28 17:36:48 +0900 (3b462bedc) @@ -1,7 +1,7 @@ /* -*- c-basic-offset: 2 -*- */ /* Copyright(C) 2009-2018 Brazil - Copyright(C) 2018 Kouhei Sutou <kou****@clear*****> + Copyright(C) 2018-2019 Kouhei Sutou <kou****@clear*****> This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public @@ -146,15 +146,6 @@ struct _grn_ctx_impl { grn_critical_section lock; grn_io_mapinfo segs[GRN_CTX_N_SEGMENTS]; -#ifdef USE_DYNAMIC_MALLOC_CHANGE - /* memory allocation portion */ - grn_malloc_func malloc_func; - grn_calloc_func calloc_func; - grn_realloc_func realloc_func; - grn_strdup_func strdup_func; - grn_free_func free_func; -#endif - #ifdef USE_MEMORY_DEBUG /* memory debug portion */ grn_alloc_info *alloc_info; Modified: lib/io.c (+103 -76) =================================================================== --- lib/io.c 2019-01-28 16:29:12 +0900 (280a483ad) +++ lib/io.c 2019-01-28 17:36:48 +0900 (355ae7c38) @@ -1,7 +1,7 @@ /* -*- c-basic-offset: 2 -*- */ /* Copyright(C) 2009-2018 Brazil - Copyright(C) 2018 Kouhei Sutou <kou****@clear*****> + Copyright(C) 2018-2019 Kouhei Sutou <kou****@clear*****> This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public @@ -84,39 +84,42 @@ grn_inline static void grn_fileinfo_init(fileinfo *fis, int nfis); grn_inline static int grn_fileinfo_opened(fileinfo *fi); grn_inline static grn_rc grn_fileinfo_close(grn_ctx *ctx, fileinfo *fi); #ifdef WIN32 -grn_inline static void * grn_mmap(grn_ctx *ctx, grn_ctx *owner_ctx, - grn_io *io, HANDLE *fmo, fileinfo *fi, - off_t offset, size_t length); +grn_inline static void *grn_mmap(grn_ctx *ctx, + grn_ctx *owner_ctx, + grn_io *io, + HANDLE *fmo, + fileinfo *fi, + off_t offset, + size_t length, + const char *file, + int line, + const char *func); grn_inline static int grn_munmap(grn_ctx *ctx, grn_ctx *owner_ctx, grn_io *io, HANDLE *fmo, fileinfo *fi, void *start, size_t length); # define GRN_MMAP(ctx,owner_ctx,io,fmo,fi,offset,length)\ - (grn_mmap((ctx), (owner_ctx), (io), (fmo), (fi), (offset), (length))) + (grn_mmap((ctx), (owner_ctx), (io), (fmo), (fi), (offset), (length),\ + __FILE__, __LINE__, __FUNCTION__)) # define GRN_MUNMAP(ctx,owner_ctx,io,fmo,fi,start,length)\ (grn_munmap((ctx), (owner_ctx), (io), (fmo), (fi), (start), (length))) #else /* WIN32 */ -grn_inline static void * grn_mmap(grn_ctx *ctx, grn_ctx *owner_ctx, - grn_io *io, fileinfo *fi, - off_t offset, size_t length); +grn_inline static void *grn_mmap(grn_ctx *ctx, + grn_ctx *owner_ctx, + grn_io *io, + fileinfo *fi, + off_t offset, + size_t length, + const char *file, + int line, + const char *func); grn_inline static int grn_munmap(grn_ctx *ctx, grn_ctx *owner_ctx, grn_io *io, fileinfo *fi, void *start, size_t length); +# define GRN_MMAP(ctx,owner_ctx,io,fmo,fi,offset,length)\ + (grn_mmap((ctx), (owner_ctx), (io), (fi), (offset), (length),\ + __FILE__, __LINE__, __FUNCTION__)) # define GRN_MUNMAP(ctx,owner_ctx,io,fmo,fi,start,length) \ (grn_munmap((ctx), (owner_ctx), (io), (fi), (start), (length))) -# ifdef USE_FAIL_MALLOC -grn_inline static void * grn_fail_mmap(grn_ctx *ctx, grn_ctx *owner_ctx, - grn_io *io, fileinfo *fi, - off_t offset, size_t length, - const char* file, - int line, - const char *func); -# define GRN_MMAP(ctx,owner_ctx,io,fmo,fi,offset,length)\ - (grn_fail_mmap((ctx), (owner_ctx), (io), (fi), (offset), (length),\ - __FILE__, __LINE__, __FUNCTION__)) -# else /* USE_FAIL_MALLOC */ -# define GRN_MMAP(ctx,owner_ctx,io,fmo,fi,offset,length)\ - (grn_mmap((ctx), (owner_ctx), (io), (fi), (offset), (length))) -# endif /* USE_FAIL_MALLOC */ #endif /* WIN32 */ grn_inline static int grn_msync(grn_ctx *ctx, @@ -1921,17 +1924,41 @@ grn_guess_io_version(grn_ctx *ctx, grn_io *io, fileinfo *fi) } grn_inline static void * -grn_mmap(grn_ctx *ctx, grn_ctx *owner_ctx, grn_io *io, HANDLE *fmo, - fileinfo *fi, off_t offset, size_t length) -{ - int version; +grn_mmap(grn_ctx *ctx, + grn_ctx *owner_ctx, + grn_io *io, + HANDLE *fmo, + fileinfo *fi, + off_t offset, + size_t length, + const char *file, + int line, + const char *func) +{ + if (grn_fail_malloc_should_fail(length, file, line, func)) { + MERR("[alloc][fail][mmap] <%d>: <%" GRN_FMT_SIZE ">: <%s>: " + "<%p:%" GRN_FMT_INT64U ":%" GRN_FMT_SIZE ">: " + "%s:%d: %s", + grn_alloc_count(), + mmap_size, + io ? (io->path[0] ? io->path : "(memory)") : "(null)", + fi ? fi->fh : NULL, + (uint64_t)offset, + length, + file, + line, + func); + return NULL; + } else { + int version; - version = grn_guess_io_version(ctx, io, fi); + version = grn_guess_io_version(ctx, io, fi); - if (version == 0) { - return grn_mmap_v0(ctx, owner_ctx, fi, offset, length); - } else { - return grn_mmap_v1(ctx, owner_ctx, fmo, fi, offset, length); + if (version == 0) { + return grn_mmap_v0(ctx, owner_ctx, fi, offset, length); + } else { + return grn_mmap_v1(ctx, owner_ctx, fmo, fi, offset, length); + } } } @@ -2120,57 +2147,57 @@ grn_fileinfo_close(grn_ctx *ctx, fileinfo *fi) #include <sys/mman.h> grn_inline static void * -grn_mmap(grn_ctx *ctx, grn_ctx *owner_ctx, grn_io *io, fileinfo *fi, - off_t offset, size_t length) -{ - void *res; - int fd, flags; - if (fi) { - struct stat s; - off_t tail = offset + length; - fd = fi->fd; - if ((fstat(fd, &s) == -1) || (s.st_size < tail && ftruncate(fd, tail) == -1)) { - SERR("fstat"); - return NULL; - } - flags = MAP_SHARED; - } else { - fd = -1; - flags = MAP_PRIVATE|MAP_ANONYMOUS; - } - res = mmap(NULL, length, PROT_READ|PROT_WRITE, flags, fd, offset); - if (MAP_FAILED == res) { - MERR("mmap(%" GRN_FMT_LLU ",%d,%" GRN_FMT_LLD ")=%s <%" GRN_FMT_LLU ">", - (unsigned long long int)length, fd, (long long int)offset, - strerror(errno), (unsigned long long int)mmap_size); - return NULL; - } - mmap_size += length; - return res; -} - -#ifdef USE_FAIL_MALLOC -grn_inline static void * -grn_fail_mmap(grn_ctx *ctx, grn_ctx *owner_ctx, grn_io *io, fileinfo *fi, - off_t offset, size_t length, - const char* file, int line, const char *func) -{ - if (grn_fail_malloc_check(length, file, line, func)) { - return grn_mmap(ctx, io, fi, offset, length); - } else { - MERR("fail_mmap(%" GRN_FMT_SIZE ",%d,%" GRN_FMT_LLU ") " - "(%s:%d@%s) <%" GRN_FMT_SIZE ">", - length, +grn_mmap(grn_ctx *ctx, + grn_ctx *owner_ctx, + grn_io *io, + fileinfo *fi, + off_t offset, + size_t length, + const char *file, + int line, + const char *func) +{ + if (grn_fail_malloc_should_fail(length, file, line, func)) { + MERR("[alloc][fail][mmap] <%d>: <%" GRN_FMT_SIZE ">: <%s>: " + "<%d:%" GRN_FMT_INT64U ":%" GRN_FMT_SIZE ">: " + "%s:%d: %s", + grn_alloc_count(), + mmap_size, + io ? (io->path[0] ? io->path : "(memory)") : "(null)", fi ? fi->fd : 0, - (long long unsigned int)offset, + (uint64_t)offset, + length, file, line, - func, - mmap_size); + func); return NULL; + } else { + void *res; + int fd, flags; + if (fi) { + struct stat s; + off_t tail = offset + length; + fd = fi->fd; + if ((fstat(fd, &s) == -1) || (s.st_size < tail && ftruncate(fd, tail) == -1)) { + SERR("fstat"); + return NULL; + } + flags = MAP_SHARED; + } else { + fd = -1; + flags = MAP_PRIVATE|MAP_ANONYMOUS; + } + res = mmap(NULL, length, PROT_READ|PROT_WRITE, flags, fd, offset); + if (MAP_FAILED == res) { + MERR("mmap(%" GRN_FMT_LLU ",%d,%" GRN_FMT_LLD ")=%s <%" GRN_FMT_LLU ">", + (unsigned long long int)length, fd, (long long int)offset, + strerror(errno), (unsigned long long int)mmap_size); + return NULL; + } + mmap_size += length; + return res; } } -#endif /* USE_FAIL_MALLOC */ grn_inline static int grn_msync(grn_ctx *ctx, fileinfo *fi, void *start, size_t length) -------------- next part -------------- An HTML attachment was scrubbed... URL: <https://lists.osdn.me/mailman/archives/groonga-commit/attachments/20190128/a1c66c4e/attachment-0001.html>
