Skip to contentSkip to conversation

User space memory

DISCUSSION Christoph Seitz 3 participants 6 messages Mar 10, 2013 – Mar 13, 2013

lore
Share & tools
lore
#0 lore raw

Hi all,

I have some problems allocation Memory the right way and use it in my kernel module.

I use a char device for reading and writing from/to a pcie dma card. Especially the read function makes me some headache. The user allocates some memory with posix_memalign and call the read function on the device, so that the devices knows where to write to. My driver now uses get_user_pages() to pin the user pages. The memory has never been written or read by the user, so it's not yet in the RAM, right? And get_user_pages returns a valid number of pages, but for every page the same struct. (respectively the same pointer). Is there any way to ensure that the user pages are in the ram and get_user_pages returns a valid page array?

Regards
Chris

#1 lore raw
Quoted 5 lines · Christoph Seitz

Hi all,

I have some problems allocation Memory the right way and use it in my kernel module.

Quoted 11 lines

I use a char device for reading and writing from/to a pcie dma card. Especially the read function makes me some headache. The user allocates some memory with posix_memalign and call the read function on the device, so that the devices knows where to write to. My driver now uses get_user_pages() to pin the user pages. The memory has never been written or read by the user, so it's not yet in the RAM, right? And get_user_pages returns a valid number of pages, but for every page the same struct. (respectively the same pointer). Is there any way to ensure that the user pages are in the ram and get_user_pages returns a valid page array?

If you know the RAM physical address range you can figure out by doing the following
*page_to_pfn(page_ptr) << 12*;
where page_ptr is a struct page * returned by get_user_pages().
* page_to_pfn()* will return the pfn of the corresponding page frame and
left shifting by 12 bits will give you page frame base address.

Quoted 8 lines

Regards
Chris

_______________________________________________
Kernelnewbies mailing list
Kernelnewbies at kernelnewbies.org
http://lists.kernelnewbies.org/mailman/listinfo/kernelnewbies

Signature · 7 lines
Regards,
Prabhunath G
Linux Trainer
Bangalore
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://lists.kernelnewbies.org/pipermail/kernelnewbies/attachments/20130312/6238f3f1/attachment.html 
#2 lore raw

Am 12.03.2013 14:08, schrieb Prabhu nath:

Quoted 22 lines

On Sun, Mar 10, 2013 at 11:30 PM, Christoph Seitz <[email protected] <mailto:[email protected]>> wrote:

Hi all,

I have some problems allocation Memory the right way and use it in my kernel module.

I use a char device for reading and writing from/to a pcie dma card. Especially the read function makes me some headache. The user allocates some memory with posix_memalign and call the read function on the device, so that the devices knows where to write to. My driver now uses get_user_pages() to pin the user pages. The memory has never been written or read by the user, so it's not yet in the RAM, right? And get_user_pages returns a valid number of pages, but for every page the same struct. (respectively the same pointer). Is there any way to ensure that the user pages are in the ram and get_user_pages returns a valid page array?

Quoted 6 lines

If you know the RAM physical address range you can figure out by doing the following
*page_to_pfn(page_ptr) << 12*;
where page_ptr is a struct page * returned by get_user_pages().
*page_to_pfn()* will return the pfn of the corresponding page frame
and left shifting by 12 bits will give you page frame base address.

Maybe my description was a little bit misleading. I have the problem, that if I don't write to that allocated memory in the user application, I won't get any valid pages from get_user_pages. The reason seems to be, that thees pages never got faulted and so the user memory never gets a page frame. Is there any chance for a kernel module to force a page fault or to assign the user memory a page frame?
I found out, if I use the force flag with get_user_pages, the pages get faulted, but there has to be a nicer way than using the force flag.

Regards,
Chris

#3 lore raw
Quoted 2 lines · Christoph Seitz

I found out, if I use the force flag with get_user_pages, the pages get faulted, but there has to be a nicer way than using the force flag.

Why does there have to be a nicer way? Maybe you already got the nice way.

(Hint - why does the force flag even exist? :)
-------------- next part --------------
A non-text attachment was scrubbed...
Name: not available
Type: application/pgp-signature
Size: 865 bytes
Desc: not available
Url : http://lists.kernelnewbies.org/pipermail/kernelnewbies/attachments/20130312/5e8a95d6/attachment.bin

#4 lore raw
In reply to Prabhu nath
Quoted 14 lines · Prabhu nath
Quoted 11 lines · Christoph Seitz

I use a char device for reading and writing from/to a pcie dma card. Especially the read function makes me some headache. The user allocates some memory with posix_memalign and call the read function on the device, so that the devices knows where to write to. My driver now uses get_user_pages() to pin the user pages. The memory has never been written or read by the user, so it's not yet in the RAM, right? And get_user_pages returns a valid number of pages, but for every page the same struct. (respectively the same pointer). Is there any way to ensure that the user pages are in the ram and get_user_pages returns a valid page array?

Quoted 6 lines

If you know the RAM physical address range you can figure out by doing the following
*page_to_pfn(page_ptr) << 12*;
where page_ptr is a struct page * returned by get_user_pages().
* page_to_pfn()* will return the pfn of the corresponding page frame and
left shifting by 12 bits will give you page frame base address.

Unfortunately, that doesn't actually tell you what Christoph was worried about - is the page *currently* in RAM? For that, you need to check some bits in the pfn once you find it.

Also, note the following:

It's not always 12, because not everything uses a 4K page - consider hugepage support, or Power and Itanium where the pages are bigger and often several different sizes are supported. There's an API for the current page size. Use it. :)

Also, there's an API for pinning pages so they *stay* in RAM so you can target
them for I/O. Use that. ;)
-------------- next part --------------
A non-text attachment was scrubbed...
Name: not available
Type: application/pgp-signature
Size: 865 bytes
Desc: not available
Url : http://lists.kernelnewbies.org/pipermail/kernelnewbies/attachments/20130312/de5bbe31/attachment-0001.bin

#5 lore raw
Quoted 31 lines · On Tue, Mar 12, 2013 at 7:59 PM, <[email protected]> wrote:
Quoted 1 line · Prabhu nath

On Sun, Mar 10, 2013 at 11:30 PM, Christoph Seitz <[email protected]>

Quoted 8 lines · wrote:
Quoted 8 lines

I use a char device for reading and writing from/to a pcie dma card. Especially the read function makes me some headache. The user allocates some memory with posix_memalign and call the read function on the device, so that the devices knows where to write to. My driver now uses get_user_pages() to pin the user pages. The memory has never been written or read by the user, so it's not yet in the RAM, right? And get_user_pages returns a valid number of pages, but for every page the same struct. (respectively the same pointer). Is there any way to

ensure

Quoted 5 lines
Quoted 3 lines

that the user pages are in the ram and get_user_pages returns a valid page array?

If you know the RAM physical address range you can figure out by doing

the

Quoted 4 lines

following
*page_to_pfn(page_ptr) << 12*;
where page_ptr is a struct page * returned by get_user_pages().
* page_to_pfn()* will return the pfn of the corresponding page frame

and

Quoted 1 line

left shifting by 12 bits will give you page frame base address.

Unfortunately, that doesn't actually tell you what Christoph was worried about - is the page *currently* in RAM? For that, you need to check some bits in the pfn once you find it.

Quoted 9 lines

Also, note the following:

It's not always 12, because not everything uses a 4K page - consider hugepage
support, or Power and Itanium where the pages are bigger and often several different sizes are supported. There's an API for the current page size. Use
it. :)

Oops.. it should be page_to_pfn(page_ptr) << PAGE_SHIFT

Quoted 5 lines

Also, there's an API for pinning pages so they *stay* in RAM so you can target
them for I/O. Use that. ;)

Signature · 7 lines
Regards,
Prabhunath G
Linux Trainer
Bangalore
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://lists.kernelnewbies.org/pipermail/kernelnewbies/attachments/20130313/60b9977c/attachment.html