danigm.net - ffi

Rust: Rust+C (parte 2), Llamando código C desde Rust

danigm — Sun, 30 Apr 2017 00:00:00 +0200

En el artículo anterior hablamos sobre la integración de Rust con C, sobre cómo llamar a código Rust desde C. Este artículo es la segunda parte sobre integración de Rust con C, donde veremos cómo hacer la operación inversa, llamar código C desde Rust.

Esto puede ser muy útil si tenemos librerías de terceros que tenemos que usar, así podemos hacer un wrapper en Rust fácilmente. En cuanto a rendimiento no es muy útil, ya que en Rust se puede escribir código tan eficiente o más que en C.

Llamando a código C desde Rust

Supongamos que tenemos una función en C, que queremos llamar desde nuestro código en Rust:

#include <stdio.h>


void repeat(char *str, int n) {
    int i;

    for (i=0; i<n; i++) {
        printf("%s\n", str);
    }
}

En el primer artículo se habla sobre cómo pasar tipos de datos más complejos, de momento, para este ejemplo tenemos tipos básicos, como un puntero a char y un int, que se traducen en Rust como *const u8 y i32.

Esta función la podemos llamar desde nuestro código Rust de la siguiente manera:

extern crate libc;

#[link(name = "cffi")]
extern {
    fn repeat(s: *const u8, n: i32);
}

fn main() {
    unsafe {
        repeat("Salida desde C\0".as_ptr(), 5);
    }
}

Lo primero a resaltar de este código Rust es el atributo "link". Esto le dice al compilador de Rust que tiene que enlazar con la biblioteca libcffi. La otra cosa que hay que tener en cuenta es el uso de unsafe. Cuando llamamos a una función en C, siempre tendremos que usar usanfe, porque ese código no está controlado por el compilador Rust y por tanto no podemos considerarlo seguro.

Si queremos limitar el uso de unsafe, la práctica recomendada es la creación de una interfaz segura:

extern crate libc;

#[link(name = "cffi")]
extern {
    fn repeat(s: *const u8, n: i32);
}

fn safe_repeat(s: &str, n: i32) {
    let st = String::from(s) + "\0";
    unsafe {
        repeat(st.as_ptr(), n);
    }
}

fn main() {
    unsafe {
        repeat("Salida desde C\0".as_ptr(), 5);
    }

    safe_repeat("Safe", 10);
}

Para este ejemplo podemos convertir la cadena a una cadena de C, terminada en \0, además de ocultar la función no segura.

Compilando código C con Cargo

Para compilar código C utilizando Cargo se puede utilizar el crate gcc, que ofrece una interfaz Rust para llamar a gcc, en combinación con el script de compilación build.rs, que es llamado por cargo por defecto antes de compilar.

Por ejemplo, si tenemos un fichero 'lib.c' y queremos que se compile cuando ejecutamos cargo build, sólo tenemos que añadir lo siguiente a los ficheros build.rs y Cargo.toml:

# Cargo.tolm
...
[build-dependencies]
gcc = "0.3"
...

/// build.rs
extern crate gcc;

fn main() {
    gcc::compile_library("libcffi.a", &["src/lib.c"]);
}

Todo el código de ejemplo se puede encontrar en github.

Integración con otros lenguajes

Esta integración con C tan sencilla por parte de Rust nos permite utilizar el gran catálogo de bibliotecas que hay en C. Pero además de esto, dado que C es el lenguaje común entre casi todos los lenguajes modernos, podemos llamar a código Rust fácilmente desde casi cualquier lenguaje, simplemente creando una interfaz C y compilando a una biblioteca en formato C.

Hay un repositorio en github donde se pueden encontrar una serie de ejemplos sencillos de integración de Rust con Python, Perl, Ruby, Haskell, etc.

Rust: Rust+C (parte 1), Llamando código Rust desde C

danigm — Sat, 22 Apr 2017 00:00:00 +0200

Rust es un lenguaje cuyo objetivo principal es sustituir o reemplazar código escrito en C o C++ con código más seguro e igual de eficiente a nivel de rendimiento.

Sin embargo, no es fácil tomar la decisión de migrar todo un proyecto escrito en C/C++ a Rust, de la noche a la mañana. En proyectos pequeños o con poca actividad, quizás sí sea fácil hacer una reescritura completa, pero en la mayoría de proyectos no es viable.

Sin embargo con Rust se puede hacer una migración incremental, implementar la nueva funcionalidad en Rust, o implementar tan sólo las partes que requieran una seguridad extra en la gestión de memoria, y esto es posible gracias a que Rust se puede integrar muy fácilmente con C y C++ con el llamado ffi o Foreign Function Interface.

Llamando a código Rust desde C

Empecemos por lo más sencillo. Supongamos que tenemos una base de código en C, y queremos comenzar una migración, reimplementando algunas partes, o alguna biblioteca interna con Rust. Esto es realmente sencillo siempre y cuando las funciones Rust sean independientes, ya que se pueden llamar directamente.

//lib.rs

#[no_mangle]
pub extern fn suma(a: i32, b: i32) -> i32 {
    println!("sumando dentro de rust {} + {}", a, b);
    a + b
}

Para poder acceder desde C a estas funciones debemos añadir algunos detalles, como el atributo "#[no_mangle]", y el modificador extern en la definición de la función.

Supongamos ahora que tenemos un código en C donde queremos hacer uso de esta función definida en Rust:

// example1.c

#include <stdio.h>

int suma(int a, int b);

int main(int argc, char **argv) {
    int a = 3, b = 2, s = 0;

    s = suma(a, b);
    printf("%d + %d = %d", a, b, s);
    return 0;
}

Como vemos, declaramos la función, suma en el código C, pero no añadimos la implementación, ya que usaremos la implementación Rust.

Para poder compilar este código C, tenemos que tener el código Rust compilado en forma de biblioteca compatible con C, podemos hacerlo como staticlib (.a) o como cdylib (.so).

$ rustc --crate-type staticlib lib.rs -o librust.a

Con esto tenemos el fichero .a compilado con la implementación de la función suma, ahora tan sólo tenemos que compilar nuestro fichero C para que haga uso de esta implementación:

$ gcc -Wl,--gc-sections -lpthread example1.c librust.a -o example1
$ ./example1

sumando dentro de rust 3 + 2
3 + 2 = 5

Devolución de tipos más complejos, structs

Trabajar con enteros es muy sencillo, ya que tenemos compatibilidad de tipos, i32 e int. Sin embargo normalmente tendremos otros tipos más complejos que querremos pasar a nuestras funciones Rust, o que querremos devolver.

En Rust se pueden definir estructuras compatibles con C añadiendo un atributo, al igual que en las definiciones de funciones, pero en este caso sería "#[repr(C)]".

use std::slice;
use std::str;

#[repr(C)]
pub struct Dato {
    n: i32,
    cadenac: *const u8,
    cadenarust: String,
    vec: Vec<i32>,
}

#[no_mangle]
pub extern fn dato_crear(n: i32, cadenac: *const u8, l: usize) -> *mut Dato {
    let mut s = unsafe {
        String::from(str::from_utf8(slice::from_raw_parts(cadenac, l)).unwrap())
    };
    s = s + ", desde Rust";
    let v = vec![n, n, n];
    let dato = Dato{n: n, cadenac: cadenac, cadenarust: s, vec: v};

    Box::into_raw(Box::new(dato))
}

#[no_mangle]
pub extern fn dato_print(dato: *mut Dato) {
    unsafe {
        println!("cadena: {}", (*dato).cadenarust);
        println!("vec: {:?}", (*dato).vec);
    }
}

#[no_mangle]
pub extern fn dato_destruir(dato: *mut Dato) {
    unsafe {
        let _ = Box::from_raw(dato);
    }
}

En este ejemplo definimos una estructura, Dato, que tiene varios campos, algunos compatibles con C, n y cadenac, y otros que no, cadenarust y vec.

Además definimos una serie de funciones que nos permitirán trabajar con esta estructura desde C, para la creación dato_crear, para acceder a elementos Rust del dato dato_print y para liberar la memoria dato_destruir.

Hay que tener en cuenta que para poder trabajar en C con esta estructura, en la creación del dato no devolvemos el dato creado, sino un puntero a este *mut Dato y además, para evitar que Rust elimine la memoria asociada a esta estructura y podamos acceder desde C, la metemos en un Box y lo convertimos a puntero into_raw.

El meter el dato en un Box, lo que hacemos es alojar esta memoria en el heap en lugar de en el stack. Luego, usando el into_raw, Rust se olvida de esta memoria y nos devuelve un puntero, así que a partir de ahora, nosotros seremos responsables de esta memoria y tenemos que tener especial cuidado, porque podremos tener memory leaks si no liberamos esto.

Para liberar esta memoria que ahora gestionamos manualmente desde Rust, podemos utilizar la operación inversa al into_raw, que es el from_raw, que hace justamente lo contrario, recibe un puntero y nos devuelve un Box, y cuando Rust elimine esta variable, la memoria se liberará, de ahí el uso de esta función en dato_destruir.

A parte de la creación y destrucción usando Box, también se define una función intermedia en Rust, que hace uso de esta estructura en código Rust, en este caso, para imprimir la cadena y el vector.

Este código está englobado dentro de un bloque unsafe, porque cada vez que dereferenciamos un puntero, el código es inseguro, y debemos marcarlo como tal. El código es inseguro, porque el compilador no puede asegurar que ese puntero que recibimos apunte realmente a memoria válida, y en esas partes dentro de unsafe es donde podríamos encontrarnos los problemas de segmentation fault y demás.

// example2.c

#include <stdint.h>
#include <stdio.h>
#include <string.h>

struct Dato {
    int n;
    char *cadenac;
};

extern struct Dato* dato_crear(int, char*, int);
extern void dato_print(struct Dato*);
extern void dato_destruir(struct Dato*);

int main (int argc, char **argv) {
    int n = 5;
    char *cadena = "Esto es una cadena C";
    struct Dato *dato = dato_crear(n, cadena, strlen(cadena));

    printf("dato: %s\n", dato->cadenac);
    dato_print(dato);

    dato_destruir(dato);
    return 0;
}

Desde C es trivial usar esta estructura y estas nuevas funciones que nos hemos definido. Tan sólo tendríamos que definir una estructura similar en código C y definir las cabeceras de las funciones. Desde C podemos acceder a los parámetros de la estructura compatibles.

Un detalle interesante es que en C no definimos todos los parámetros de la estructura original de Rust, ya que no vamos a acceder a la cadena Rust ni al vector, esto funciona porque hemos definido los parámetros compatibles primero y por tanto al acceder a la memoria es completamente compatible la estructura Rust y la estructura C.

Para la interoperabilidad entre C y Rust, existe un crate llamado libc, que define una serie de tipos que se pueden usar en Rust cuando se hace una interfaz hacia C. En los ejemplos no he utilizado el crate libc, pero sería recomendable si queremos mantener un código compatible con el mayor número de plataformas.

Todo el código de ejemplo se puede encontrar en github, con un Makefile para poder compilarlo fácilmente.