Estoy escribiendo un sistema simple basado en complementos en Rust para obtener algunas habilidades y experiencia usando el lenguaje. Mi sistema carga dinámicamente bibliotecas y las ejecuta en tiempo de ejecución para inicializar cada complemento. Me encuentro con un problema de seguridad predeterminado al ejecutar código desde una biblioteca cargada dinámicamente.

Este es el código para cargar y ejecutar la función de inicio del complemento: (este bit funciona bien)

pub fn register_plugins<'rp>(&'rp mut self)
{
    let p1 = match DynamicLibrary::open(Some("librust_plugin_1.so")) {
            Ok(lib) => lib,
            Err(error) => fail!("Could not load the library: {}", error)
    };
    let s1: extern "Rust" fn(&PluginSystem) = unsafe {
        match p1.symbol("init") {
            Err(error) => fail!("Could not load function init: {}", error),
            Ok(init) => mem::transmute::<*mut u8, _>(init)
        }
    };
    s1(&self.ps);
}

Esta es la función init dentro de la biblioteca de complementos:

#[no_mangle]
pub fn init(ps:&mut PluginSystem)
{
    ps.register_plugin("ps1"); //<-- Segfault is in this method
    ps.add_new_hook_with_closure("onLoad", "ps1", "display greeting.", 10, test1);
    println!("Initialized plugin.");
}

Como se comentó, el segfault ocurre dentro de la función register_plugin de la estructura PluginSystem llamada ps. Esta estructura se toma prestada del método de llamada (en el primer fragmento de código).

Esta es la función register_plugin en PluginSystem:

pub fn register_plugin(&mut self, plugin_name: &'s str)
{
    if ! self.plugins.contains_key(&plugin_name) {
        let hm = HashMap::new(); //<-- Segfault Here
        self.plugins.insert(plugin_name, hm);
    };
}

El segfault ocurre cuando se ejecutaHashMap::new() en este bloque de código;

He intentado implementar esta función de manera diferente, como en:

pub fn register_plugin(&mut self, plugin_name: &'s str)
{
    match self.plugins.entry(plugin_name) {
                Vacant(entry) => {
                        entry.set(HashMap::new()); //<-- Segfault Here
                    }
                Occupied(mut entry) => {  }
            }
}

Pero me sale exactamente el mismo problema.

Si omito la función register_plugin y ejecuto otro código en la biblioteca cargada dinámicamente, funciona bien. De hecho, el único código en el que esto está predeterminado esHashMap::new().

¿Es esto un error o un problema existente, o estoy haciendo algo mal?

Más información: compilé óxido con símbolos de depuración para recorrer el código HashMap y encontrar el problema. Parece que ni siquiera intenta ejecutar la nueva función (), al depurar el código, al ingresarHashMap::new() el depurador avanza directamente a esta función en unwind.rs:

pub unsafe fn try(f: ||) -> ::core::result::Result<(), Box<Any + Send>> {
    let closure: Closure = mem::transmute(f);
    let ep = rust_try(try_fn, closure.code as *mut c_void,
                  closure.env as *mut c_void);
    return if ep.is_null() {
        Ok(())
    } else {
        let my_ep = ep as *mut Exception; //<-- Steps into this line
        rtdebug!("caught {}", (*my_ep).uwe.exception_class);
        let cause = (*my_ep).cause.take(); //<-- Segfaults Here
        uw::_Unwind_DeleteException(ep);
        Err(cause.unwrap())
    };

El Segfault ocurre en elcause.take() función, creo que es porque my_ep.cause es nulo o inaccesible. Entonces, algo está generando una excepción no válida, ytry La función se está ahogando y da la segfault. Esto está relacionado con llamar al código HashMap desde la biblioteca cargada dinámicamente, pero no sé cómo está relacionado.

Gracias por cualquier ayuda.

EDITAR: Mi plataforma es Linux x64, estoy usando un óxido recién construido de git master a partir de ayer (28 de octubre '14).