调用enif_free（）时出现分段错误

Question

I have some code that should manage a 3 dimensional array with O(1) access and reading time in Erlang. Therefor I'm using Erlang NIFs. Everything is working fine except for the release() function. I always get a segmentation fault when calling it and I have no idea why.

Here is my code:

#include "erl_nif.h"

static ErlNifResourceType *DATA_RESOURCE;

typedef struct
{
    int size;
    ERL_NIF_TERM *** array;
    ERL_NIF_TERM defaultValue;
} DATA;

static ERL_NIF_TERM new3DimArray(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
    DATA *data = (DATA *)enif_alloc_resource(DATA_RESOURCE, sizeof(DATA));
    int size;
    enif_get_int(env, argv[0], &size);
    if(argc > 1)
    {
        data->defaultValue = argv[1];
    }else{
        data->defaultValue = NULL;
    }
    data->size = size;
    data->array =  (ERL_NIF_TERM ***)enif_alloc(sizeof(ERL_NIF_TERM **) * size);
    int x = 0;
    while(x < size)
    {
        data->array[x] = (ERL_NIF_TERM **)enif_alloc(sizeof(ERL_NIF_TERM *) * size);
        int y = 0;
        while(y < size)
        {
            data->array[x][y] =  (ERL_NIF_TERM *)enif_alloc(sizeof(ERL_NIF_TERM) * size);
            y++;
        }
        x++;
    }
    return enif_make_resource(env, data);
}

static ERL_NIF_TERM get_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
    DATA *data;
    enif_get_resource(env, argv[0], DATA_RESOURCE, &data);
    int x;
    int y;
    int z;
    enif_get_int(env, argv[1], &x);
    enif_get_int(env, argv[2], &y);
    enif_get_int(env, argv[3], &z);
    ERL_NIF_TERM res = data->array[x][y][z];
    if(res == NULL && data->defaultValue != NULL)
    {
        res = data->defaultValue;
    }
    return res;
}

static void set_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
    DATA *data;
    enif_get_resource(env, argv[0], DATA_RESOURCE, &data);
    int x;
    int y;
    int z;
    enif_get_int(env, argv[1], &x);
    enif_get_int(env, argv[2], &y);
    enif_get_int(env, argv[3], &z);
    ERL_NIF_TERM value = argv[4];
    data->array[x][y][z] = value;
}

static void release(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
    DATA *data;
    enif_get_resource(env, argv[0], DATA_RESOURCE, &data);
    int x = 0;
    while(x < data->size)
    {
        int y = 0;
        while(y < data->size)
        {
            enif_free(data->array[x][y]);
            y++;
        }
        enif_free(data->array[x]);
        x++;
    }
    enif_free(data->array);
    enif_release_resource(data);
}

static void cleanup(ErlNifEnv *env, void *obj){}

static int load(ErlNifEnv *env, void **priv_data, ERL_NIF_TERM load_info){
    DATA_RESOURCE = enif_open_resource_type(env, "mutArray", "DATA_RESOURCE", &cleanup, ERL_NIF_RT_CREATE, 0);
    return 0;
}

static ErlNifFunc nif_funcs[] = {
    {"new_3_dim_array", 1, new3DimArray},
    {"new_3_dim_array", 2, new3DimArray},
    {"get", 4, get_nif},
    {"set", 5, set_nif},
    {"release", 1, release}
};

ERL_NIF_INIT(mutArray, nif_funcs, load, NULL, NULL, NULL);

This is my Erlang code (to make the arity clearer):

module(mutArray).

%% ====================================================================
%% API functions
%% ====================================================================
-export([init/0, new_3_dim_array/1, new_3_dim_array/2, get/4, set/5, release/1]).

init() ->
    erlang:load_nif("./mutArray", 0).

new_3_dim_array(_Size) ->
    "NIF not loaded yet.".

new_3_dim_array(_Size, _DefaultValue) ->
    "NIF not loaded yet.".

get(_Array, _X, _Y, _Z) ->
    "NIF not loaded yet.".

set(_Array, _X, _Y, _Z, _Value) ->
    "NIF not loaded yet.".

release(_Array) ->
    "NIF not loaded yet.".

Btw, this is my Testcode:

mutArray:init(),
A = mutArray:new_3_dim_array(100),
mutArray:release(A).

EDIT: Ok it gets more and more weird... After some testing I fidured out that I get ** exception error: [] if enif_free(data->array); is the last call of the function. At every other position I still get the segmentation fault, even if there is just a println() after enif_free(data->array); . After some debugging I also figured out that every line before enif_free(data->array); was called. So the exception seems to happen at enif_free(data->array) . Does anybody know what this means?

EDIT2: Simply leaving enif_free(data->array); out doesn't help either. I get a segmentation fault then as well.

Answer 1

I was able to get your code running correctly by fixing several problems.

First, your code assumes that it's OK to check the validity of an ERL_NIF_TERM by comparing it to NULL , which is incorrect. You can fix this by either initializing all of your array elements to 0 (by calling enif_make_int(env, 0) to set each element), or by using an array of structs where each struct holds an ERL_NIF_TERM and an unsigned char flag to indicate whether the term is valid or not. If you choose the latter approach, you could simply memset the struct values to 0, and if a caller requests an uninitialized element via mutArray:get/4 , just return enif_make_badarg(env) to indicate they passed bad arguments to the call.

Second, both your set_nif and release functions are declared to return void when they need to return ERL_NIF_TERM instead. To fix this you can correct their return types, and then return argv[4] from set_nif and enif_make_int(env, 0) from release .

Lastly, the second argument to your enif_open_resource_type call needs to be NULL rather than the "mutArray" value you're passing, as the erl_nif man page indicates.