Leaking memory when calling lua function with a mutable userdata ref

[Joffi05]

My program is leaking memory when calling a lua function from rust, with a scoped mut ref userdata.
My goal is to have a color buffer for which a lua function decides how it should look which is then painted in rust.
It looks like this:

pub fn call_lua_update_buffer(&mut self) -> mlua::Result<()> {
        let mut gate_ref = self.gate.borrow_mut();
    
        let lua = gate_ref.get_lua_env().ok_or_else(|| mlua::Error::RuntimeError("Failed to get Lua environment".to_string()))?;

        lua.0.load(&lua.1.0).exec()?;
        lua.0.scope(|scope| {
            let visual_buff_ref = scope.create_userdata_ref_mut(&mut self.visual)?;
            let globals = lua.0.globals();
            let draw_func: mlua::Function = globals.get("Draw")?;
            draw_func.call(visual_buff_ref)?;

            Ok(())
        })?;

        Ok(())
    }

The self visual has the type VisualBuffer which looks like this:

struct VisualBuffer {
    pub size: (u32, u32),
    pub texture: TextureHandle,
    pub changed: bool,
    pub buffer: Vec<[u8; 4]>,
}

And this is my implementation for the UserData:

impl UserData for VisualBuffer {
    fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
        methods.add_method_mut("set_all", |_, this, color: (u8, u8, u8, u8)| {
            for i in this.buffer.iter_mut() {
                *i = (color.0, color.1, color.2, color.3).into();
            }
            this.changed = true;
            Ok(())
        });
    }
}

The called lua function intern only calls the set_all function on the buffer.

function Draw(buffer)
    buffer:set_all(0,0,255, 255)
end

I've tried to reproduce the leak minimally and ended with:

use mlua::UserData;


struct Userdata { 
    name: String,
    buffer: Vec<[u8; 4]>,
}

impl UserData for Userdata {
    fn add_methods<'lua, M: mlua::prelude::LuaUserDataMethods<'lua, Self>>(methods: &mut M) {
        methods.add_method_mut("set_buffer", |_, this, color: (u8,u8,u8,u8)| {
            for i in this.buffer.iter_mut() {
                *i = [color.0, color.1, color.2, color.3];
            }
            Ok(())
        });
    }
}



fn main() {
    let mut lua = mlua::Lua::new();
    let mut userdata = Userdata { name: "John".to_string(), buffer: vec![[0,0,0,0]; 100]};
    
    let lua_code = r#"
        function rename(name)
            name:set_buffer(0,0,255,255)
        end
    "#;

    
    loop {
        lua.load(lua_code).exec().unwrap();
        lua.scope(|scope| {
            let userdata_ref = scope.create_userdata_ref_mut(&mut userdata)?;
            let globals = lua.globals();
            let rename: mlua::Function = globals.get("rename")?;
            rename.call(userdata_ref)?;
    
            Ok(())
        }).unwrap();
    }
}

Which doesn't seem to leak. I've been trying to solve this problem for 2 days now and really am quite frustrated with the code and myself. I'm sorry if the solution is obvious.

[khvzak]

My program is leaking memory when calling a lua function from rust, with a scoped mut ref userdata.

How did you diagnose the leak?

[Joffi05]

The program crashes after some time. The ram usage is just steadily increasing. I wasn't able to get useful info from valgrind tho.

[khvzak]

Do you have a full source of the program? The code above looks fine to me and should not have any leaks.

[Joffi05]

Here is the repository:
link