Hello Matthew,

Thank you for your response. Since at user level I am using the pread()
function, in kernel level, unless I am making a mistake, the
do_generic_file_read() is being called. Inside this, the find_get_page() is
called and if the page is not in the page cache then
page_cache_sync_readahead() is called or page_cache_async_readahead() if
the page is marked with the PG_readahead flag. So, I would like to find in
which exact part of the code can someone understand that the I/O is not
waited for.

Thank you again,

Vasilis

On Thu, Jul 13, 2017 at 7:34 PM, Matthew Wilcox <willy@infradead.org> wrote:

> On Wed, Jul 12, 2017 at 11:31:21PM +0300, Vasilis Dimitsas wrote:
> > I am currently working on a project which is related to the operation of
> > the linux readahead prefetcher. As a result, I am trying to understand
> its
> > operation. Having read thoroughly the relevant part in the kernel code, I
> > realize, from the comments, that part of the prefetching occurs
> > asynchronously. The problem is that I can not verify this from the code.
> >
> > Even if you call page_cache_sync_readahead() or
> > page_cache_async_readahead(), then both will end up in ra_submit(), in
> > which, the operation is common for both cases.
> >
> > So, please could you tell me at which point does the operation of
> > prefetching occurs asynchronously?
>
> The prefetching operation always occurs asynchronously; the
> I/O is submitted and then both page_cache_sync_readahead() and
> page_cache_async_readahead() return to the caller.  They use slightly
> different algorithms, which is why they're different functions, but the
> I/O is not waited for.  It's up to the caller to do that.
>
> I imagine you're looking at filemap_fault(), and it happens like this:
>
>         page = find_get_page(mapping, offset);
> (returns NULL because there's no page in the cache)
>                 do_sync_mmap_readahead(vmf->vma, ra, file, offset);
> (will create pages and put them in the page cache, taking PageLock on each
> page)
>                 page = find_get_page(mapping, offset);
> (finds the page that was just created)
>         if (!lock_page_or_retry(page, vmf->vma->vm_mm, vmf->flags)) {
> (will attempt to lock the page ... if it's locked and the fault lets us
> retry,
> fails so we can handle retries at the higher level.  If it's locked and the
> fault says we can't retry, then sleeps until unlocked.  If/once it's
> unlocked,
> will return success)
>
> When the I/O completes, the page will be unlocked, usually by calling
> page_endio().
>