Saltar al contenido ForoHackers

Dibujar en /dev/fb0 y mi segfault en las últimas filas

CDepuraciónLinux embebido
#1090 · ManoloSegfault · · Denunciar

En una placa con Linux embebido quería pintar directamente en el framebuffer, sin servidor gráfico. Mi código:

int fd = open("/dev/fb0", O_RDWR);
struct fb_var_screeninfo vi;
struct fb_fix_screeninfo fi;
ioctl(fd, FBIOGET_VSCREENINFO, &vi);
ioctl(fd, FBIOGET_FSCREENINFO, &fi);

size_t len = vi.xres * vi.yres * 4;            /* ¡ojo! */
uint8_t *fb = mmap(NULL, len, PROT_READ | PROT_WRITE,
                   MAP_SHARED, fd, 0);

for (unsigned y = 0; y < vi.yres; y++) {
    uint32_t *fila = (uint32_t *)(fb + y * fi.line_length);
    for (unsigned x = 0; x < vi.xres; x++)
        fila[x] = 0x00FF0000;                  /* rojo */
}

Primera versión: usaba y * vi.xres * 4 para saltar de fila y la imagen salía torcida, en diagonal. Segunda: usé line_length, que es el pitch: los bytes reales entre el principio de una fila y el de la siguiente, que puede ser mayor que xres * 4 por relleno. La imagen salió bien... y el programa moría con un segfault al llegar a las últimas filas.

Causa: seguía mapeando xres * yres * 4 bytes, pero con el relleno la pantalla ocupa line_length * yres. Las últimas filas caían fuera de lo mapeado. Arreglo: len = fi.line_length * vi.yres.

Aprendí tres cosas: el pitch manda, nunca suponer que bpp es 32 sin mirarlo en vi.bits_per_pixel, y que un segfault "solo al final" casi siempre es un tamaño mal calculado.

#1707 · ElDelPuntoYComa · · Denunciar

Un matiz sobre la aritmética: y * fi.line_length mezcla unsigned con __u32, y no hay problema, pero si algún día calculas el tamaño en int con pantallas enormes, cuidado con el desbordamiento con signo, que es comportamiento indefinido. Usa size_t para tamaños, como haces con len.

#1708 · CafecitoConKernel · · Denunciar

Y otro detalle de pitch: algunos drivers añaden relleno para alinear cada fila, y con memoria de vídeo especial puede que además convenga escribir con accesos alineados y no con memcpy byte a byte. Verifica también vi.yres_virtual y vi.yoffset si haces doble búfer.

#1709 · AlubiasConAssembler · · Denunciar

Ese rojo 0x00FF0000 me recuerda al Spectrum: allí el desorden de filas era por diseño, no por relleno. Cada época tiene su manera de hacer que bajar una línea no sea sumar un número.

#1710 · PacoElDelCronjob · · Denunciar

Zasca el de "un segfault solo al final casi siempre es un tamaño mal calculado". Va directo a la libreta de las verdades de la vida.

#1711 · ElQueCompilaEnDomingo · · Denunciar

Ejecútalo bajo gdb y mira y y la dirección de fila en el momento del fallo: verás que es una de las últimas filas y que la dirección cae justo después del final del mapeo. Y para probar sin la placa, mapea un fichero normal del tamaño correcto y compara.

#1712 · ManoloSegfault · · Denunciar

Buena idea, Domingo: probar primero con un fichero normal mapeado y luego pasar al dispositivo real. Mañana lo hago, y de paso añado una comprobación de bits_per_pixel que aborte con un mensaje claro.

Inicia sesión o únete para responder.