Estoy trabajando en un proyecto que intenta buscar bytes específicos (por ejemplo, 0xAB) en un sistema de archivos (por ejemplo, ext2). Pude encontrar lo que necesitaba usando malloc() , realloc() y memchr() , pero parecía lento, así que estaba buscando usar mmap() . Lo que estoy tratando de hacer es encontrar bytes específicos, luego copiarlos en una estructura, así que tengo dos preguntas: (1) está usando mmap() como la mejor estrategia, y (2) ¿por qué no funciona el siguiente código ( Me sale error EINVAL)?
ACTUALIZACIÓN: El siguiente programa se compila y se ejecuta, pero todavía tengo un par de problemas:
1) no mostrará el tamaño de archivo correcto en archivos grandes (se muestra el tamaño correcto para una unidad flash de 1 GB, pero no para 32 GB)*.
2) no está buscando el mapeo correctamente**.
*¿Es ESTA una posible solución para obtener el tamaño correcto usando stat64() ? Si es así, ¿es algo que agrego en mi Makefile? No he trabajado mucho con makefiles, así que no sé cómo agregar algo así.
** ¿Es esta la forma correcta de buscar?
#define _LARGEFILE64_SOURCE #include <stdio.h> #include <fcntl.h> #include <stdlib.h> #include <string.h> #include <sys/stat.h> #include <sys/types.h> #include <unistd.h> #include <errno.h> #define handle_error(msg) \ do { perror(msg); exit(EXIT_FAILURE); } while (0) int main(int argc, char **argv) { int fd = open("/dev/sdb1", O_RDONLY); if(fd < 0) { printf("Error %s\n", strerror(errno)); return -1; } const char * map; off64_t size; size = lseek64(fd, 0, SEEK_END); printf("file size: %llu\n", size); lseek64(fd, 0, SEEK_SET); map = mmap(0, size, PROT_READ, MAP_SHARED, fd, 0); if (map == MAP_FAILED) { handle_error("mmap error"); } printf("Searching for magic numbers...\n"); for (i=0; i < size; i++) { if(map[i] == 0X53 && map[i + 1] == 0XEF) { if ((map[i-32] == 0X00 && map[i-31] == 0X00) || (map[i-32] == 0X01 && map[i-31] == 0X00) || (map[i-32] == 0X02 && map[i-31] == 0X00)) { if(j <= 5) { printf("superblock %d found\n", j); ++j; } else break; int q; for(q=0; q<j; q++) { printf("SUPERBLOCK[%d]: %d\n", q+1, sb_pos[q]); } fclose(fd); munmap(map, size); return 0; }Gracias por tu ayuda.
mmap es una forma muy eficiente de manejar la búsqueda de un archivo grande, especialmente en los casos en los que hay una estructura interna que puede usar (por ejemplo, usar mmap en un archivo grande con registros de tamaño fijo que están ordenados le permitiría hacer una búsqueda binaria, y sólo se tocarían las páginas correspondientes a los registros leídos).
En su caso, necesita compilar para 64 bits y habilitar la compatibilidad con archivos grandes (y usar open(2) ).
Si su /dev/sdb1 es un dispositivo y no un archivo, no creo que stat(2) muestre un tamaño real. stat devuelve un tamaño de 0 para estos dispositivos en mis cajas. Creo que tendrás que conseguir el tamaño de otra manera.
Con respecto al espacio de direcciones: x86-64 usa 2^48 bytes de espacio de direcciones virtuales, que es 256 TiB. No puede usar todo eso, pero hay fácilmente ~127 TiB de espacio de direcciones contiguas en la mayoría de los procesos.
Acabo de darme cuenta de que estaba usando fopen(), ¿debería usar open() en su lugar?
Sí, deberías usar open() en lugar de fopen(). Y esa es la razón por la que obtuviste el error EINVAL.
fopen("/dev/sdb1", O_RDONLY);
Este código es totalmente incorrecto. O_RDONLY es un indicador que debe usarse con la llamada al sistema open() pero no con la función fopen() libc
También debe tener en cuenta que el mapeo de archivos grandes solo está disponible si está ejecutando en una plataforma con un gran espacio de direcciones virtuales. Es obvio: debe tener suficiente memoria virtual para direccionar su archivo. Hablando de Intel, debería ser solo x86_64, no x86_32.
No he intentado hacer esto con archivos realmente grandes (>4G). Es posible que se requieran algunos indicadores adicionales para pasar a open() syscall.
Estoy trabajando en un proyecto que intenta buscar bytes específicos (por ejemplo, 0xAB) en un sistema de archivos (por ejemplo, ext2)
Para mmap () un archivo grande en la memoria es un enfoque totalmente incorrecto en su caso. Solo necesita procesar su archivo paso a paso por fragmentos con un tamaño fijo (alrededor de 1 MB). Puede usar mmap() o simplemente leer() en su búfer interno, eso no importa. Pero poner un archivo completo en la memoria es totalmente excesivo si solo desea procesarlo secuencialmente.