UNLOCK_PAGE(9) Memory Management in Linux UNLOCK_PAGE(9)NAME
unlock_page - unlock a locked page
SYNOPSIS
void unlock_page(struct page * page);
ARGUMENTS
page
the page
DESCRIPTION
Unlocks the page and wakes up sleepers in ___wait_on_page_locked. Also wakes sleepers in wait_on_page_writeback because the wakeup
mechananism between PageLocked pages and PageWriteback pages is shared. But that's OK - sleepers in wait_on_page_writeback just go back to
sleep.
The mb is necessary to enforce ordering between the clear_bit and the read of the waitqueue (to avoid SMP races with a parallel
wait_on_page_locked).
COPYRIGHT Kernel Hackers Manual 3.10 June 2014 UNLOCK_PAGE(9)
Check Out this Related Man Page
__GET_USER_PAGES(9) Memory Management in Linux __GET_USER_PAGES(9)NAME
__get_user_pages - pin user pages in memory
SYNOPSIS
long __get_user_pages(struct task_struct * tsk, struct mm_struct * mm, unsigned long start, unsigned long nr_pages, unsigned int gup_flags,
struct page ** pages, struct vm_area_struct ** vmas, int * nonblocking);
ARGUMENTS
tsk
task_struct of target task
mm
mm_struct of target mm
start
starting user address
nr_pages
number of pages from start to pin
gup_flags
flags modifying pin behaviour
pages
array that receives pointers to the pages pinned. Should be at least nr_pages long. Or NULL, if caller only intends to ensure the pages
are faulted in.
vmas
array of pointers to vmas corresponding to each page. Or NULL if the caller does not require them.
nonblocking
whether waiting for disk IO or mmap_sem contention
DESCRIPTION
Returns number of pages pinned. This may be fewer than the number requested. If nr_pages is 0 or negative, returns 0. If no pages were
pinned, returns -errno. Each page returned must be released with a put_page call when it is finished with. vmas will only remain valid
while mmap_sem is held.
Must be called with mmap_sem held for read or write.
__get_user_pages walks a process's page tables and takes a reference to each struct page that each user address corresponds to at a given
instant. That is, it takes the page that would be accessed if a user thread accesses the given user virtual address at that instant.
This does not guarantee that the page exists in the user mappings when __get_user_pages returns, and there may even be a completely
different page there in some cases (eg. if mmapped pagecache has been invalidated and subsequently re faulted). However it does guarantee
that the page won't be freed completely. And mostly callers simply care that the page contains data that was valid *at some point in time*.
Typically, an IO or similar operation cannot guarantee anything stronger anyway because locks can't be held over the syscall boundary.
If gup_flags & FOLL_WRITE == 0, the page must not be written to. If the page is written to, set_page_dirty (or set_page_dirty_lock, as
appropriate) must be called after the page is finished with, and before put_page is called.
If nonblocking != NULL, __get_user_pages will not wait for disk IO or mmap_sem contention, and if waiting is needed to pin all pages,
*nonblocking will be set to 0.
In most cases, get_user_pages or get_user_pages_fast should be used instead of __get_user_pages. __get_user_pages should be used only if
you need some special gup_flags.
COPYRIGHT Kernel Hackers Manual 3.10 June 2014 __GET_USER_PAGES(9)