Contiguous physical memory from userspace

Is there a way to allocate contiguous physical memory from userspace in linux? At least few guar开发者_开发百科anteed contiguous memory pages. One huge page isn't the answer.

No. There is not. You do need to do this from Kernel space.

If you say "we need to do this from User Space" - without anything going on in kernel-space it makes little sense - because a user space program has no way of controlling or even knowing if the underlying memory is contiguous or not.

The only reason where you would need to do this - is if you were working in-conjunction with a piece of hardware, or some other low-level (i.e. Kernel) service that needed this requirement. So again, you would have to deal with it at that level.

So the answer isn't just "you can't" - but "you should never need to".

I have written such memory managers that do allow me to do this - but it was always because of some underlying issue at the kernel level, which had to be addressed at the kernel level. Generally because some other agent on the bus (PCI card, BIOS or even another computer over RDMA interface) had the physical contiguous memory requirement. Again, all of this had to be addressed in kernel space.

When you talk about "cache lines" - you don't need to worry. You can be assured that each page of your user-space memory is contiguous, and each page is much larger than a cache-line (no matter what architecture you're talking about).

Yes, if all you need is a few pages, this may indeed be possible.

The file /proc/[pid]/pagemap now allows programs to inspect the mapping of their virtual memory to physical memory.

While you cannot explicitly modify the mapping, you can just allocate a virtual page, lock it into memory via a call to mlock, record its physical address via a lookup into /proc/self/pagemap, and repeat until you just happen to get enough blocks touching eachother to create a large enough contiguous block. Then unlock and free your excess blocks.

It's hackish, clunky and potentially slow, but it's worth a try. On the other hand, there's a decently large chance that this isn't actually what you really need.

DPDK library's memory allocator uses approach @Wallacoloo described. eal_memory.c. The code is BSD licensed.

if specific device driver exports dma buffer which is physical contiguous, user space can access through dma buf apis so user task can access but not allocate directly

that is because physically contiguous constraints are not from user aplications but only from device so only device drivers should care.