do_generic_file_read()函数

这个函数完成了文件读的主要流程

核心在于操作页高速缓存，如缺页，失效，预读等操作。

函数中goto语句不计其数，

static void do_generic_file_read(struct file *filp, loff_t *ppos,

       read_descriptor_t *desc, read_actor_t actor)
{
   struct address_space *mapping = filp->f_mapping;
   struct inode *inode = mapping->host;
   struct file_ra_state *ra = &filp->f_ra;
   pgoff_t index;
   pgoff_t last_index;
   pgoff_t prev_index;
   unsigned long offset;      /* offset into pagecache page */
   unsigned int prev_offset;
   int error;

   index = *ppos >> PAGE_CACHE_SHIFT;
   prev_index = ra->prev_pos >> PAGE_CACHE_SHIFT;
   prev_offset = ra->prev_pos & (PAGE_CACHE_SIZE-1);
   last_index = (*ppos + desc->count + PAGE_CACHE_SIZE-1) >> PAGE_CACHE_SHIFT;
   offset = *ppos & ~PAGE_CACHE_MASK;

   for (;;) {
       struct page *page;
       pgoff_t end_index;
       loff_t isize;
       unsigned long nr, ret;

       cond_resched();
find_page:
       page = find_get_page(mapping, index);
       if (!page) {
           page_cache_sync_readahead(mapping,
                   ra, filp,
                   index, last_index - index);
           page = find_get_page(mapping, index);
           if (unlikely(page == NULL))
               goto no_cached_page;
       }
       if (PageReadahead(page)) {
           page_cache_async_readahead(mapping,
                   ra, filp, page,
                   index, last_index - index);
       }
       if (!PageUptodate(page)) {
           if (inode->i_blkbits == PAGE_CACHE_SHIFT ||
                   !mapping->a_ops->is_partially_uptodate)
               goto page_not_up_to_date;
           if (!trylock_page(page))
               goto page_not_up_to_date;
           if (!mapping->a_ops->is_partially_uptodate(page,
                               desc, offset))
               goto page_not_up_to_date_locked;
           unlock_page(page);
       }
page_ok:
       /*
       * i_size must be checked after we know the page is Uptodate.
       *
       * Checking i_size after the check allows us to calculate
       * the correct value for "nr", which means the zero-filled
       * part of the page is not copied back to userspace (unless
       * another truncate extends the file - this is desired though).
       */

       isize = i_size_read(inode);
       end_index = (isize - 1) >> PAGE_CACHE_SHIFT;
       if (unlikely(!isize || index > end_index)) {
           page_cache_release(page);
           goto out;
       }

       /* nr is the maximum number of bytes to copy from this page */
       nr = PAGE_CACHE_SIZE;
       if (index == end_index) {
           nr = ((isize - 1) & ~PAGE_CACHE_MASK) + 1;
           if (nr <= offset) {
               page_cache_release(page);
               goto out;
           }
       }
       nr = nr - offset;

       /* If users can be writing to this page using arbitrary
       * virtual addresses, take care about potential aliasing
       * before reading the page on the kernel side.
       */
       if (mapping_writably_mapped(mapping))
           flush_dcache_page(page);

       /*
       * When a sequential read accesses a page several times,
       * only mark it as accessed the first time.
       */
       if (prev_index != index || offset != prev_offset)
           mark_page_accessed(page);
       prev_index = index;

       /*
       * Ok, we have the page, and it's up-to-date, so
       * now we can copy it to user space...
       *
       * The actor routine returns how many bytes were actually used..
       * NOTE! This may not be the same as how much of a user buffer
       * we filled up (we may be padding etc), so we can only update
       * "pos" here (the actor routine has to update the user buffer
       * pointers and the remaining count).
       */
       ret = actor(desc, page, offset, nr);
       offset += ret;
       index += offset >> PAGE_CACHE_SHIFT;
       offset &= ~PAGE_CACHE_MASK;
       prev_offset = offset;

       page_cache_release(page);
       if (ret == nr && desc->count)
           continue;
       goto out;

page_not_up_to_date:
       /* Get exclusive access to the page ... */
       error = lock_page_killable(page);
       if (unlikely(error))
           goto readpage_error;

page_not_up_to_date_locked:
       /* Did it get truncated before we got the lock? */
       if (!page->mapping) {
           unlock_page(page);
           page_cache_release(page);
           continue;
       }

       /* Did somebody else fill it already? */
       if (PageUptodate(page)) {
           unlock_page(page);
           goto page_ok;
       }

readpage:
       /* Start the actual read. The read will unlock the page. */
       error = mapping->a_ops->readpage(filp, page);

       if (unlikely(error)) {
           if (error == AOP_TRUNCATED_PAGE) {
               page_cache_release(page);
               goto find_page;
           }
           goto readpage_error;
       }

       if (!PageUptodate(page)) {
           error = lock_page_killable(page);
           if (unlikely(error))
               goto readpage_error;
           if (!PageUptodate(page)) {
               if (page->mapping == NULL) {
                   /*
                   * invalidate_inode_pages got it
                   */
                   unlock_page(page);
                   page_cache_release(page);
                   goto find_page;
               }
               unlock_page(page);
               shrink_readahead_size_eio(filp, ra);
               error = -EIO;
               goto readpage_error;
           }
           unlock_page(page);
       }

       goto page_ok;

readpage_error:
       /* UHHUH! A synchronous read error occurred. Report it */
       desc->error = error;
       page_cache_release(page);
       goto out;

no_cached_page:
       /*
       * Ok, it wasn't cached, so we need to create a new
       * page..
       */
       page = page_cache_alloc_cold(mapping);
       if (!page) {
           desc->error = -ENOMEM;
           goto out;
       }
       error = add_to_page_cache_lru(page, mapping,
                       index, GFP_KERNEL);
       if (error) {
           page_cache_release(page);
           if (error == -EEXIST)
               goto find_page;
           desc->error = error;
           goto out;
       }
       goto readpage;
   }

out:
   ra->prev_pos = prev_index;
   ra->prev_pos <<= PAGE_CACHE_SHIFT;
   ra->prev_pos |= prev_offset;

   *ppos = ((loff_t)index << PAGE_CACHE_SHIFT) + offset;
   file_accessed(filp);