How to write kernel space memory (physical address) to a file using O_DIRECT?

I want to write a physical memory to a file. The memory itself will not be touched again, thus I want to use O_DIRECT to gain the best write performance.

My first idea was to open /dev/mem and mmap the memory and write everything to a file, which is opened with O_DIRECT. The write call fails (EFAULT) on the memory-address returned by mmap. If I do not use O_DIRECT, it results in a memcpy.

#include <cstdint>
#include <iostream>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <errno.h>
#include <malloc.h>
#include <sys/mman.h>

#define PRINT_ERRNO_REASON(reason)  \
        case reason: { std::cout << #reason << std::endl; } break;

void write_page_aligned_buffer(int out_fd)
{
    const ssize_t PAGE_SIZE = getpagesize();

    void* page_aligned_buffer = memalign(PAGE_SIZE, PAGE_SIZE);
    if(!page_aligned_buffer)
    {
        std::cout << "Could not allocate page aligned buffer." << std::endl;
        return;
    }

    std::cout << "Allocated a buffer at address " << page_aligned_buffer << "." << std::endl;

    if(write(out_fd, page_aligned_buffer, PAGE_SIZE) < 0)
    {
        std::cout << "Could not write page-aligned user buffer to tmp-file. Quitting..." << std::endl;
        std::cout << "Reason of fail is ";

        switch(errno)
        {
            PRINT_ERRNO_REASON(EAGAIN);
            PRINT_ERRNO_REASON(EBADF);
            PRINT_ERRNO_REASON(EFAULT);
            PRINT_ERRNO_REASON(EFBIG);
            PRINT_ERRNO_REASON(EINTR);
            PRINT_ERRNO_REASON(EINVAL);
            PRINT_ERRNO_REASON(EIO);
            PRINT_ERRNO_REASON(ENOSPC);
            PRINT_ERRNO_REASON(EPIPE);
        default:
            std::cout << "Unknown" << std::endl;
        }
    }
    else
    {
        std::cout << "Successfully written user-page-aligned buffer." << std::endl;
    }

    free(page_aligned_buffer);
}

int main()
{
    const ssize_t PAGE_SIZE = getpagesize();

    // number of pages to copy
    const uint32_t PAGES_TO_COPY = 1;

    char* tmp_file_name = 0;
    int tmp_file_fd = -1;
    ssize_t bytes_copied = 0;

    std::cout << "Copying " << PAGES_TO_COPY << " pages with PAGE_SIZE = " << PAGE_SIZE << std::endl;
    std::cout << "Copying " << PAGES_TO_COPY * PAGE_SIZE / 1024 << " kBytes." << std::endl << std::endl;

    uid_t user_id = geteuid();
    if(user_id)
    {
        std::cout << "We need to be root. I am euid == " << user_id << ". Quitting..." << std::endl;
        return 0;
    }
    else
    {
        seteuid(0);
        setuid(0);
    }

    // get the file descriptor
    int mem_fd = open("/dev/mem", O_RDONLY);
    if(mem_fd < 0)
    {
        std::cout << "Could not open /dev/mem. Quitting..." << std::endl;
        std::cout << "Reason of fail is ";

        switch(errno)
        {
            PRINT_ERRNO_REASON(EACCES);
            PRINT_ERRNO_REASON(EEXIST);
            PRINT_ERRNO_REASON(EINTR);
            PRINT_ERRNO_REASON(EINVAL);
            PRINT_ERRNO_REASON(EIO);
            PRINT_ERRNO_REASON(EISDIR);
            PRINT_ERRNO_REASON(ELOOP);
            PRINT_ERRNO_REASON(EMFILE);
            PRINT_ERRNO_REASON(ENFILE);
            PRINT_ERRNO_REASON(ENOENT);
            PRINT_ERRNO_REASON(ENOSR);
            PRINT_ERRNO_REASON(ENOSPC);
            PRINT_ERRNO_REASON(ENOTDIR);
            PRINT_ERRNO_REASON(ENXIO);
            PRINT_ERRNO_REASON(EOVERFLOW);
            PRINT_ERRNO_REASON(EROFS);
            PRINT_ERRNO_REASON(EAGAIN);
            PRINT_ERRNO_REASON(ENAMETOOLONG);
            PRINT_ERRNO_REASON(ENOMEM);
            PRINT_ERRNO_REASON(ETXTBSY);
        default:
            std::cout << "Unknown" << std::endl;
        }
        return 0;
    }

    // get read pointer
    uint8_t* mem_ptr = static_cast<uint8_t*>(mmap(0,
            PAGE_SIZE,
            PROT_READ,
            MAP_SHARED,
            mem_fd,
            PAGE_SIZE));
    if(mem_ptr == MAP_FAILED)
    {
        std::cout << "Could not mmap /dev/mem. Quitting..." << std::endl;
        std::cout << "Reason of fail is ";

        switch(errno)
        {
            PRINT_ERRNO_REASON(EACCES);
            PRINT_ERRNO_REASON(EAGAIN);
            PRINT_ERRNO_REASON(EBADF);
            PRINT_ERRNO_REASON(EINVAL);
            PRINT_ERRNO_REASON(ENFILE);
            PRINT_ERRNO_REASON(ENODEV);
            PRINT_ERRNO_REASON(ENOMEM);
            PRINT_ERRNO_REASON(EPERM);
            PRINT_ERRNO_REASON(ETXTBSY);
        default:
            std::cout << "Unknown" << std::endl;
        }
        goto CLEANUP_FD_DEV_MEM;
    }

    tmp_file_name = tempnam("/tmp", "prefix");
    if(!tmp_file_name)
    {
        std::cout << "Could not get a free tmp-filename";
        goto CLEANUP_MMAP_DEV_MEM;
    }

    // if O_DIRECT is omitted the example will work
    tmp_file_fd = open(tmp_file_name,
            O_WRONLY | O_CREAT | O_DIRECT | O_TRUNC,
            S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
    if(tmp_file_fd < 0)
    {
        std::cout << "Could not create tmp file with O_DIRECT." << std::endl;
        goto CLEANUP_MMAP_DEV_MEM;
    }

    write_page_aligned_buffer(tmp_file_fd);

    // everything worked so lets start the copying
    for(uint i = 0; i < PAGES_TO_COPY; i++)
    {
        // check memory
        // snip
        for(int i = 0; i < PAGE_SIZE; i += 32)
        {
            printf("%02X%02X%02X%02X %02X%02X%02X%02X %02X%02X%02X%02X %02X%02X%02X%02X %02X%02X%02X%02X %02X%02X%02X%02X %02X%02X%02X%02X %02X%02X%02X%02X\n",
                    mem_ptr[i + 0], mem_ptr[i + 1], mem_ptr[i + 2], mem_ptr[i + 3],
                    mem_ptr[i + 4], mem_ptr[i + 5], mem_ptr[i + 6], mem_ptr[i + 7],
                    mem_ptr[i + 8], mem_ptr[i + 9], mem_ptr[i + 10], mem_ptr[i + 11],
                    mem_ptr[i + 12], mem_ptr[i + 13], mem_ptr[i + 14], mem_ptr[i + 15],
                    mem_ptr[i + 16], mem_ptr[i + 17], mem_ptr[i + 18], mem_ptr[i + 19],
                    mem_ptr[i + 20], mem_ptr[i + 21], mem_ptr[i + 22], mem_ptr[i + 23],
                    mem_ptr[i + 24], mem_ptr[i + 25], mem_ptr[i + 26], mem_ptr[i + 27],
                    mem_ptr[i + 28], mem_ptr[i + 29], mem_ptr[i + 30], mem_ptr[i + 31]);
        }
        std::cout << "\n";
        // endsnip

        bytes_copied = write(tmp_file_fd, mem_ptr, PAGE_SIZE);
        if(bytes_copied < 0)
        {
            std::cout << "Could not write to tmp-file. Quitting..." << std::endl;
            std::cout << "Reason of fail is ";

            switch(errno)
            {
                PRINT_ERRNO_REASON(EAGAIN);
                PRINT_ERRNO_REASON(EBADF);
                PRINT_ERRNO_REASON(EFAULT);
                PRINT_ERRNO_REASON(EFBIG);
                PRINT_ERRNO_REASON(EINTR);
                PRINT_ERRNO_REASON(EINVAL);
                PRINT_ERRNO_REASON(EIO);
                PRINT_ERRNO_REASON(ENOSPC);
                PRINT_ERRNO_REASON(EPIPE);
            default:
                std::cout << "Unknown" << std::endl;
            }
            goto CLEANUP_FD_TMP_FILE;
        }
    }

CLEANUP_FD_TMP_FILE:
    if(tmp_file_name)
    {
        if(close(tmp_file_fd))
        {
            std::cout << "Could close tmp-file " << tmp_file_name << "." << std::endl;
        }

        if(remove(tmp_file_name))
        {
            std::cout << "Could remove tmp-file " << tmp_file_name << "." << std::endl;
        }

        free(tmp_file_name);
    }

CLEANUP_MMAP_DEV_MEM:
    if(munmap(mem_ptr, PAGE_SIZE))
    {
        std::cout << "munmap failed." << std::endl;
    }

CLEANUP_FD_DEV_MEM:
    if(close(mem_fd))
    {
        std::cout << "Could not close /dev/mem filedescriptor." << std::endl;
    }

    return 0;
}

The next step would be to write a char-device or a block-device, which handles the memory-transfer. But how to bypass the copy_to_user? The target system is an embedded PowerPC architecture, with the drawback, that writing user-memory to the harddrive (using the DMA-controller) is faster than memcpy from RAM to RAM. Thus I must bypass the page-cache.

Be开发者_开发知识库st regards

Friedrich

Your problem looks a little strange. Since you are programming quite near to the hardware, you might consider using direct memory access (DMA). This might be a bit tricky, since you need to understand paging and parts of the I/O mechanism. You might want to read that:

http://www.linuxjournal.com/article/7104

(It's just mere introduction to get the idea.)

I tested tonight , if use O_DIRECT your write will be conditional.