Estoy tratando de limitar el sistema operativo (Ubuntu Server 15.04) a un cierto uso de memoria y reservar el resto pero escribir un módulo de kernel para leer/escribir en la memoria reservada. Descubrí cómo limitar el uso/memoria de reserva usando los parámetros del kernel "mem=4G memmap=4G@0 memmap=4G$4G" (4GB para OS y 4GB reservados, divididos en un punto de 4GB) pero no sé cómo DMA a memoria reservada funciona con módulos del núcleo. Estaba pensando en crear un archivo proc, pero no estoy seguro de si puede crear uno fuera de la memoria asignada del sistema operativo.
¿Alguna sugerencia? ¡Gracias!
Editar: esto es para investigación, por lo que no necesita ser "agradable"
Actualización: tal vez no necesite escribir un módulo de kernel. Acabo de encontrar esto y lo intentaré: http://elinux.org/Memory_Management#Reserving_.28and_accessing.29_the_top_of_memory_on_startup
Actualización: probé el enlace de arriba, pero fallo de segmento cada vez que intento escribir. Aquí está mi código:
#include <fcntl.h> #include <stdio.h> #include <stdlib.h> #include <sys/mann.h> #define RESERVED_MEMORY_SIZE 0x100000000 int main() { int fd; char *reserved_memory; fd = open("/dev/mem", O_RDWR | O_SYNC); reserved_memory = (char *) mmap(0, RESERVED_MEMORY_SIZE, PROT_READ | PROT_WRITE, MAP_FILE | MAP_SHARED, fd, 4096); reserved_memory[0] = 'a'; return 0; }dmesg muestra:
a.out[1167]: segfault at ffffffffffffffff ip 00000000004005d7 sp 00007ffeffccbd80 error 7 in a.out[400000+1000]Por diversión, probé la memoria reservada [1]:
a.out[1180]: segfault at 0 ip 00000000004005db sp 00007ffc388d77b0 error 6 in a.out[400000+1000]Examinaré el formato de esos mensajes para poder descifrar lo que me está diciendo.
Actualizar:
Encontré esta pregunta por alguien con el mismo problema que yo, sin embargo, la única solución parece ser una reconstrucción del kernel. Voy a tratar de evitar esto, así que tal vez mi mejor opción sea un módulo kernel personalizado nuevamente. accediendo a mmaped /dev/mem?
Ok, entonces creo que lo resolví. Resulta que simplemente no entendía cómo funciona mmap y supongo que el kernel no tiene restricciones para escribir/leer /dev/mem si está en la memoria reservada. A continuación hay dos programas que escribirán en mi lugar reservado en la memoria y leerán de él.
Escribe "¡Hola mundo!":
#include <errno.h> #include <fcntl.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/mman.h> #define RESERVED_MEMORY_OFFSET 0x100000000 /* Offset is 4GB */ int main() { int fd; char *reserved_memory; char *buffer = "Hello World!"; fd = open("/dev/mem", O_RDWR | O_SYNC): /* Returns a pointer to the 4GB point in /dev/mem - the start of my reserved memory. Only mapping 4096 bytes. */ reserved_memory = (char *) mmap(0, 4096, PROT_READ | PROT_WRITE, MAP_FILE | MAP_SHARED, fd, RESERVED_MEMORY_OFFSET); if (reserved_memory == MAP_FAILED) { printf("Failed to creating mapping.\n"); printf("ERRNO: %s\n", strerror(errno)); return -1; } sprintf(reserved_memory, "%s", buffer); return 0; }Leer desde el principio de la memoria reservada:
#include <errno.h> #include <fcntl.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/mman.h> #define RESERVED_MEMORY_OFFSET 0x100000000 /* Offset is 4GB */ int main() { int fd; char *reserved_memory; char buffer[13]; fd = open("/dev/mem", O_RDWR | O_SYNC): /* Returns a pointer to the 4GB point in /dev/mem - the start of my reserved memory. Only mapping 4096 bytes. */ reserved_memory = (char *) mmap(0, 4096, PROT_READ | PROT_WRITE, MAP_FILE | MAP_SHARED, fd, RESERVED_MEMORY_OFFSET); if (reserved_memory == MAP_FAILED) { printf("Failed to creating mapping.\n"); printf("ERRNO: %s\n", strerror(errno)); return -1; } snprintf(buffer, 13, "%s", reserved_memory); printf("%s\n", buffer); return 0; }¡Un agradecimiento especial a @knm241!