Allocate swappable memory in linux kernel

Question

Memory in the Linux kernel is usually unswappable (Do Kernel pages get swapped out?). However, sometimes it is useful to allow memory to be swapped out. Is it possible to explicitly allocate swappable memory inside the Linux kernel? One method I thought of was to create a user space process and use its memory. Is there anything better?

you will have to explain your use casea – Jul 14 '17 at 22:55 — , Jul 14 '17 at 22:55

score 2 · Accepted Answer · answered Jul 14 '17 at 23:04

You can create a file in the internal shm shared memory filesystem.

const char *name = "example";
loff_t size = PAGE_SIZE;
unsigned long flags = 0;
struct file *filp = shmem_file_setup(name, size, flags);
/* assert(!IS_ERR(filp)); */

The file isn't actually linked, so the name isn't visible. The flags may include VM_NORESERVE to skip accounting up-front, instead accounting as pages are allocated. Now you have a shmem file. You can map a page like so:

struct address_space *mapping = filp->f_mapping;
pgoff_t index = 0;
struct page *p = shmem_read_mapping_page(mapping, index);
/* assert(!IS_ERR(filp)); */
void *data = page_to_virt(p);
memset(data, 0, PAGE_SIZE);

There is also shmem_read_mapping_page_gfp(..., gfp_t) to specify how the page is allocated. Don't forget to put the page back when you're done with it.

put_page(p);

Ditto with the file.

fput(filp);

using page_to_virt here happens to work on archs with the direct map, but is completely unjustified. the thing to do is kmap_atomic. more importantly though the real question is what OP wants this for. — , Jul 15 '17 at 05:58

score 0 · Answer 2 · answered Feb 08 '19 at 01:01

Answer to your question is a simple No, or Yes with a complex modification to kernel source.

First, to enable swapping out, you have to ask yourself what is happening when kswapd is swapping out. Essentially it will walk through all the processes and make a decision whether its memory can be swapped out or not. And all these memory have the hardware mode of ring 3. So SMAP essentially forbid it from being read as data or executed as program in the kernel (ring 0):

https://en.wikipedia.org/wiki/Supervisor_Mode_Access_Prevention

And check your distros "CONFIG_X86_SMAP", for mine Ubuntu it is default to "y" which is the case for past few years.

But if you keep your memory as a kernel address (ring 0), then you may need to consider changing the kswapd operation to trigger swapout of kernel addresses. Whick kernel addresses to walk first? And what if the address is part of the kswapd's kernel operation? The complexities involved is huge.

And next is to consider the swap in operation: When the memory read is attempted and it's "not present" bit is enabled, then hardware exception will trigger linux kernel memory fault handler (which is __do_page_fault()).

And looking into __do_page_fault:

https://elixir.bootlin.com/linux/latest/source/arch/x86/mm/fault.c#L1477

and there after how it handler the kernel addresses (do_kern_address_fault()):

https://elixir.bootlin.com/linux/latest/source/arch/x86/mm/fault.c#L1174

which essentially is just reporting as error for possible scenario. If you want to enable kernel address pagefaulting, then this path has to be modified.

And note too that the SMAP check (inside smap_violation) is done in the user address pagefaulting (do_usr_addr_fault()).

Allocate swappable memory in linux kernel

2 Answers2