I'm using VMAP function to create memory writable mapping as it suggested
in ksplice project. Here is the implementation of map_writable function:

/*
 * map_writable creates a shadow page mapping of the range
 * [addr, addr + len) so that we can write to code mapped read-only.
 *
 * It is similar to a generalized version of x86's text_poke.  But
 * because one cannot use vmalloc/vfree() inside stop_machine, we use
 * map_writable to map the pages before stop_machine, then use the
 * mapping inside stop_machine, and unmap the pages afterwards.
 */
static void *map_writable(void *addr, size_t len)
{
        void *vaddr;
        int nr_pages = DIV_ROUND_UP(offset_in_page(addr) + len, PAGE_SIZE);
        struct page **pages = kmalloc(nr_pages * sizeof(*pages),
GFP_KERNEL);
        void *page_addr = (void *)((unsigned long)addr & PAGE_MASK);
        int i;

        if (pages == NULL)
                return NULL;

        for (i = 0; i < nr_pages; i++) {
                if (__module_address((unsigned long)page_addr) == NULL) {
                        pages[i] = virt_to_page(page_addr);
                        WARN_ON(!PageReserved(pages[i]));
                } else {
                        pages[i] = vmalloc_to_page(page_addr);
                }
                if (pages[i] == NULL) {
                        kfree(pages);
                        return NULL;
                }
                page_addr += PAGE_SIZE;
        }
        vaddr = vmap(pages, nr_pages, VM_MAP, PAGE_KERNEL);
        kfree(pages);
        if (vaddr == NULL)
                return NULL;
        return vaddr + offset_in_page(addr);
}

This function works well when I used it to map kernel's text addresses. All
fine and I can rewrite read-only data well via the mapping.

Now, I need to modify kernel module's text. Given the symbol address inside
the module, I use the same method. The mapping I've got seems to be valid.
But all my changes visible only in that mapping and not in the module!

I suppose that in case of module mapping I get something like copy-on-write
but I can't prove it.

Can anyone explain me what's happend and why I can use it for mapping
kernel and can't for modules?

http://stackoverflow.com/questions/20658357/virtual-mapping-of-kernel-and-module-pages