/proc/self/pagemap 과 /dev/mem으로 physical address 접근

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/mman.h>
#include <errno.h>
#include <fcntl.h>
#include <stdint.h>
 
// ORIG_BUFFER will be placed in memory
#define ORIG_BUFFER "Hello, World!"
 
// The page frame shifted left by PAGE_SHIFT will give us the physcial address of the frame
// Note that this number is architecture dependent. For me on x86_64 with 4096 page sizes,
// it is defined as 12. If you're running something different, check the kernel source
// for what it is defined as.
#define PAGE_SHIFT 12
#define PAGEMAP_LENGTH 8
 
void* create_buffer(void);
unsigned long get_page_frame_number_of_address(void *addr);
 
int main(void) {
   // Create a buffer with some data in it
   void *buffer = create_buffer();
 
   // Get the page frame the buffer is on
   unsigned int page_frame_number = get_page_frame_number_of_address(buffer);
   printf("Page frame: 0x%x\n", page_frame_number);
 
   // Find the difference from the buffer to the page boundary
   unsigned int distance_from_page_boundary = (unsigned long)buffer % getpagesize();
 
   // Determine how far to seek into memory to find the buffer
   uint64_t offset = (page_frame_number << PAGE_SHIFT) + distance_from_page_boundary;
   printf("PAGE_SHIFT: %d\n", PAGE_SHIFT);
   printf("physical address: %lx\n", offset);
   printf("distance: %x\n", distance_from_page_boundary);
   FILE *f;
   char s[64];
   char logacalAddress[64];
   sprintf(s, "%lx", offset);
   printf("logical address: %lx\n", buffer);
   f = fopen("log.txt", "w");
   fprintf(f, s);
   fclose(f);
 
   // Clean up
   free(buffer);
   close(mem_fd);
 
   return 0;
}
 
void* create_buffer(void) {
   size_t buf_size = strlen(ORIG_BUFFER) + 1;
 
   // Allocate some memory to manipulate
   void *buffer = malloc(buf_size);
   if(buffer == NULL) {
      fprintf(stderr, "Failed to allocate memory for buffer\n");
      exit(1);
   }
 
   // Lock the page in memory
   // Do this before writing data to the buffer so that any copy-on-write
   // mechanisms will give us our own page locked in memory
   if(mlock(buffer, buf_size) == -1) {
      fprintf(stderr, "Failed to lock page in memory: %s\n", strerror(errno));
      exit(1);
   }
 
   // Add some data to the memory
   strncpy(buffer, ORIG_BUFFER, strlen(ORIG_BUFFER));
 
   return buffer;
}
 
unsigned long get_page_frame_number_of_address(void *addr) {
   // Open the pagemap file for the current process
   FILE *pagemap = fopen("/proc/self/pagemap", "rb");
 
   // Seek to the page that the buffer is on
   unsigned long offset = (unsigned long)addr / getpagesize() * PAGEMAP_LENGTH;
   if(fseek(pagemap, (unsigned long)offset, SEEK_SET) != 0) {
      fprintf(stderr, "Failed to seek pagemap to proper location\n");
      exit(1);
   }
 
   // The page frame number is in bits 0-54 so read the first 7 bytes and clear the 55th bit
   unsigned long page_frame_number = 0;
   fread(&page_frame_number, 1, PAGEMAP_LENGTH-1, pagemap);
 
   page_frame_number &= 0x7FFFFFFFFFFFFF;
 
   fclose(pagemap);
 
   return page_frame_number;
}

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#define ORIG_BUFFER "Hello, World!"
 
int main() {
    int mem_dev = open("/dev/mem", O_RDWR | O_SYNC);
 
    if(mem_dev == -1)
    {
        printf("Error\n"); // Error
    }
 
    char s[64];
    uint64_t mem_address;
    FILE *f = fopen("log.txt", "r");
    //fgets(s, sizeof(s), f);
    //printf("%s\n", s);
    fscanf(f, "%lx", &mem_address);
    //printf("%x\n", mem_addr);
    fclose(f);
 
    printf("%lx\n", mem_address);
 
 
    /*if(mem_addr == 0xa30e9010) {
        printf("true\n");
    }*/
 
    //const uint32_t mem_address = 0x10001234;
    const uint32_t  mem_size = strlen(ORIG_BUFFER) + 1;
 
    uint32_t alloc_mem_size, page_mask, page_size;
    void *mem_pointer, *virt_addr;
 
    page_size = sysconf(_SC_PAGESIZE);
    alloc_mem_size = (((mem_size / page_size) + 1) * page_size);
    page_mask = (page_size - 1);
 
    mem_pointer = mmap(NULL,
                       alloc_mem_size,
                       PROT_READ | PROT_WRITE,
                       MAP_SHARED,
                       mem_dev,
                       (mem_address & ~page_mask)
                       );
 
    if(mem_pointer == MAP_FAILED)
    {
        printf("Error2\n"); // Error
        printf("%s\n", strerror(errno)); // Error
    }
 
    virt_addr = (mem_pointer + (mem_address & page_mask));
 
    printf("%s\n", (const char *)virt_addr);
 
    munmap(mem_pointer, alloc_mem_size);
 
    close(mem_dev);
 
    return 0;
}