3dc6c7a128dd35bfeda20ecb165a852f4b46eeaf
[linux-2.6-block.git] / mm / readahead.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * mm/readahead.c - address_space-level file readahead.
4  *
5  * Copyright (C) 2002, Linus Torvalds
6  *
7  * 09Apr2002    Andrew Morton
8  *              Initial version.
9  */
10
11 /**
12  * DOC: Readahead Overview
13  *
14  * Readahead is used to read content into the page cache before it is
15  * explicitly requested by the application.  Readahead only ever
16  * attempts to read folios that are not yet in the page cache.  If a
17  * folio is present but not up-to-date, readahead will not try to read
18  * it. In that case a simple ->read_folio() will be requested.
19  *
20  * Readahead is triggered when an application read request (whether a
21  * system call or a page fault) finds that the requested folio is not in
22  * the page cache, or that it is in the page cache and has the
23  * readahead flag set.  This flag indicates that the folio was read
24  * as part of a previous readahead request and now that it has been
25  * accessed, it is time for the next readahead.
26  *
27  * Each readahead request is partly synchronous read, and partly async
28  * readahead.  This is reflected in the struct file_ra_state which
29  * contains ->size being the total number of pages, and ->async_size
30  * which is the number of pages in the async section.  The readahead
31  * flag will be set on the first folio in this async section to trigger
32  * a subsequent readahead.  Once a series of sequential reads has been
33  * established, there should be no need for a synchronous component and
34  * all readahead request will be fully asynchronous.
35  *
36  * When either of the triggers causes a readahead, three numbers need
37  * to be determined: the start of the region to read, the size of the
38  * region, and the size of the async tail.
39  *
40  * The start of the region is simply the first page address at or after
41  * the accessed address, which is not currently populated in the page
42  * cache.  This is found with a simple search in the page cache.
43  *
44  * The size of the async tail is determined by subtracting the size that
45  * was explicitly requested from the determined request size, unless
46  * this would be less than zero - then zero is used.  NOTE THIS
47  * CALCULATION IS WRONG WHEN THE START OF THE REGION IS NOT THE ACCESSED
48  * PAGE.  ALSO THIS CALCULATION IS NOT USED CONSISTENTLY.
49  *
50  * The size of the region is normally determined from the size of the
51  * previous readahead which loaded the preceding pages.  This may be
52  * discovered from the struct file_ra_state for simple sequential reads,
53  * or from examining the state of the page cache when multiple
54  * sequential reads are interleaved.  Specifically: where the readahead
55  * was triggered by the readahead flag, the size of the previous
56  * readahead is assumed to be the number of pages from the triggering
57  * page to the start of the new readahead.  In these cases, the size of
58  * the previous readahead is scaled, often doubled, for the new
59  * readahead, though see get_next_ra_size() for details.
60  *
61  * If the size of the previous read cannot be determined, the number of
62  * preceding pages in the page cache is used to estimate the size of
63  * a previous read.  This estimate could easily be misled by random
64  * reads being coincidentally adjacent, so it is ignored unless it is
65  * larger than the current request, and it is not scaled up, unless it
66  * is at the start of file.
67  *
68  * In general readahead is accelerated at the start of the file, as
69  * reads from there are often sequential.  There are other minor
70  * adjustments to the readahead size in various special cases and these
71  * are best discovered by reading the code.
72  *
73  * The above calculation, based on the previous readahead size,
74  * determines the size of the readahead, to which any requested read
75  * size may be added.
76  *
77  * Readahead requests are sent to the filesystem using the ->readahead()
78  * address space operation, for which mpage_readahead() is a canonical
79  * implementation.  ->readahead() should normally initiate reads on all
80  * folios, but may fail to read any or all folios without causing an I/O
81  * error.  The page cache reading code will issue a ->read_folio() request
82  * for any folio which ->readahead() did not read, and only an error
83  * from this will be final.
84  *
85  * ->readahead() will generally call readahead_folio() repeatedly to get
86  * each folio from those prepared for readahead.  It may fail to read a
87  * folio by:
88  *
89  * * not calling readahead_folio() sufficiently many times, effectively
90  *   ignoring some folios, as might be appropriate if the path to
91  *   storage is congested.
92  *
93  * * failing to actually submit a read request for a given folio,
94  *   possibly due to insufficient resources, or
95  *
96  * * getting an error during subsequent processing of a request.
97  *
98  * In the last two cases, the folio should be unlocked by the filesystem
99  * to indicate that the read attempt has failed.  In the first case the
100  * folio will be unlocked by the VFS.
101  *
102  * Those folios not in the final ``async_size`` of the request should be
103  * considered to be important and ->readahead() should not fail them due
104  * to congestion or temporary resource unavailability, but should wait
105  * for necessary resources (e.g.  memory or indexing information) to
106  * become available.  Folios in the final ``async_size`` may be
107  * considered less urgent and failure to read them is more acceptable.
108  * In this case it is best to use filemap_remove_folio() to remove the
109  * folios from the page cache as is automatically done for folios that
110  * were not fetched with readahead_folio().  This will allow a
111  * subsequent synchronous readahead request to try them again.  If they
112  * are left in the page cache, then they will be read individually using
113  * ->read_folio() which may be less efficient.
114  */
115
116 #include <linux/blkdev.h>
117 #include <linux/kernel.h>
118 #include <linux/dax.h>
119 #include <linux/gfp.h>
120 #include <linux/export.h>
121 #include <linux/backing-dev.h>
122 #include <linux/task_io_accounting_ops.h>
123 #include <linux/pagemap.h>
124 #include <linux/psi.h>
125 #include <linux/syscalls.h>
126 #include <linux/file.h>
127 #include <linux/mm_inline.h>
128 #include <linux/blk-cgroup.h>
129 #include <linux/fadvise.h>
130 #include <linux/sched/mm.h>
131
132 #include "internal.h"
133
134 /*
135  * Initialise a struct file's readahead state.  Assumes that the caller has
136  * memset *ra to zero.
137  */
138 void
139 file_ra_state_init(struct file_ra_state *ra, struct address_space *mapping)
140 {
141         ra->ra_pages = inode_to_bdi(mapping->host)->ra_pages;
142         ra->prev_pos = -1;
143 }
144 EXPORT_SYMBOL_GPL(file_ra_state_init);
145
146 static void read_pages(struct readahead_control *rac)
147 {
148         const struct address_space_operations *aops = rac->mapping->a_ops;
149         struct folio *folio;
150         struct blk_plug plug;
151
152         if (!readahead_count(rac))
153                 return;
154
155         if (unlikely(rac->_workingset))
156                 psi_memstall_enter(&rac->_pflags);
157         blk_start_plug(&plug);
158
159         if (aops->readahead) {
160                 aops->readahead(rac);
161                 /*
162                  * Clean up the remaining folios.  The sizes in ->ra
163                  * may be used to size the next readahead, so make sure
164                  * they accurately reflect what happened.
165                  */
166                 while ((folio = readahead_folio(rac)) != NULL) {
167                         unsigned long nr = folio_nr_pages(folio);
168
169                         folio_get(folio);
170                         rac->ra->size -= nr;
171                         if (rac->ra->async_size >= nr) {
172                                 rac->ra->async_size -= nr;
173                                 filemap_remove_folio(folio);
174                         }
175                         folio_unlock(folio);
176                         folio_put(folio);
177                 }
178         } else {
179                 while ((folio = readahead_folio(rac)) != NULL)
180                         aops->read_folio(rac->file, folio);
181         }
182
183         blk_finish_plug(&plug);
184         if (unlikely(rac->_workingset))
185                 psi_memstall_leave(&rac->_pflags);
186         rac->_workingset = false;
187
188         BUG_ON(readahead_count(rac));
189 }
190
191 /**
192  * page_cache_ra_unbounded - Start unchecked readahead.
193  * @ractl: Readahead control.
194  * @nr_to_read: The number of pages to read.
195  * @lookahead_size: Where to start the next readahead.
196  *
197  * This function is for filesystems to call when they want to start
198  * readahead beyond a file's stated i_size.  This is almost certainly
199  * not the function you want to call.  Use page_cache_async_readahead()
200  * or page_cache_sync_readahead() instead.
201  *
202  * Context: File is referenced by caller.  Mutexes may be held by caller.
203  * May sleep, but will not reenter filesystem to reclaim memory.
204  */
205 void page_cache_ra_unbounded(struct readahead_control *ractl,
206                 unsigned long nr_to_read, unsigned long lookahead_size)
207 {
208         struct address_space *mapping = ractl->mapping;
209         unsigned long ra_folio_index, index = readahead_index(ractl);
210         gfp_t gfp_mask = readahead_gfp_mask(mapping);
211         unsigned long mark, i = 0;
212         unsigned int min_nrpages = mapping_min_folio_nrpages(mapping);
213
214         /*
215          * Partway through the readahead operation, we will have added
216          * locked pages to the page cache, but will not yet have submitted
217          * them for I/O.  Adding another page may need to allocate memory,
218          * which can trigger memory reclaim.  Telling the VM we're in
219          * the middle of a filesystem operation will cause it to not
220          * touch file-backed pages, preventing a deadlock.  Most (all?)
221          * filesystems already specify __GFP_NOFS in their mapping's
222          * gfp_mask, but let's be explicit here.
223          */
224         unsigned int nofs = memalloc_nofs_save();
225
226         filemap_invalidate_lock_shared(mapping);
227         index = mapping_align_index(mapping, index);
228
229         /*
230          * As iterator `i` is aligned to min_nrpages, round_up the
231          * difference between nr_to_read and lookahead_size to mark the
232          * index that only has lookahead or "async_region" to set the
233          * readahead flag.
234          */
235         ra_folio_index = round_up(readahead_index(ractl) + nr_to_read - lookahead_size,
236                                   min_nrpages);
237         mark = ra_folio_index - index;
238         nr_to_read += readahead_index(ractl) - index;
239         ractl->_index = index;
240
241         /*
242          * Preallocate as many pages as we will need.
243          */
244         while (i < nr_to_read) {
245                 struct folio *folio = xa_load(&mapping->i_pages, index + i);
246                 int ret;
247
248                 if (folio && !xa_is_value(folio)) {
249                         /*
250                          * Page already present?  Kick off the current batch
251                          * of contiguous pages before continuing with the
252                          * next batch.  This page may be the one we would
253                          * have intended to mark as Readahead, but we don't
254                          * have a stable reference to this page, and it's
255                          * not worth getting one just for that.
256                          */
257                         read_pages(ractl);
258                         ractl->_index += min_nrpages;
259                         i = ractl->_index + ractl->_nr_pages - index;
260                         continue;
261                 }
262
263                 folio = filemap_alloc_folio(gfp_mask,
264                                             mapping_min_folio_order(mapping));
265                 if (!folio)
266                         break;
267
268                 ret = filemap_add_folio(mapping, folio, index + i, gfp_mask);
269                 if (ret < 0) {
270                         folio_put(folio);
271                         if (ret == -ENOMEM)
272                                 break;
273                         read_pages(ractl);
274                         ractl->_index += min_nrpages;
275                         i = ractl->_index + ractl->_nr_pages - index;
276                         continue;
277                 }
278                 if (i == mark)
279                         folio_set_readahead(folio);
280                 ractl->_workingset |= folio_test_workingset(folio);
281                 ractl->_nr_pages += min_nrpages;
282                 i += min_nrpages;
283         }
284
285         /*
286          * Now start the IO.  We ignore I/O errors - if the folio is not
287          * uptodate then the caller will launch read_folio again, and
288          * will then handle the error.
289          */
290         read_pages(ractl);
291         filemap_invalidate_unlock_shared(mapping);
292         memalloc_nofs_restore(nofs);
293 }
294 EXPORT_SYMBOL_GPL(page_cache_ra_unbounded);
295
296 /*
297  * do_page_cache_ra() actually reads a chunk of disk.  It allocates
298  * the pages first, then submits them for I/O. This avoids the very bad
299  * behaviour which would occur if page allocations are causing VM writeback.
300  * We really don't want to intermingle reads and writes like that.
301  */
302 static void do_page_cache_ra(struct readahead_control *ractl,
303                 unsigned long nr_to_read, unsigned long lookahead_size)
304 {
305         struct inode *inode = ractl->mapping->host;
306         unsigned long index = readahead_index(ractl);
307         loff_t isize = i_size_read(inode);
308         pgoff_t end_index;      /* The last page we want to read */
309
310         if (isize == 0)
311                 return;
312
313         end_index = (isize - 1) >> PAGE_SHIFT;
314         if (index > end_index)
315                 return;
316         /* Don't read past the page containing the last byte of the file */
317         if (nr_to_read > end_index - index)
318                 nr_to_read = end_index - index + 1;
319
320         page_cache_ra_unbounded(ractl, nr_to_read, lookahead_size);
321 }
322
323 /*
324  * Chunk the readahead into 2 megabyte units, so that we don't pin too much
325  * memory at once.
326  */
327 void force_page_cache_ra(struct readahead_control *ractl,
328                 unsigned long nr_to_read)
329 {
330         struct address_space *mapping = ractl->mapping;
331         struct file_ra_state *ra = ractl->ra;
332         struct backing_dev_info *bdi = inode_to_bdi(mapping->host);
333         unsigned long max_pages;
334
335         if (unlikely(!mapping->a_ops->read_folio && !mapping->a_ops->readahead))
336                 return;
337
338         /*
339          * If the request exceeds the readahead window, allow the read to
340          * be up to the optimal hardware IO size
341          */
342         max_pages = max_t(unsigned long, bdi->io_pages, ra->ra_pages);
343         nr_to_read = min_t(unsigned long, nr_to_read, max_pages);
344         while (nr_to_read) {
345                 unsigned long this_chunk = (2 * 1024 * 1024) / PAGE_SIZE;
346
347                 if (this_chunk > nr_to_read)
348                         this_chunk = nr_to_read;
349                 do_page_cache_ra(ractl, this_chunk, 0);
350
351                 nr_to_read -= this_chunk;
352         }
353 }
354
355 /*
356  * Set the initial window size, round to next power of 2 and square
357  * for small size, x 4 for medium, and x 2 for large
358  * for 128k (32 page) max ra
359  * 1-2 page = 16k, 3-4 page 32k, 5-8 page = 64k, > 8 page = 128k initial
360  */
361 static unsigned long get_init_ra_size(unsigned long size, unsigned long max)
362 {
363         unsigned long newsize = roundup_pow_of_two(size);
364
365         if (newsize <= max / 32)
366                 newsize = newsize * 4;
367         else if (newsize <= max / 4)
368                 newsize = newsize * 2;
369         else
370                 newsize = max;
371
372         return newsize;
373 }
374
375 /*
376  *  Get the previous window size, ramp it up, and
377  *  return it as the new window size.
378  */
379 static unsigned long get_next_ra_size(struct file_ra_state *ra,
380                                       unsigned long max)
381 {
382         unsigned long cur = ra->size;
383
384         if (cur < max / 16)
385                 return 4 * cur;
386         if (cur <= max / 2)
387                 return 2 * cur;
388         return max;
389 }
390
391 /*
392  * On-demand readahead design.
393  *
394  * The fields in struct file_ra_state represent the most-recently-executed
395  * readahead attempt:
396  *
397  *                        |<----- async_size ---------|
398  *     |------------------- size -------------------->|
399  *     |==================#===========================|
400  *     ^start             ^page marked with PG_readahead
401  *
402  * To overlap application thinking time and disk I/O time, we do
403  * `readahead pipelining': Do not wait until the application consumed all
404  * readahead pages and stalled on the missing page at readahead_index;
405  * Instead, submit an asynchronous readahead I/O as soon as there are
406  * only async_size pages left in the readahead window. Normally async_size
407  * will be equal to size, for maximum pipelining.
408  *
409  * In interleaved sequential reads, concurrent streams on the same fd can
410  * be invalidating each other's readahead state. So we flag the new readahead
411  * page at (start+size-async_size) with PG_readahead, and use it as readahead
412  * indicator. The flag won't be set on already cached pages, to avoid the
413  * readahead-for-nothing fuss, saving pointless page cache lookups.
414  *
415  * prev_pos tracks the last visited byte in the _previous_ read request.
416  * It should be maintained by the caller, and will be used for detecting
417  * small random reads. Note that the readahead algorithm checks loosely
418  * for sequential patterns. Hence interleaved reads might be served as
419  * sequential ones.
420  *
421  * There is a special-case: if the first page which the application tries to
422  * read happens to be the first page of the file, it is assumed that a linear
423  * read is about to happen and the window is immediately set to the initial size
424  * based on I/O request size and the max_readahead.
425  *
426  * The code ramps up the readahead size aggressively at first, but slow down as
427  * it approaches max_readhead.
428  */
429
430 static inline int ra_alloc_folio(struct readahead_control *ractl, pgoff_t index,
431                 pgoff_t mark, unsigned int order, gfp_t gfp)
432 {
433         int err;
434         struct folio *folio = filemap_alloc_folio(gfp, order);
435
436         if (!folio)
437                 return -ENOMEM;
438         mark = round_down(mark, 1UL << order);
439         if (index == mark)
440                 folio_set_readahead(folio);
441         err = filemap_add_folio(ractl->mapping, folio, index, gfp);
442         if (err) {
443                 folio_put(folio);
444                 return err;
445         }
446
447         ractl->_nr_pages += 1UL << order;
448         ractl->_workingset |= folio_test_workingset(folio);
449         return 0;
450 }
451
452 void page_cache_ra_order(struct readahead_control *ractl,
453                 struct file_ra_state *ra, unsigned int new_order)
454 {
455         struct address_space *mapping = ractl->mapping;
456         pgoff_t start = readahead_index(ractl);
457         pgoff_t index = start;
458         unsigned int min_order = mapping_min_folio_order(mapping);
459         pgoff_t limit = (i_size_read(mapping->host) - 1) >> PAGE_SHIFT;
460         pgoff_t mark = index + ra->size - ra->async_size;
461         unsigned int nofs;
462         int err = 0;
463         gfp_t gfp = readahead_gfp_mask(mapping);
464         unsigned int min_ra_size = max(4, mapping_min_folio_nrpages(mapping));
465
466         /*
467          * Fallback when size < min_nrpages as each folio should be
468          * at least min_nrpages anyway.
469          */
470         if (!mapping_large_folio_support(mapping) || ra->size < min_ra_size)
471                 goto fallback;
472
473         limit = min(limit, index + ra->size - 1);
474
475         if (new_order < mapping_max_folio_order(mapping))
476                 new_order += 2;
477
478         new_order = min(mapping_max_folio_order(mapping), new_order);
479         new_order = min_t(unsigned int, new_order, ilog2(ra->size));
480         new_order = max(new_order, min_order);
481
482         /* See comment in page_cache_ra_unbounded() */
483         nofs = memalloc_nofs_save();
484         filemap_invalidate_lock_shared(mapping);
485         /*
486          * If the new_order is greater than min_order and index is
487          * already aligned to new_order, then this will be noop as index
488          * aligned to new_order should also be aligned to min_order.
489          */
490         ractl->_index = mapping_align_index(mapping, index);
491         index = readahead_index(ractl);
492
493         while (index <= limit) {
494                 unsigned int order = new_order;
495
496                 /* Align with smaller pages if needed */
497                 if (index & ((1UL << order) - 1))
498                         order = __ffs(index);
499                 /* Don't allocate pages past EOF */
500                 while (order > min_order && index + (1UL << order) - 1 > limit)
501                         order--;
502                 err = ra_alloc_folio(ractl, index, mark, order, gfp);
503                 if (err)
504                         break;
505                 index += 1UL << order;
506         }
507
508         read_pages(ractl);
509         filemap_invalidate_unlock_shared(mapping);
510         memalloc_nofs_restore(nofs);
511
512         /*
513          * If there were already pages in the page cache, then we may have
514          * left some gaps.  Let the regular readahead code take care of this
515          * situation.
516          */
517         if (!err)
518                 return;
519 fallback:
520         do_page_cache_ra(ractl, ra->size - (index - start), ra->async_size);
521 }
522
523 static unsigned long ractl_max_pages(struct readahead_control *ractl,
524                 unsigned long req_size)
525 {
526         struct backing_dev_info *bdi = inode_to_bdi(ractl->mapping->host);
527         unsigned long max_pages = ractl->ra->ra_pages;
528
529         /*
530          * If the request exceeds the readahead window, allow the read to
531          * be up to the optimal hardware IO size
532          */
533         if (req_size > max_pages && bdi->io_pages > max_pages)
534                 max_pages = min(req_size, bdi->io_pages);
535         return max_pages;
536 }
537
538 void page_cache_sync_ra(struct readahead_control *ractl,
539                 unsigned long req_count)
540 {
541         pgoff_t index = readahead_index(ractl);
542         bool do_forced_ra = ractl->file && (ractl->file->f_mode & FMODE_RANDOM);
543         struct file_ra_state *ra = ractl->ra;
544         unsigned long max_pages, contig_count;
545         pgoff_t prev_index, miss;
546
547         /*
548          * Even if readahead is disabled, issue this request as readahead
549          * as we'll need it to satisfy the requested range. The forced
550          * readahead will do the right thing and limit the read to just the
551          * requested range, which we'll set to 1 page for this case.
552          */
553         if (!ra->ra_pages || blk_cgroup_congested()) {
554                 if (!ractl->file)
555                         return;
556                 req_count = 1;
557                 do_forced_ra = true;
558         }
559
560         /* be dumb */
561         if (do_forced_ra) {
562                 force_page_cache_ra(ractl, req_count);
563                 return;
564         }
565
566         max_pages = ractl_max_pages(ractl, req_count);
567         prev_index = (unsigned long long)ra->prev_pos >> PAGE_SHIFT;
568         /*
569          * A start of file, oversized read, or sequential cache miss:
570          * trivial case: (index - prev_index) == 1
571          * unaligned reads: (index - prev_index) == 0
572          */
573         if (!index || req_count > max_pages || index - prev_index <= 1UL) {
574                 ra->start = index;
575                 ra->size = get_init_ra_size(req_count, max_pages);
576                 ra->async_size = ra->size > req_count ? ra->size - req_count :
577                                                         ra->size >> 1;
578                 goto readit;
579         }
580
581         /*
582          * Query the page cache and look for the traces(cached history pages)
583          * that a sequential stream would leave behind.
584          */
585         rcu_read_lock();
586         miss = page_cache_prev_miss(ractl->mapping, index - 1, max_pages);
587         rcu_read_unlock();
588         contig_count = index - miss - 1;
589         /*
590          * Standalone, small random read. Read as is, and do not pollute the
591          * readahead state.
592          */
593         if (contig_count <= req_count) {
594                 do_page_cache_ra(ractl, req_count, 0);
595                 return;
596         }
597         /*
598          * File cached from the beginning:
599          * it is a strong indication of long-run stream (or whole-file-read)
600          */
601         if (miss == ULONG_MAX)
602                 contig_count *= 2;
603         ra->start = index;
604         ra->size = min(contig_count + req_count, max_pages);
605         ra->async_size = 1;
606 readit:
607         ractl->_index = ra->start;
608         page_cache_ra_order(ractl, ra, 0);
609 }
610 EXPORT_SYMBOL_GPL(page_cache_sync_ra);
611
612 void page_cache_async_ra(struct readahead_control *ractl,
613                 struct folio *folio, unsigned long req_count)
614 {
615         unsigned long max_pages;
616         struct file_ra_state *ra = ractl->ra;
617         pgoff_t index = readahead_index(ractl);
618         pgoff_t expected, start;
619         unsigned int order = folio_order(folio);
620
621         /* no readahead */
622         if (!ra->ra_pages)
623                 return;
624
625         /*
626          * Same bit is used for PG_readahead and PG_reclaim.
627          */
628         if (folio_test_writeback(folio))
629                 return;
630
631         folio_clear_readahead(folio);
632
633         if (blk_cgroup_congested())
634                 return;
635
636         max_pages = ractl_max_pages(ractl, req_count);
637         /*
638          * It's the expected callback index, assume sequential access.
639          * Ramp up sizes, and push forward the readahead window.
640          */
641         expected = round_down(ra->start + ra->size - ra->async_size,
642                         1UL << order);
643         if (index == expected) {
644                 ra->start += ra->size;
645                 ra->size = get_next_ra_size(ra, max_pages);
646                 ra->async_size = ra->size;
647                 goto readit;
648         }
649
650         /*
651          * Hit a marked folio without valid readahead state.
652          * E.g. interleaved reads.
653          * Query the pagecache for async_size, which normally equals to
654          * readahead size. Ramp it up and use it as the new readahead size.
655          */
656         rcu_read_lock();
657         start = page_cache_next_miss(ractl->mapping, index + 1, max_pages);
658         rcu_read_unlock();
659
660         if (!start || start - index > max_pages)
661                 return;
662
663         ra->start = start;
664         ra->size = start - index;       /* old async_size */
665         ra->size += req_count;
666         ra->size = get_next_ra_size(ra, max_pages);
667         ra->async_size = ra->size;
668 readit:
669         ractl->_index = ra->start;
670         page_cache_ra_order(ractl, ra, order);
671 }
672 EXPORT_SYMBOL_GPL(page_cache_async_ra);
673
674 ssize_t ksys_readahead(int fd, loff_t offset, size_t count)
675 {
676         ssize_t ret;
677         struct fd f;
678
679         ret = -EBADF;
680         f = fdget(fd);
681         if (!fd_file(f) || !(fd_file(f)->f_mode & FMODE_READ))
682                 goto out;
683
684         /*
685          * The readahead() syscall is intended to run only on files
686          * that can execute readahead. If readahead is not possible
687          * on this file, then we must return -EINVAL.
688          */
689         ret = -EINVAL;
690         if (!fd_file(f)->f_mapping || !fd_file(f)->f_mapping->a_ops ||
691             (!S_ISREG(file_inode(fd_file(f))->i_mode) &&
692             !S_ISBLK(file_inode(fd_file(f))->i_mode)))
693                 goto out;
694
695         ret = vfs_fadvise(fd_file(f), offset, count, POSIX_FADV_WILLNEED);
696 out:
697         fdput(f);
698         return ret;
699 }
700
701 SYSCALL_DEFINE3(readahead, int, fd, loff_t, offset, size_t, count)
702 {
703         return ksys_readahead(fd, offset, count);
704 }
705
706 #if defined(CONFIG_COMPAT) && defined(__ARCH_WANT_COMPAT_READAHEAD)
707 COMPAT_SYSCALL_DEFINE4(readahead, int, fd, compat_arg_u64_dual(offset), size_t, count)
708 {
709         return ksys_readahead(fd, compat_arg_u64_glue(offset), count);
710 }
711 #endif
712
713 /**
714  * readahead_expand - Expand a readahead request
715  * @ractl: The request to be expanded
716  * @new_start: The revised start
717  * @new_len: The revised size of the request
718  *
719  * Attempt to expand a readahead request outwards from the current size to the
720  * specified size by inserting locked pages before and after the current window
721  * to increase the size to the new window.  This may involve the insertion of
722  * THPs, in which case the window may get expanded even beyond what was
723  * requested.
724  *
725  * The algorithm will stop if it encounters a conflicting page already in the
726  * pagecache and leave a smaller expansion than requested.
727  *
728  * The caller must check for this by examining the revised @ractl object for a
729  * different expansion than was requested.
730  */
731 void readahead_expand(struct readahead_control *ractl,
732                       loff_t new_start, size_t new_len)
733 {
734         struct address_space *mapping = ractl->mapping;
735         struct file_ra_state *ra = ractl->ra;
736         pgoff_t new_index, new_nr_pages;
737         gfp_t gfp_mask = readahead_gfp_mask(mapping);
738         unsigned long min_nrpages = mapping_min_folio_nrpages(mapping);
739         unsigned int min_order = mapping_min_folio_order(mapping);
740
741         new_index = new_start / PAGE_SIZE;
742         /*
743          * Readahead code should have aligned the ractl->_index to
744          * min_nrpages before calling readahead aops.
745          */
746         VM_BUG_ON(!IS_ALIGNED(ractl->_index, min_nrpages));
747
748         /* Expand the leading edge downwards */
749         while (ractl->_index > new_index) {
750                 unsigned long index = ractl->_index - 1;
751                 struct folio *folio = xa_load(&mapping->i_pages, index);
752
753                 if (folio && !xa_is_value(folio))
754                         return; /* Folio apparently present */
755
756                 folio = filemap_alloc_folio(gfp_mask, min_order);
757                 if (!folio)
758                         return;
759
760                 index = mapping_align_index(mapping, index);
761                 if (filemap_add_folio(mapping, folio, index, gfp_mask) < 0) {
762                         folio_put(folio);
763                         return;
764                 }
765                 if (unlikely(folio_test_workingset(folio)) &&
766                                 !ractl->_workingset) {
767                         ractl->_workingset = true;
768                         psi_memstall_enter(&ractl->_pflags);
769                 }
770                 ractl->_nr_pages += min_nrpages;
771                 ractl->_index = folio->index;
772         }
773
774         new_len += new_start - readahead_pos(ractl);
775         new_nr_pages = DIV_ROUND_UP(new_len, PAGE_SIZE);
776
777         /* Expand the trailing edge upwards */
778         while (ractl->_nr_pages < new_nr_pages) {
779                 unsigned long index = ractl->_index + ractl->_nr_pages;
780                 struct folio *folio = xa_load(&mapping->i_pages, index);
781
782                 if (folio && !xa_is_value(folio))
783                         return; /* Folio apparently present */
784
785                 folio = filemap_alloc_folio(gfp_mask, min_order);
786                 if (!folio)
787                         return;
788
789                 index = mapping_align_index(mapping, index);
790                 if (filemap_add_folio(mapping, folio, index, gfp_mask) < 0) {
791                         folio_put(folio);
792                         return;
793                 }
794                 if (unlikely(folio_test_workingset(folio)) &&
795                                 !ractl->_workingset) {
796                         ractl->_workingset = true;
797                         psi_memstall_enter(&ractl->_pflags);
798                 }
799                 ractl->_nr_pages += min_nrpages;
800                 if (ra) {
801                         ra->size += min_nrpages;
802                         ra->async_size += min_nrpages;
803                 }
804         }
805 }
806 EXPORT_SYMBOL(readahead_expand);