LXR linux/mm/fadvise.c

   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * mm/fadvise.c
   4 *
   5 * Copyright (C) 2002, Linus Torvalds
   6 *
   7 * 11Jan2003    Andrew Morton
   8 *              Initial version.
   9 */
  10
  11#include <linux/kernel.h>
  12#include <linux/file.h>
  13#include <linux/fs.h>
  14#include <linux/mm.h>
  15#include <linux/pagemap.h>
  16#include <linux/backing-dev.h>
  17#include <linux/pagevec.h>
  18#include <linux/fadvise.h>
  19#include <linux/writeback.h>
  20#include <linux/syscalls.h>
  21#include <linux/swap.h>
  22
  23#include <asm/unistd.h>
  24
  25/*
  26 * POSIX_FADV_WILLNEED could set PG_Referenced, and POSIX_FADV_NOREUSE could
  27 * deactivate the pages and clear PG_Referenced.
  28 */
  29
  30int ksys_fadvise64_64(int fd, loff_t offset, loff_t len, int advice)
  31{
  32        struct fd f = fdget(fd);
  33        struct inode *inode;
  34        struct address_space *mapping;
  35        struct backing_dev_info *bdi;
  36        loff_t endbyte;                 /* inclusive */
  37        pgoff_t start_index;
  38        pgoff_t end_index;
  39        unsigned long nrpages;
  40        int ret = 0;
  41
  42        if (!f.file)
  43                return -EBADF;
  44
  45        inode = file_inode(f.file);
  46        if (S_ISFIFO(inode->i_mode)) {
  47                ret = -ESPIPE;
  48                goto out;
  49        }
  50
  51        mapping = f.file->f_mapping;
  52        if (!mapping || len < 0) {
  53                ret = -EINVAL;
  54                goto out;
  55        }
  56
  57        bdi = inode_to_bdi(mapping->host);
  58
  59        if (IS_DAX(inode) || (bdi == &noop_backing_dev_info)) {
  60                switch (advice) {
  61                case POSIX_FADV_NORMAL:
  62                case POSIX_FADV_RANDOM:
  63                case POSIX_FADV_SEQUENTIAL:
  64                case POSIX_FADV_WILLNEED:
  65                case POSIX_FADV_NOREUSE:
  66                case POSIX_FADV_DONTNEED:
  67                        /* no bad return value, but ignore advice */
  68                        break;
  69                default:
  70                        ret = -EINVAL;
  71                }
  72                goto out;
  73        }
  74
  75        /* Careful about overflows. Len == 0 means "as much as possible" */
  76        endbyte = offset + len;
  77        if (!len || endbyte < len)
  78                endbyte = -1;
  79        else
  80                endbyte--;              /* inclusive */
  81
  82        switch (advice) {
  83        case POSIX_FADV_NORMAL:
  84                f.file->f_ra.ra_pages = bdi->ra_pages;
  85                spin_lock(&f.file->f_lock);
  86                f.file->f_mode &= ~FMODE_RANDOM;
  87                spin_unlock(&f.file->f_lock);
  88                break;
  89        case POSIX_FADV_RANDOM:
  90                spin_lock(&f.file->f_lock);
  91                f.file->f_mode |= FMODE_RANDOM;
  92                spin_unlock(&f.file->f_lock);
  93                break;
  94        case POSIX_FADV_SEQUENTIAL:
  95                f.file->f_ra.ra_pages = bdi->ra_pages * 2;
  96                spin_lock(&f.file->f_lock);
  97                f.file->f_mode &= ~FMODE_RANDOM;
  98                spin_unlock(&f.file->f_lock);
  99                break;
 100        case POSIX_FADV_WILLNEED:
 101                /* First and last PARTIAL page! */
 102                start_index = offset >> PAGE_SHIFT;
 103                end_index = endbyte >> PAGE_SHIFT;
 104
 105                /* Careful about overflow on the "+1" */
 106                nrpages = end_index - start_index + 1;
 107                if (!nrpages)
 108                        nrpages = ~0UL;
 109
 110                /*
 111                 * Ignore return value because fadvise() shall return
 112                 * success even if filesystem can't retrieve a hint,
 113                 */
 114                force_page_cache_readahead(mapping, f.file, start_index,
 115                                           nrpages);
 116                break;
 117        case POSIX_FADV_NOREUSE:
 118                break;
 119        case POSIX_FADV_DONTNEED:
 120                if (!inode_write_congested(mapping->host))
 121                        __filemap_fdatawrite_range(mapping, offset, endbyte,
 122                                                   WB_SYNC_NONE);
 123
 124                /*
 125                 * First and last FULL page! Partial pages are deliberately
 126                 * preserved on the expectation that it is better to preserve
 127                 * needed memory than to discard unneeded memory.
 128                 */
 129                start_index = (offset+(PAGE_SIZE-1)) >> PAGE_SHIFT;
 130                end_index = (endbyte >> PAGE_SHIFT);
 131                /*
 132                 * The page at end_index will be inclusively discarded according
 133                 * by invalidate_mapping_pages(), so subtracting 1 from
 134                 * end_index means we will skip the last page.  But if endbyte
 135                 * is page aligned or is at the end of file, we should not skip
 136                 * that page - discarding the last page is safe enough.
 137                 */
 138                if ((endbyte & ~PAGE_MASK) != ~PAGE_MASK &&
 139                                endbyte != inode->i_size - 1) {
 140                        /* First page is tricky as 0 - 1 = -1, but pgoff_t
 141                         * is unsigned, so the end_index >= start_index
 142                         * check below would be true and we'll discard the whole
 143                         * file cache which is not what was asked.
 144                         */
 145                        if (end_index == 0)
 146                                break;
 147
 148                        end_index--;
 149                }
 150
 151                if (end_index >= start_index) {
 152                        unsigned long count;
 153
 154                        /*
 155                         * It's common to FADV_DONTNEED right after
 156                         * the read or write that instantiates the
 157                         * pages, in which case there will be some
 158                         * sitting on the local LRU cache. Try to
 159                         * avoid the expensive remote drain and the
 160                         * second cache tree walk below by flushing
 161                         * them out right away.
 162                         */
 163                        lru_add_drain();
 164
 165                        count = invalidate_mapping_pages(mapping,
 166                                                start_index, end_index);
 167
 168                        /*
 169                         * If fewer pages were invalidated than expected then
 170                         * it is possible that some of the pages were on
 171                         * a per-cpu pagevec for a remote CPU. Drain all
 172                         * pagevecs and try again.
 173                         */
 174                        if (count < (end_index - start_index + 1)) {
 175                                lru_add_drain_all();
 176                                invalidate_mapping_pages(mapping, start_index,
 177                                                end_index);
 178                        }
 179                }
 180                break;
 181        default:
 182                ret = -EINVAL;
 183        }
 184out:
 185        fdput(f);
 186        return ret;
 187}
 188
 189SYSCALL_DEFINE4(fadvise64_64, int, fd, loff_t, offset, loff_t, len, int, advice)
 190{
 191        return ksys_fadvise64_64(fd, offset, len, advice);
 192}
 193
 194#ifdef __ARCH_WANT_SYS_FADVISE64
 195
 196SYSCALL_DEFINE4(fadvise64, int, fd, loff_t, offset, size_t, len, int, advice)
 197{
 198        return ksys_fadvise64_64(fd, offset, len, advice);
 199}
 200
 201#endif
 202