Libuv

El mecanismo depende del SO. En linux, se usa epoll, en MacOS y BSD, kqueue, y en Windows IOCP. Este mecanismo se usa para las llamadas de red. Para I/O del sistema de archivos realmente se usa un thread pool. No hay primitivas específicas para los distintos SO de las que pueda depender libuv¹. Así que lo que se hace es usar dicho pool y ejecutar en él las acciones sobre el fs, y cuando acaben se notifican.

El siguiente ejemplo es muy bueno para ver la estructura de cómo ha de ser un programa que use libuv, como por ejemplo nodejs.

#include <stdio.h>
#include <stdlib.h>
#include <uv.h>

int main() {
    uv_loop_t *loop = malloc(sizeof(uv_loop_t));
    uv_loop_init(loop);

    printf("Now quitting.\n");
    uv_run(loop, UV_RUN_DEFAULT); // Node usa el loop por defecto.

    uv_loop_close(loop);
    free(loop);
    return 0;
}

Node usa como en el ejemplo el loop por defecto. Si queremos tener una referencia a él en cualquier momento, podemos usar la función uv_default_loop().

La forma de trabajar con libuv es diciéndole al programa que tenemos interés en ciertos eventos mediante observadores (watchers). Estos están definidos en el código, se pueden ver aquí. Estos observadores o manejadores se setean en el bucle mediante:

uv_TYPE_init(uv_loop_t *, uv_TYPE_t *)

donde el primer parámetro es el bucle en el que queremos registrar nuestro manejador, y el segundo es el evento que queremos que dispare nuestro callback. Un ejemplo concreto (y comentado) se ve a continuación, en el que se usa un handle de un evento idle, los cuales se llaman en cada iteración del bucle.

#include <stdio.h>
#include <uv.h>

int64_t counter = 0;

void wait_for_a_while(uv_idle_t* handle) {
  if (++counter >= 10e6)
    // Al llamar a esta función se cierra el manejador del evento y el loop
    // deja de tener ningún observador registrado por lo que finaliza.
    uv_idle_stop(handle);
}

int main() {
  // Inicializamos un tipo de evento idle
  // typedef struct uv_idle_s uv_idle_t;
  uv_idle_t idler;

  // y lo conectamos al loop por defecto.
  uv_idle_init(uv_default_loop(), &idler);

  // Registramos el callback al que llamar cuando se reciba la notificación de ese evento.
  uv_idle_start(&idler, wait_for_a_while);

  printf("Idling...\n");

  // Ejecutamos el bucle, que no parará hasta que no haya más eventos registrados.
  // Como los eventos de tipo idle se llaman en cualquier iteración, hasta que no
  // se cierra con `uv_idle_stop`, el loop tendrá siempre registrado un evento y
  // no saldrá de este punto hasta que dicha función de cierre se invoque, lo cual
  // ocurre en el `callback` definido arriba.
  uv_run(uv_default_loop(), UV_RUN_DEFAULT);

  // Cerramos el bucle.
  uv_loop_close(uv_default_loop());

  return 0;
}

En función de si la llamada es síncrona o asíncrona:

• síncrona: devuelve un código numérico negativo

• asíncrona: el callback recibe un código de status

  A partir de estos valores podemos obtener el error llamando a uv_strerr(int) o a uv_err_name(int). Ambas nos devuelven un char* con la descripción o el nombre del error respectivamente.