LCOV - code coverage report
Current view: top level - mm - shmem.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 705 1661 42.4 %
Date: 2022-04-01 13:59:58 Functions: 51 98 52.0 %
Branches: 244 889 27.4 %

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  * Resizable virtual memory filesystem for Linux.
       3                 :            :  *
       4                 :            :  * Copyright (C) 2000 Linus Torvalds.
       5                 :            :  *               2000 Transmeta Corp.
       6                 :            :  *               2000-2001 Christoph Rohland
       7                 :            :  *               2000-2001 SAP AG
       8                 :            :  *               2002 Red Hat Inc.
       9                 :            :  * Copyright (C) 2002-2011 Hugh Dickins.
      10                 :            :  * Copyright (C) 2011 Google Inc.
      11                 :            :  * Copyright (C) 2002-2005 VERITAS Software Corporation.
      12                 :            :  * Copyright (C) 2004 Andi Kleen, SuSE Labs
      13                 :            :  *
      14                 :            :  * Extended attribute support for tmpfs:
      15                 :            :  * Copyright (c) 2004, Luke Kenneth Casson Leighton <lkcl@lkcl.net>
      16                 :            :  * Copyright (c) 2004 Red Hat, Inc., James Morris <jmorris@redhat.com>
      17                 :            :  *
      18                 :            :  * tiny-shmem:
      19                 :            :  * Copyright (c) 2004, 2008 Matt Mackall <mpm@selenic.com>
      20                 :            :  *
      21                 :            :  * This file is released under the GPL.
      22                 :            :  */
      23                 :            : 
      24                 :            : #include <linux/fs.h>
      25                 :            : #include <linux/init.h>
      26                 :            : #include <linux/vfs.h>
      27                 :            : #include <linux/mount.h>
      28                 :            : #include <linux/ramfs.h>
      29                 :            : #include <linux/pagemap.h>
      30                 :            : #include <linux/file.h>
      31                 :            : #include <linux/mm.h>
      32                 :            : #include <linux/random.h>
      33                 :            : #include <linux/sched/signal.h>
      34                 :            : #include <linux/export.h>
      35                 :            : #include <linux/swap.h>
      36                 :            : #include <linux/uio.h>
      37                 :            : #include <linux/khugepaged.h>
      38                 :            : #include <linux/hugetlb.h>
      39                 :            : #include <linux/frontswap.h>
      40                 :            : #include <linux/fs_parser.h>
      41                 :            : 
      42                 :            : #include <asm/tlbflush.h> /* for arch/microblaze update_mmu_cache() */
      43                 :            : 
      44                 :            : static struct vfsmount *shm_mnt;
      45                 :            : 
      46                 :            : #ifdef CONFIG_SHMEM
      47                 :            : /*
      48                 :            :  * This virtual memory filesystem is heavily based on the ramfs. It
      49                 :            :  * extends ramfs by the ability to use swap and honor resource limits
      50                 :            :  * which makes it a completely usable filesystem.
      51                 :            :  */
      52                 :            : 
      53                 :            : #include <linux/xattr.h>
      54                 :            : #include <linux/exportfs.h>
      55                 :            : #include <linux/posix_acl.h>
      56                 :            : #include <linux/posix_acl_xattr.h>
      57                 :            : #include <linux/mman.h>
      58                 :            : #include <linux/string.h>
      59                 :            : #include <linux/slab.h>
      60                 :            : #include <linux/backing-dev.h>
      61                 :            : #include <linux/shmem_fs.h>
      62                 :            : #include <linux/writeback.h>
      63                 :            : #include <linux/blkdev.h>
      64                 :            : #include <linux/pagevec.h>
      65                 :            : #include <linux/percpu_counter.h>
      66                 :            : #include <linux/falloc.h>
      67                 :            : #include <linux/splice.h>
      68                 :            : #include <linux/security.h>
      69                 :            : #include <linux/swapops.h>
      70                 :            : #include <linux/mempolicy.h>
      71                 :            : #include <linux/namei.h>
      72                 :            : #include <linux/ctype.h>
      73                 :            : #include <linux/migrate.h>
      74                 :            : #include <linux/highmem.h>
      75                 :            : #include <linux/seq_file.h>
      76                 :            : #include <linux/magic.h>
      77                 :            : #include <linux/syscalls.h>
      78                 :            : #include <linux/fcntl.h>
      79                 :            : #include <uapi/linux/memfd.h>
      80                 :            : #include <linux/userfaultfd_k.h>
      81                 :            : #include <linux/rmap.h>
      82                 :            : #include <linux/uuid.h>
      83                 :            : 
      84                 :            : #include <linux/uaccess.h>
      85                 :            : #include <asm/pgtable.h>
      86                 :            : 
      87                 :            : #include "internal.h"
      88                 :            : 
      89                 :            : #define BLOCKS_PER_PAGE  (PAGE_SIZE/512)
      90                 :            : #define VM_ACCT(size)    (PAGE_ALIGN(size) >> PAGE_SHIFT)
      91                 :            : 
      92                 :            : /* Pretend that each entry is of this size in directory's i_size */
      93                 :            : #define BOGO_DIRENT_SIZE 20
      94                 :            : 
      95                 :            : /* Symlink up to this size is kmalloc'ed instead of using a swappable page */
      96                 :            : #define SHORT_SYMLINK_LEN 128
      97                 :            : 
      98                 :            : /*
      99                 :            :  * shmem_fallocate communicates with shmem_fault or shmem_writepage via
     100                 :            :  * inode->i_private (with i_mutex making sure that it has only one user at
     101                 :            :  * a time): we would prefer not to enlarge the shmem inode just for that.
     102                 :            :  */
     103                 :            : struct shmem_falloc {
     104                 :            :         wait_queue_head_t *waitq; /* faults into hole wait for punch to end */
     105                 :            :         pgoff_t start;          /* start of range currently being fallocated */
     106                 :            :         pgoff_t next;           /* the next page offset to be fallocated */
     107                 :            :         pgoff_t nr_falloced;    /* how many new pages have been fallocated */
     108                 :            :         pgoff_t nr_unswapped;   /* how often writepage refused to swap out */
     109                 :            : };
     110                 :            : 
     111                 :            : struct shmem_options {
     112                 :            :         unsigned long long blocks;
     113                 :            :         unsigned long long inodes;
     114                 :            :         struct mempolicy *mpol;
     115                 :            :         kuid_t uid;
     116                 :            :         kgid_t gid;
     117                 :            :         umode_t mode;
     118                 :            :         int huge;
     119                 :            :         int seen;
     120                 :            : #define SHMEM_SEEN_BLOCKS 1
     121                 :            : #define SHMEM_SEEN_INODES 2
     122                 :            : #define SHMEM_SEEN_HUGE 4
     123                 :            : };
     124                 :            : 
     125                 :            : #ifdef CONFIG_TMPFS
     126                 :      65910 : static unsigned long shmem_default_max_blocks(void)
     127                 :            : {
     128                 :     131820 :         return totalram_pages() / 2;
     129                 :            : }
     130                 :            : 
     131                 :      65988 : static unsigned long shmem_default_max_inodes(void)
     132                 :            : {
     133                 :      65988 :         unsigned long nr_pages = totalram_pages();
     134                 :            : 
     135         [ +  + ]:      65988 :         return min(nr_pages - totalhigh_pages(), nr_pages / 2);
     136                 :            : }
     137                 :            : #endif
     138                 :            : 
     139                 :            : static bool shmem_should_replace_page(struct page *page, gfp_t gfp);
     140                 :            : static int shmem_replace_page(struct page **pagep, gfp_t gfp,
     141                 :            :                                 struct shmem_inode_info *info, pgoff_t index);
     142                 :            : static int shmem_swapin_page(struct inode *inode, pgoff_t index,
     143                 :            :                              struct page **pagep, enum sgp_type sgp,
     144                 :            :                              gfp_t gfp, struct vm_area_struct *vma,
     145                 :            :                              vm_fault_t *fault_type);
     146                 :            : static int shmem_getpage_gfp(struct inode *inode, pgoff_t index,
     147                 :            :                 struct page **pagep, enum sgp_type sgp,
     148                 :            :                 gfp_t gfp, struct vm_area_struct *vma,
     149                 :            :                 struct vm_fault *vmf, vm_fault_t *fault_type);
     150                 :            : 
     151                 :     110073 : int shmem_getpage(struct inode *inode, pgoff_t index,
     152                 :            :                 struct page **pagep, enum sgp_type sgp)
     153                 :            : {
     154                 :          0 :         return shmem_getpage_gfp(inode, index, pagep, sgp,
     155                 :            :                 mapping_gfp_mask(inode->i_mapping), NULL, NULL, NULL);
     156                 :            : }
     157                 :            : 
     158                 :     400950 : static inline struct shmem_sb_info *SHMEM_SB(struct super_block *sb)
     159                 :            : {
     160                 :     400950 :         return sb->s_fs_info;
     161                 :            : }
     162                 :            : 
     163                 :            : /*
     164                 :            :  * shmem_file_setup pre-accounts the whole fixed size of a VM object,
     165                 :            :  * for shared memory and for shared anonymous (/dev/zero) mappings
     166                 :            :  * (unless MAP_NORESERVE and sysctl_overcommit_memory <= 1),
     167                 :            :  * consistent with the pre-accounting of private mappings ...
     168                 :            :  */
     169                 :          0 : static inline int shmem_acct_size(unsigned long flags, loff_t size)
     170                 :            : {
     171                 :          0 :         return (flags & VM_NORESERVE) ?
     172                 :          0 :                 0 : security_vm_enough_memory_mm(current->mm, VM_ACCT(size));
     173                 :            : }
     174                 :            : 
     175                 :       8273 : static inline void shmem_unacct_size(unsigned long flags, loff_t size)
     176                 :            : {
     177         [ -  + ]:       8273 :         if (!(flags & VM_NORESERVE))
     178                 :          0 :                 vm_unacct_memory(VM_ACCT(size));
     179                 :       8273 : }
     180                 :            : 
     181                 :         78 : static inline int shmem_reacct_size(unsigned long flags,
     182                 :            :                 loff_t oldsize, loff_t newsize)
     183                 :            : {
     184         [ -  + ]:         78 :         if (!(flags & VM_NORESERVE)) {
     185         [ #  # ]:          0 :                 if (VM_ACCT(newsize) > VM_ACCT(oldsize))
     186                 :          0 :                         return security_vm_enough_memory_mm(current->mm,
     187                 :          0 :                                         VM_ACCT(newsize) - VM_ACCT(oldsize));
     188         [ #  # ]:          0 :                 else if (VM_ACCT(newsize) < VM_ACCT(oldsize))
     189                 :          0 :                         vm_unacct_memory(VM_ACCT(oldsize) - VM_ACCT(newsize));
     190                 :            :         }
     191                 :            :         return 0;
     192                 :            : }
     193                 :            : 
     194                 :            : /*
     195                 :            :  * ... whereas tmpfs objects are accounted incrementally as
     196                 :            :  * pages are allocated, in order to allow large sparse files.
     197                 :            :  * shmem_getpage reports shmem_acct_block failure as -ENOSPC not -ENOMEM,
     198                 :            :  * so that a failure on a sparse tmpfs mapping will give SIGBUS not OOM.
     199                 :            :  */
     200                 :     102636 : static inline int shmem_acct_block(unsigned long flags, long pages)
     201                 :            : {
     202                 :     102636 :         if (!(flags & VM_NORESERVE))
     203                 :            :                 return 0;
     204                 :            : 
     205                 :     102636 :         return security_vm_enough_memory_mm(current->mm,
     206                 :            :                         pages * VM_ACCT(PAGE_SIZE));
     207                 :            : }
     208                 :            : 
     209                 :       2685 : static inline void shmem_unacct_blocks(unsigned long flags, long pages)
     210                 :            : {
     211                 :       2685 :         if (flags & VM_NORESERVE)
     212                 :       2685 :                 vm_unacct_memory(pages * VM_ACCT(PAGE_SIZE));
     213                 :            : }
     214                 :            : 
     215                 :     102636 : static inline bool shmem_inode_acct_block(struct inode *inode, long pages)
     216                 :            : {
     217         [ +  - ]:     102636 :         struct shmem_inode_info *info = SHMEM_I(inode);
     218                 :     102636 :         struct shmem_sb_info *sbinfo = SHMEM_SB(inode->i_sb);
     219                 :            : 
     220   [ +  -  +  - ]:     205272 :         if (shmem_acct_block(info->flags, pages))
     221                 :            :                 return false;
     222                 :            : 
     223         [ +  - ]:     102636 :         if (sbinfo->max_blocks) {
     224         [ -  + ]:     102636 :                 if (percpu_counter_compare(&sbinfo->used_blocks,
     225                 :     102636 :                                            sbinfo->max_blocks - pages) > 0)
     226                 :          0 :                         goto unacct;
     227                 :     102636 :                 percpu_counter_add(&sbinfo->used_blocks, pages);
     228                 :            :         }
     229                 :            : 
     230                 :            :         return true;
     231                 :            : 
     232                 :            : unacct:
     233         [ #  # ]:          0 :         shmem_unacct_blocks(info->flags, pages);
     234                 :            :         return false;
     235                 :            : }
     236                 :            : 
     237                 :       2685 : static inline void shmem_inode_unacct_blocks(struct inode *inode, long pages)
     238                 :            : {
     239         [ +  - ]:       2685 :         struct shmem_inode_info *info = SHMEM_I(inode);
     240                 :       2685 :         struct shmem_sb_info *sbinfo = SHMEM_SB(inode->i_sb);
     241                 :            : 
     242         [ +  - ]:       2685 :         if (sbinfo->max_blocks)
     243                 :       2685 :                 percpu_counter_sub(&sbinfo->used_blocks, pages);
     244         [ +  - ]:       2685 :         shmem_unacct_blocks(info->flags, pages);
     245                 :       2685 : }
     246                 :            : 
     247                 :            : static const struct super_operations shmem_ops;
     248                 :            : static const struct address_space_operations shmem_aops;
     249                 :            : static const struct file_operations shmem_file_operations;
     250                 :            : static const struct inode_operations shmem_inode_operations;
     251                 :            : static const struct inode_operations shmem_dir_inode_operations;
     252                 :            : static const struct inode_operations shmem_special_inode_operations;
     253                 :            : static const struct vm_operations_struct shmem_vm_ops;
     254                 :            : static struct file_system_type shmem_fs_type;
     255                 :            : 
     256                 :          0 : bool vma_is_shmem(struct vm_area_struct *vma)
     257                 :            : {
     258                 :          0 :         return vma->vm_ops == &shmem_vm_ops;
     259                 :            : }
     260                 :            : 
     261                 :            : static LIST_HEAD(shmem_swaplist);
     262                 :            : static DEFINE_MUTEX(shmem_swaplist_mutex);
     263                 :            : 
     264                 :      59351 : static int shmem_reserve_inode(struct super_block *sb)
     265                 :            : {
     266                 :      59351 :         struct shmem_sb_info *sbinfo = SHMEM_SB(sb);
     267         [ +  + ]:      59351 :         if (sbinfo->max_inodes) {
     268                 :      59273 :                 spin_lock(&sbinfo->stat_lock);
     269         [ -  + ]:      59273 :                 if (!sbinfo->free_inodes) {
     270                 :          0 :                         spin_unlock(&sbinfo->stat_lock);
     271                 :          0 :                         return -ENOSPC;
     272                 :            :                 }
     273                 :      59273 :                 sbinfo->free_inodes--;
     274                 :      59273 :                 spin_unlock(&sbinfo->stat_lock);
     275                 :            :         }
     276                 :            :         return 0;
     277                 :            : }
     278                 :            : 
     279                 :       8507 : static void shmem_free_inode(struct super_block *sb)
     280                 :            : {
     281                 :       8507 :         struct shmem_sb_info *sbinfo = SHMEM_SB(sb);
     282         [ +  - ]:       8507 :         if (sbinfo->max_inodes) {
     283                 :       8507 :                 spin_lock(&sbinfo->stat_lock);
     284                 :       8507 :                 sbinfo->free_inodes++;
     285                 :       8507 :                 spin_unlock(&sbinfo->stat_lock);
     286                 :            :         }
     287                 :       8507 : }
     288                 :            : 
     289                 :            : /**
     290                 :            :  * shmem_recalc_inode - recalculate the block usage of an inode
     291                 :            :  * @inode: inode to recalc
     292                 :            :  *
     293                 :            :  * We have to calculate the free blocks since the mm can drop
     294                 :            :  * undirtied hole pages behind our back.
     295                 :            :  *
     296                 :            :  * But normally   info->alloced == inode->i_mapping->nrpages + info->swapped
     297                 :            :  * So mm freed is info->alloced - (inode->i_mapping->nrpages + info->swapped)
     298                 :            :  *
     299                 :            :  * It has to be called with the spinlock held.
     300                 :            :  */
     301                 :     111473 : static void shmem_recalc_inode(struct inode *inode)
     302                 :            : {
     303         [ +  + ]:     111473 :         struct shmem_inode_info *info = SHMEM_I(inode);
     304                 :     111473 :         long freed;
     305                 :            : 
     306                 :     111473 :         freed = info->alloced - info->swapped - inode->i_mapping->nrpages;
     307         [ +  + ]:     111473 :         if (freed > 0) {
     308                 :       2685 :                 info->alloced -= freed;
     309                 :       2685 :                 inode->i_blocks -= freed * BLOCKS_PER_PAGE;
     310                 :       2685 :                 shmem_inode_unacct_blocks(inode, freed);
     311                 :            :         }
     312                 :     111473 : }
     313                 :            : 
     314                 :          0 : bool shmem_charge(struct inode *inode, long pages)
     315                 :            : {
     316                 :          0 :         struct shmem_inode_info *info = SHMEM_I(inode);
     317                 :          0 :         unsigned long flags;
     318                 :            : 
     319         [ #  # ]:          0 :         if (!shmem_inode_acct_block(inode, pages))
     320                 :            :                 return false;
     321                 :            : 
     322                 :            :         /* nrpages adjustment first, then shmem_recalc_inode() when balanced */
     323                 :          0 :         inode->i_mapping->nrpages += pages;
     324                 :            : 
     325                 :          0 :         spin_lock_irqsave(&info->lock, flags);
     326                 :          0 :         info->alloced += pages;
     327                 :          0 :         inode->i_blocks += pages * BLOCKS_PER_PAGE;
     328                 :          0 :         shmem_recalc_inode(inode);
     329                 :          0 :         spin_unlock_irqrestore(&info->lock, flags);
     330                 :            : 
     331                 :          0 :         return true;
     332                 :            : }
     333                 :            : 
     334                 :          0 : void shmem_uncharge(struct inode *inode, long pages)
     335                 :            : {
     336                 :          0 :         struct shmem_inode_info *info = SHMEM_I(inode);
     337                 :          0 :         unsigned long flags;
     338                 :            : 
     339                 :            :         /* nrpages adjustment done by __delete_from_page_cache() or caller */
     340                 :            : 
     341                 :          0 :         spin_lock_irqsave(&info->lock, flags);
     342                 :          0 :         info->alloced -= pages;
     343                 :          0 :         inode->i_blocks -= pages * BLOCKS_PER_PAGE;
     344                 :          0 :         shmem_recalc_inode(inode);
     345                 :          0 :         spin_unlock_irqrestore(&info->lock, flags);
     346                 :            : 
     347                 :          0 :         shmem_inode_unacct_blocks(inode, pages);
     348                 :          0 : }
     349                 :            : 
     350                 :            : /*
     351                 :            :  * Replace item expected in xarray by a new item, while holding xa_lock.
     352                 :            :  */
     353                 :          0 : static int shmem_replace_entry(struct address_space *mapping,
     354                 :            :                         pgoff_t index, void *expected, void *replacement)
     355                 :            : {
     356                 :          0 :         XA_STATE(xas, &mapping->i_pages, index);
     357                 :          0 :         void *item;
     358                 :            : 
     359                 :          0 :         VM_BUG_ON(!expected);
     360                 :          0 :         VM_BUG_ON(!replacement);
     361                 :          0 :         item = xas_load(&xas);
     362         [ #  # ]:          0 :         if (item != expected)
     363                 :            :                 return -ENOENT;
     364                 :          0 :         xas_store(&xas, replacement);
     365                 :          0 :         return 0;
     366                 :            : }
     367                 :            : 
     368                 :            : /*
     369                 :            :  * Sometimes, before we decide whether to proceed or to fail, we must check
     370                 :            :  * that an entry was not already brought back from swap by a racing thread.
     371                 :            :  *
     372                 :            :  * Checking page is not enough: by the time a SwapCache page is locked, it
     373                 :            :  * might be reused, and again be SwapCache, using the same swap as before.
     374                 :            :  */
     375                 :          0 : static bool shmem_confirm_swap(struct address_space *mapping,
     376                 :            :                                pgoff_t index, swp_entry_t swap)
     377                 :            : {
     378                 :          0 :         return xa_load(&mapping->i_pages, index) == swp_to_radix_entry(swap);
     379                 :            : }
     380                 :            : 
     381                 :            : /*
     382                 :            :  * Definitions for "huge tmpfs": tmpfs mounted with the huge= option
     383                 :            :  *
     384                 :            :  * SHMEM_HUGE_NEVER:
     385                 :            :  *      disables huge pages for the mount;
     386                 :            :  * SHMEM_HUGE_ALWAYS:
     387                 :            :  *      enables huge pages for the mount;
     388                 :            :  * SHMEM_HUGE_WITHIN_SIZE:
     389                 :            :  *      only allocate huge pages if the page will be fully within i_size,
     390                 :            :  *      also respect fadvise()/madvise() hints;
     391                 :            :  * SHMEM_HUGE_ADVISE:
     392                 :            :  *      only allocate huge pages if requested with fadvise()/madvise();
     393                 :            :  */
     394                 :            : 
     395                 :            : #define SHMEM_HUGE_NEVER        0
     396                 :            : #define SHMEM_HUGE_ALWAYS       1
     397                 :            : #define SHMEM_HUGE_WITHIN_SIZE  2
     398                 :            : #define SHMEM_HUGE_ADVISE       3
     399                 :            : 
     400                 :            : /*
     401                 :            :  * Special values.
     402                 :            :  * Only can be set via /sys/kernel/mm/transparent_hugepage/shmem_enabled:
     403                 :            :  *
     404                 :            :  * SHMEM_HUGE_DENY:
     405                 :            :  *      disables huge on shm_mnt and all mounts, for emergency use;
     406                 :            :  * SHMEM_HUGE_FORCE:
     407                 :            :  *      enables huge on shm_mnt and all mounts, w/o needing option, for testing;
     408                 :            :  *
     409                 :            :  */
     410                 :            : #define SHMEM_HUGE_DENY         (-1)
     411                 :            : #define SHMEM_HUGE_FORCE        (-2)
     412                 :            : 
     413                 :            : #ifdef CONFIG_TRANSPARENT_HUGE_PAGECACHE
     414                 :            : /* ifdef here to avoid bloating shmem.o when not necessary */
     415                 :            : 
     416                 :            : static int shmem_huge __read_mostly;
     417                 :            : 
     418                 :            : #if defined(CONFIG_SYSFS)
     419                 :            : static int shmem_parse_huge(const char *str)
     420                 :            : {
     421                 :            :         if (!strcmp(str, "never"))
     422                 :            :                 return SHMEM_HUGE_NEVER;
     423                 :            :         if (!strcmp(str, "always"))
     424                 :            :                 return SHMEM_HUGE_ALWAYS;
     425                 :            :         if (!strcmp(str, "within_size"))
     426                 :            :                 return SHMEM_HUGE_WITHIN_SIZE;
     427                 :            :         if (!strcmp(str, "advise"))
     428                 :            :                 return SHMEM_HUGE_ADVISE;
     429                 :            :         if (!strcmp(str, "deny"))
     430                 :            :                 return SHMEM_HUGE_DENY;
     431                 :            :         if (!strcmp(str, "force"))
     432                 :            :                 return SHMEM_HUGE_FORCE;
     433                 :            :         return -EINVAL;
     434                 :            : }
     435                 :            : #endif
     436                 :            : 
     437                 :            : #if defined(CONFIG_SYSFS) || defined(CONFIG_TMPFS)
     438                 :            : static const char *shmem_format_huge(int huge)
     439                 :            : {
     440                 :            :         switch (huge) {
     441                 :            :         case SHMEM_HUGE_NEVER:
     442                 :            :                 return "never";
     443                 :            :         case SHMEM_HUGE_ALWAYS:
     444                 :            :                 return "always";
     445                 :            :         case SHMEM_HUGE_WITHIN_SIZE:
     446                 :            :                 return "within_size";
     447                 :            :         case SHMEM_HUGE_ADVISE:
     448                 :            :                 return "advise";
     449                 :            :         case SHMEM_HUGE_DENY:
     450                 :            :                 return "deny";
     451                 :            :         case SHMEM_HUGE_FORCE:
     452                 :            :                 return "force";
     453                 :            :         default:
     454                 :            :                 VM_BUG_ON(1);
     455                 :            :                 return "bad_val";
     456                 :            :         }
     457                 :            : }
     458                 :            : #endif
     459                 :            : 
     460                 :            : static unsigned long shmem_unused_huge_shrink(struct shmem_sb_info *sbinfo,
     461                 :            :                 struct shrink_control *sc, unsigned long nr_to_split)
     462                 :            : {
     463                 :            :         LIST_HEAD(list), *pos, *next;
     464                 :            :         LIST_HEAD(to_remove);
     465                 :            :         struct inode *inode;
     466                 :            :         struct shmem_inode_info *info;
     467                 :            :         struct page *page;
     468                 :            :         unsigned long batch = sc ? sc->nr_to_scan : 128;
     469                 :            :         int removed = 0, split = 0;
     470                 :            : 
     471                 :            :         if (list_empty(&sbinfo->shrinklist))
     472                 :            :                 return SHRINK_STOP;
     473                 :            : 
     474                 :            :         spin_lock(&sbinfo->shrinklist_lock);
     475                 :            :         list_for_each_safe(pos, next, &sbinfo->shrinklist) {
     476                 :            :                 info = list_entry(pos, struct shmem_inode_info, shrinklist);
     477                 :            : 
     478                 :            :                 /* pin the inode */
     479                 :            :                 inode = igrab(&info->vfs_inode);
     480                 :            : 
     481                 :            :                 /* inode is about to be evicted */
     482                 :            :                 if (!inode) {
     483                 :            :                         list_del_init(&info->shrinklist);
     484                 :            :                         removed++;
     485                 :            :                         goto next;
     486                 :            :                 }
     487                 :            : 
     488                 :            :                 /* Check if there's anything to gain */
     489                 :            :                 if (round_up(inode->i_size, PAGE_SIZE) ==
     490                 :            :                                 round_up(inode->i_size, HPAGE_PMD_SIZE)) {
     491                 :            :                         list_move(&info->shrinklist, &to_remove);
     492                 :            :                         removed++;
     493                 :            :                         goto next;
     494                 :            :                 }
     495                 :            : 
     496                 :            :                 list_move(&info->shrinklist, &list);
     497                 :            : next:
     498                 :            :                 if (!--batch)
     499                 :            :                         break;
     500                 :            :         }
     501                 :            :         spin_unlock(&sbinfo->shrinklist_lock);
     502                 :            : 
     503                 :            :         list_for_each_safe(pos, next, &to_remove) {
     504                 :            :                 info = list_entry(pos, struct shmem_inode_info, shrinklist);
     505                 :            :                 inode = &info->vfs_inode;
     506                 :            :                 list_del_init(&info->shrinklist);
     507                 :            :                 iput(inode);
     508                 :            :         }
     509                 :            : 
     510                 :            :         list_for_each_safe(pos, next, &list) {
     511                 :            :                 int ret;
     512                 :            : 
     513                 :            :                 info = list_entry(pos, struct shmem_inode_info, shrinklist);
     514                 :            :                 inode = &info->vfs_inode;
     515                 :            : 
     516                 :            :                 if (nr_to_split && split >= nr_to_split)
     517                 :            :                         goto leave;
     518                 :            : 
     519                 :            :                 page = find_get_page(inode->i_mapping,
     520                 :            :                                 (inode->i_size & HPAGE_PMD_MASK) >> PAGE_SHIFT);
     521                 :            :                 if (!page)
     522                 :            :                         goto drop;
     523                 :            : 
     524                 :            :                 /* No huge page at the end of the file: nothing to split */
     525                 :            :                 if (!PageTransHuge(page)) {
     526                 :            :                         put_page(page);
     527                 :            :                         goto drop;
     528                 :            :                 }
     529                 :            : 
     530                 :            :                 /*
     531                 :            :                  * Leave the inode on the list if we failed to lock
     532                 :            :                  * the page at this time.
     533                 :            :                  *
     534                 :            :                  * Waiting for the lock may lead to deadlock in the
     535                 :            :                  * reclaim path.
     536                 :            :                  */
     537                 :            :                 if (!trylock_page(page)) {
     538                 :            :                         put_page(page);
     539                 :            :                         goto leave;
     540                 :            :                 }
     541                 :            : 
     542                 :            :                 ret = split_huge_page(page);
     543                 :            :                 unlock_page(page);
     544                 :            :                 put_page(page);
     545                 :            : 
     546                 :            :                 /* If split failed leave the inode on the list */
     547                 :            :                 if (ret)
     548                 :            :                         goto leave;
     549                 :            : 
     550                 :            :                 split++;
     551                 :            : drop:
     552                 :            :                 list_del_init(&info->shrinklist);
     553                 :            :                 removed++;
     554                 :            : leave:
     555                 :            :                 iput(inode);
     556                 :            :         }
     557                 :            : 
     558                 :            :         spin_lock(&sbinfo->shrinklist_lock);
     559                 :            :         list_splice_tail(&list, &sbinfo->shrinklist);
     560                 :            :         sbinfo->shrinklist_len -= removed;
     561                 :            :         spin_unlock(&sbinfo->shrinklist_lock);
     562                 :            : 
     563                 :            :         return split;
     564                 :            : }
     565                 :            : 
     566                 :            : static long shmem_unused_huge_scan(struct super_block *sb,
     567                 :            :                 struct shrink_control *sc)
     568                 :            : {
     569                 :            :         struct shmem_sb_info *sbinfo = SHMEM_SB(sb);
     570                 :            : 
     571                 :            :         if (!READ_ONCE(sbinfo->shrinklist_len))
     572                 :            :                 return SHRINK_STOP;
     573                 :            : 
     574                 :            :         return shmem_unused_huge_shrink(sbinfo, sc, 0);
     575                 :            : }
     576                 :            : 
     577                 :            : static long shmem_unused_huge_count(struct super_block *sb,
     578                 :            :                 struct shrink_control *sc)
     579                 :            : {
     580                 :            :         struct shmem_sb_info *sbinfo = SHMEM_SB(sb);
     581                 :            :         return READ_ONCE(sbinfo->shrinklist_len);
     582                 :            : }
     583                 :            : #else /* !CONFIG_TRANSPARENT_HUGE_PAGECACHE */
     584                 :            : 
     585                 :            : #define shmem_huge SHMEM_HUGE_DENY
     586                 :            : 
     587                 :            : static unsigned long shmem_unused_huge_shrink(struct shmem_sb_info *sbinfo,
     588                 :            :                 struct shrink_control *sc, unsigned long nr_to_split)
     589                 :            : {
     590                 :            :         return 0;
     591                 :            : }
     592                 :            : #endif /* CONFIG_TRANSPARENT_HUGE_PAGECACHE */
     593                 :            : 
     594                 :      24149 : static inline bool is_huge_enabled(struct shmem_sb_info *sbinfo)
     595                 :            : {
     596                 :      24149 :         if (IS_ENABLED(CONFIG_TRANSPARENT_HUGE_PAGECACHE) &&
     597                 :            :             (shmem_huge == SHMEM_HUGE_FORCE || sbinfo->huge) &&
     598                 :            :             shmem_huge != SHMEM_HUGE_DENY)
     599                 :            :                 return true;
     600                 :      24149 :         return false;
     601                 :            : }
     602                 :            : 
     603                 :            : /*
     604                 :            :  * Like add_to_page_cache_locked, but error if expected item has gone.
     605                 :            :  */
     606                 :     102636 : static int shmem_add_to_page_cache(struct page *page,
     607                 :            :                                    struct address_space *mapping,
     608                 :            :                                    pgoff_t index, void *expected, gfp_t gfp)
     609                 :            : {
     610                 :     513180 :         XA_STATE_ORDER(xas, &mapping->i_pages, index, compound_order(page));
     611                 :     102636 :         unsigned long i = 0;
     612                 :     102636 :         unsigned long nr = compound_nr(page);
     613                 :            : 
     614                 :     102636 :         VM_BUG_ON_PAGE(PageTail(page), page);
     615                 :     102636 :         VM_BUG_ON_PAGE(index != round_down(index, nr), page);
     616                 :     102636 :         VM_BUG_ON_PAGE(!PageLocked(page), page);
     617                 :     102636 :         VM_BUG_ON_PAGE(!PageSwapBacked(page), page);
     618                 :     102636 :         VM_BUG_ON(expected && PageTransHuge(page));
     619                 :            : 
     620                 :     102636 :         page_ref_add(page, nr);
     621                 :     102636 :         page->mapping = mapping;
     622                 :     102636 :         page->index = index;
     623                 :            : 
     624                 :     102636 :         do {
     625                 :     102636 :                 void *entry;
     626                 :     102636 :                 xas_lock_irq(&xas);
     627                 :     102636 :                 entry = xas_find_conflict(&xas);
     628         [ -  + ]:     102636 :                 if (entry != expected)
     629                 :          0 :                         xas_set_err(&xas, -EEXIST);
     630                 :     102636 :                 xas_create_range(&xas);
     631   [ -  +  -  - ]:     102636 :                 if (xas_error(&xas))
     632                 :          0 :                         goto unlock;
     633                 :          0 : next:
     634                 :     102636 :                 xas_store(&xas, page);
     635         [ -  + ]:     102636 :                 if (++i < nr) {
     636                 :          0 :                         xas_next(&xas);
     637                 :          0 :                         goto next;
     638                 :            :                 }
     639                 :     102636 :                 if (PageTransHuge(page)) {
     640                 :            :                         count_vm_event(THP_FILE_ALLOC);
     641                 :            :                         __inc_node_page_state(page, NR_SHMEM_THPS);
     642                 :            :                 }
     643                 :     102636 :                 mapping->nrpages += nr;
     644                 :     102636 :                 __mod_node_page_state(page_pgdat(page), NR_FILE_PAGES, nr);
     645                 :     102636 :                 __mod_node_page_state(page_pgdat(page), NR_SHMEM, nr);
     646                 :     102636 : unlock:
     647                 :     102636 :                 xas_unlock_irq(&xas);
     648         [ -  + ]:     102636 :         } while (xas_nomem(&xas, gfp));
     649                 :            : 
     650   [ -  +  -  - ]:     102636 :         if (xas_error(&xas)) {
     651                 :          0 :                 page->mapping = NULL;
     652                 :          0 :                 page_ref_sub(page, nr);
     653         [ #  # ]:          0 :                 return xas_error(&xas);
     654                 :            :         }
     655                 :            : 
     656                 :            :         return 0;
     657                 :            : }
     658                 :            : 
     659                 :            : /*
     660                 :            :  * Like delete_from_page_cache, but substitutes swap for page.
     661                 :            :  */
     662                 :          0 : static void shmem_delete_from_page_cache(struct page *page, void *radswap)
     663                 :            : {
     664                 :          0 :         struct address_space *mapping = page->mapping;
     665                 :          0 :         int error;
     666                 :            : 
     667                 :          0 :         VM_BUG_ON_PAGE(PageCompound(page), page);
     668                 :            : 
     669                 :          0 :         xa_lock_irq(&mapping->i_pages);
     670                 :          0 :         error = shmem_replace_entry(mapping, page->index, page, radswap);
     671                 :          0 :         page->mapping = NULL;
     672                 :          0 :         mapping->nrpages--;
     673                 :          0 :         __dec_node_page_state(page, NR_FILE_PAGES);
     674                 :          0 :         __dec_node_page_state(page, NR_SHMEM);
     675                 :          0 :         xa_unlock_irq(&mapping->i_pages);
     676                 :          0 :         put_page(page);
     677         [ #  # ]:          0 :         BUG_ON(error);
     678                 :          0 : }
     679                 :            : 
     680                 :            : /*
     681                 :            :  * Remove swap entry from page cache, free the swap and its page cache.
     682                 :            :  */
     683                 :          0 : static int shmem_free_swap(struct address_space *mapping,
     684                 :            :                            pgoff_t index, void *radswap)
     685                 :            : {
     686                 :          0 :         void *old;
     687                 :            : 
     688                 :          0 :         old = xa_cmpxchg_irq(&mapping->i_pages, index, radswap, NULL, 0);
     689         [ #  # ]:          0 :         if (old != radswap)
     690                 :            :                 return -ENOENT;
     691                 :          0 :         free_swap_and_cache(radix_to_swp_entry(radswap));
     692                 :          0 :         return 0;
     693                 :            : }
     694                 :            : 
     695                 :            : /*
     696                 :            :  * Determine (in bytes) how many of the shmem object's pages mapped by the
     697                 :            :  * given offsets are swapped out.
     698                 :            :  *
     699                 :            :  * This is safe to call without i_mutex or the i_pages lock thanks to RCU,
     700                 :            :  * as long as the inode doesn't go away and racy results are not a problem.
     701                 :            :  */
     702                 :          0 : unsigned long shmem_partial_swap_usage(struct address_space *mapping,
     703                 :            :                                                 pgoff_t start, pgoff_t end)
     704                 :            : {
     705                 :          0 :         XA_STATE(xas, &mapping->i_pages, start);
     706                 :          0 :         struct page *page;
     707                 :          0 :         unsigned long swapped = 0;
     708                 :            : 
     709                 :          0 :         rcu_read_lock();
     710         [ #  # ]:          0 :         xas_for_each(&xas, page, end - 1) {
     711         [ #  # ]:          0 :                 if (xas_retry(&xas, page))
     712                 :          0 :                         continue;
     713         [ #  # ]:          0 :                 if (xa_is_value(page))
     714                 :          0 :                         swapped++;
     715                 :            : 
     716         [ #  # ]:          0 :                 if (need_resched()) {
     717                 :          0 :                         xas_pause(&xas);
     718                 :          0 :                         cond_resched_rcu();
     719                 :            :                 }
     720                 :            :         }
     721                 :            : 
     722                 :          0 :         rcu_read_unlock();
     723                 :            : 
     724                 :          0 :         return swapped << PAGE_SHIFT;
     725                 :            : }
     726                 :            : 
     727                 :            : /*
     728                 :            :  * Determine (in bytes) how many of the shmem object's pages mapped by the
     729                 :            :  * given vma is swapped out.
     730                 :            :  *
     731                 :            :  * This is safe to call without i_mutex or the i_pages lock thanks to RCU,
     732                 :            :  * as long as the inode doesn't go away and racy results are not a problem.
     733                 :            :  */
     734                 :          0 : unsigned long shmem_swap_usage(struct vm_area_struct *vma)
     735                 :            : {
     736         [ #  # ]:          0 :         struct inode *inode = file_inode(vma->vm_file);
     737         [ #  # ]:          0 :         struct shmem_inode_info *info = SHMEM_I(inode);
     738                 :          0 :         struct address_space *mapping = inode->i_mapping;
     739                 :          0 :         unsigned long swapped;
     740                 :            : 
     741                 :            :         /* Be careful as we don't hold info->lock */
     742         [ #  # ]:          0 :         swapped = READ_ONCE(info->swapped);
     743                 :            : 
     744                 :            :         /*
     745                 :            :          * The easier cases are when the shmem object has nothing in swap, or
     746                 :            :          * the vma maps it whole. Then we can simply use the stats that we
     747                 :            :          * already track.
     748                 :            :          */
     749         [ #  # ]:          0 :         if (!swapped)
     750                 :            :                 return 0;
     751                 :            : 
     752   [ #  #  #  # ]:          0 :         if (!vma->vm_pgoff && vma->vm_end - vma->vm_start >= inode->i_size)
     753                 :          0 :                 return swapped << PAGE_SHIFT;
     754                 :            : 
     755                 :            :         /* Here comes the more involved part */
     756                 :          0 :         return shmem_partial_swap_usage(mapping,
     757                 :            :                         linear_page_index(vma, vma->vm_start),
     758                 :            :                         linear_page_index(vma, vma->vm_end));
     759                 :            : }
     760                 :            : 
     761                 :            : /*
     762                 :            :  * SysV IPC SHM_UNLOCK restore Unevictable pages to their evictable lists.
     763                 :            :  */
     764                 :          0 : void shmem_unlock_mapping(struct address_space *mapping)
     765                 :            : {
     766                 :          0 :         struct pagevec pvec;
     767                 :          0 :         pgoff_t indices[PAGEVEC_SIZE];
     768                 :          0 :         pgoff_t index = 0;
     769                 :            : 
     770                 :          0 :         pagevec_init(&pvec);
     771                 :            :         /*
     772                 :            :          * Minor point, but we might as well stop if someone else SHM_LOCKs it.
     773                 :            :          */
     774   [ #  #  #  # ]:          0 :         while (!mapping_unevictable(mapping)) {
     775                 :            :                 /*
     776                 :            :                  * Avoid pagevec_lookup(): find_get_pages() returns 0 as if it
     777                 :            :                  * has finished, if it hits a row of PAGEVEC_SIZE swap entries.
     778                 :            :                  */
     779                 :          0 :                 pvec.nr = find_get_entries(mapping, index,
     780                 :            :                                            PAGEVEC_SIZE, pvec.pages, indices);
     781         [ #  # ]:          0 :                 if (!pvec.nr)
     782                 :            :                         break;
     783                 :          0 :                 index = indices[pvec.nr - 1] + 1;
     784                 :          0 :                 pagevec_remove_exceptionals(&pvec);
     785                 :          0 :                 check_move_unevictable_pages(&pvec);
     786         [ #  # ]:          0 :                 pagevec_release(&pvec);
     787                 :          0 :                 cond_resched();
     788                 :            :         }
     789                 :          0 : }
     790                 :            : 
     791                 :            : /*
     792                 :            :  * Remove range of pages and swap entries from page cache, and free them.
     793                 :            :  * If !unfalloc, truncate or punch hole; if unfalloc, undo failed fallocate.
     794                 :            :  */
     795                 :       8837 : static void shmem_undo_range(struct inode *inode, loff_t lstart, loff_t lend,
     796                 :            :                                                                  bool unfalloc)
     797                 :            : {
     798                 :       8837 :         struct address_space *mapping = inode->i_mapping;
     799         [ +  - ]:       8837 :         struct shmem_inode_info *info = SHMEM_I(inode);
     800                 :       8837 :         pgoff_t start = (lstart + PAGE_SIZE - 1) >> PAGE_SHIFT;
     801                 :       8837 :         pgoff_t end = (lend + 1) >> PAGE_SHIFT;
     802                 :       8837 :         unsigned int partial_start = lstart & (PAGE_SIZE - 1);
     803                 :       8837 :         unsigned int partial_end = (lend + 1) & (PAGE_SIZE - 1);
     804                 :       8837 :         struct pagevec pvec;
     805                 :       8837 :         pgoff_t indices[PAGEVEC_SIZE];
     806                 :       8837 :         long nr_swaps_freed = 0;
     807                 :       8837 :         pgoff_t index;
     808                 :       8837 :         int i;
     809                 :            : 
     810         [ +  - ]:       8837 :         if (lend == -1)
     811                 :       8837 :                 end = -1;       /* unsigned, so actually very big */
     812                 :            : 
     813                 :       8837 :         pagevec_init(&pvec);
     814                 :       8837 :         index = start;
     815         [ +  - ]:      11522 :         while (index < end) {
     816                 :      23044 :                 pvec.nr = find_get_entries(mapping, index,
     817                 :      11522 :                         min(end - index, (pgoff_t)PAGEVEC_SIZE),
     818                 :            :                         pvec.pages, indices);
     819         [ +  + ]:      11522 :                 if (!pvec.nr)
     820                 :            :                         break;
     821         [ +  + ]:       5370 :                 for (i = 0; i < pagevec_count(&pvec); i++) {
     822                 :       2685 :                         struct page *page = pvec.pages[i];
     823                 :            : 
     824                 :       2685 :                         index = indices[i];
     825         [ +  - ]:       2685 :                         if (index >= end)
     826                 :            :                                 break;
     827                 :            : 
     828         [ -  + ]:       2685 :                         if (xa_is_value(page)) {
     829         [ #  # ]:          0 :                                 if (unfalloc)
     830                 :          0 :                                         continue;
     831                 :          0 :                                 nr_swaps_freed += !shmem_free_swap(mapping,
     832                 :            :                                                                 index, page);
     833                 :          0 :                                 continue;
     834                 :            :                         }
     835                 :            : 
     836                 :       2685 :                         VM_BUG_ON_PAGE(page_to_pgoff(page) != index, page);
     837                 :            : 
     838   [ -  +  -  + ]:       5370 :                         if (!trylock_page(page))
     839                 :          0 :                                 continue;
     840                 :            : 
     841         [ -  + ]:       2685 :                         if (PageTransTail(page)) {
     842                 :            :                                 /* Middle of THP: zero out the page */
     843                 :            :                                 clear_highpage(page);
     844                 :            :                                 unlock_page(page);
     845                 :            :                                 continue;
     846         [ -  + ]:       2685 :                         } else if (PageTransHuge(page)) {
     847                 :            :                                 if (index == round_down(end, HPAGE_PMD_NR)) {
     848                 :            :                                         /*
     849                 :            :                                          * Range ends in the middle of THP:
     850                 :            :                                          * zero out the page
     851                 :            :                                          */
     852                 :            :                                         clear_highpage(page);
     853                 :            :                                         unlock_page(page);
     854                 :            :                                         continue;
     855                 :            :                                 }
     856                 :            :                                 index += HPAGE_PMD_NR - 1;
     857                 :            :                                 i += HPAGE_PMD_NR - 1;
     858                 :            :                         }
     859                 :            : 
     860   [ -  +  -  - ]:       2685 :                         if (!unfalloc || !PageUptodate(page)) {
     861                 :       2685 :                                 VM_BUG_ON_PAGE(PageTail(page), page);
     862         [ +  - ]:       2685 :                                 if (page_mapping(page) == mapping) {
     863                 :       2685 :                                         VM_BUG_ON_PAGE(PageWriteback(page), page);
     864                 :       2685 :                                         truncate_inode_page(mapping, page);
     865                 :            :                                 }
     866                 :            :                         }
     867                 :       2685 :                         unlock_page(page);
     868                 :            :                 }
     869                 :       2685 :                 pagevec_remove_exceptionals(&pvec);
     870         [ +  - ]:       2685 :                 pagevec_release(&pvec);
     871                 :       2685 :                 cond_resched();
     872                 :       2685 :                 index++;
     873                 :            :         }
     874                 :            : 
     875         [ +  + ]:       8837 :         if (partial_start) {
     876                 :        156 :                 struct page *page = NULL;
     877                 :        156 :                 shmem_getpage(inode, start - 1, &page, SGP_READ);
     878         [ +  - ]:        156 :                 if (page) {
     879                 :        156 :                         unsigned int top = PAGE_SIZE;
     880         [ -  + ]:        156 :                         if (start > end) {
     881                 :          0 :                                 top = partial_end;
     882                 :          0 :                                 partial_end = 0;
     883                 :            :                         }
     884                 :        156 :                         zero_user_segment(page, partial_start, top);
     885                 :        156 :                         set_page_dirty(page);
     886                 :        156 :                         unlock_page(page);
     887                 :        156 :                         put_page(page);
     888                 :            :                 }
     889                 :            :         }
     890         [ -  + ]:       8837 :         if (partial_end) {
     891                 :          0 :                 struct page *page = NULL;
     892                 :          0 :                 shmem_getpage(inode, end, &page, SGP_READ);
     893         [ #  # ]:          0 :                 if (page) {
     894                 :          0 :                         zero_user_segment(page, 0, partial_end);
     895                 :          0 :                         set_page_dirty(page);
     896                 :          0 :                         unlock_page(page);
     897                 :          0 :                         put_page(page);
     898                 :            :                 }
     899                 :            :         }
     900         [ -  + ]:       8837 :         if (start >= end)
     901                 :          0 :                 return;
     902                 :            : 
     903                 :            :         index = start;
     904         [ +  - ]:       8837 :         while (index < end) {
     905                 :       8837 :                 cond_resched();
     906                 :            : 
     907                 :      17674 :                 pvec.nr = find_get_entries(mapping, index,
     908                 :       8837 :                                 min(end - index, (pgoff_t)PAGEVEC_SIZE),
     909                 :            :                                 pvec.pages, indices);
     910         [ +  - ]:       8837 :                 if (!pvec.nr) {
     911                 :            :                         /* If all gone or hole-punch or unfalloc, we're done */
     912         [ -  + ]:       8837 :                         if (index == start || end != -1)
     913                 :            :                                 break;
     914                 :            :                         /* But if truncating, restart to make sure all gone */
     915                 :          0 :                         index = start;
     916                 :          0 :                         continue;
     917                 :            :                 }
     918         [ #  # ]:          0 :                 for (i = 0; i < pagevec_count(&pvec); i++) {
     919                 :          0 :                         struct page *page = pvec.pages[i];
     920                 :            : 
     921                 :          0 :                         index = indices[i];
     922         [ #  # ]:          0 :                         if (index >= end)
     923                 :            :                                 break;
     924                 :            : 
     925         [ #  # ]:          0 :                         if (xa_is_value(page)) {
     926         [ #  # ]:          0 :                                 if (unfalloc)
     927                 :          0 :                                         continue;
     928         [ #  # ]:          0 :                                 if (shmem_free_swap(mapping, index, page)) {
     929                 :            :                                         /* Swap was replaced by page: retry */
     930                 :          0 :                                         index--;
     931                 :          0 :                                         break;
     932                 :            :                                 }
     933                 :          0 :                                 nr_swaps_freed++;
     934                 :          0 :                                 continue;
     935                 :            :                         }
     936                 :            : 
     937                 :          0 :                         lock_page(page);
     938                 :            : 
     939         [ #  # ]:          0 :                         if (PageTransTail(page)) {
     940                 :            :                                 /* Middle of THP: zero out the page */
     941                 :            :                                 clear_highpage(page);
     942                 :            :                                 unlock_page(page);
     943                 :            :                                 /*
     944                 :            :                                  * Partial thp truncate due 'start' in middle
     945                 :            :                                  * of THP: don't need to look on these pages
     946                 :            :                                  * again on !pvec.nr restart.
     947                 :            :                                  */
     948                 :            :                                 if (index != round_down(end, HPAGE_PMD_NR))
     949                 :            :                                         start++;
     950                 :            :                                 continue;
     951         [ #  # ]:          0 :                         } else if (PageTransHuge(page)) {
     952                 :            :                                 if (index == round_down(end, HPAGE_PMD_NR)) {
     953                 :            :                                         /*
     954                 :            :                                          * Range ends in the middle of THP:
     955                 :            :                                          * zero out the page
     956                 :            :                                          */
     957                 :            :                                         clear_highpage(page);
     958                 :            :                                         unlock_page(page);
     959                 :            :                                         continue;
     960                 :            :                                 }
     961                 :            :                                 index += HPAGE_PMD_NR - 1;
     962                 :            :                                 i += HPAGE_PMD_NR - 1;
     963                 :            :                         }
     964                 :            : 
     965   [ #  #  #  # ]:          0 :                         if (!unfalloc || !PageUptodate(page)) {
     966                 :          0 :                                 VM_BUG_ON_PAGE(PageTail(page), page);
     967         [ #  # ]:          0 :                                 if (page_mapping(page) == mapping) {
     968                 :          0 :                                         VM_BUG_ON_PAGE(PageWriteback(page), page);
     969                 :          0 :                                         truncate_inode_page(mapping, page);
     970                 :            :                                 } else {
     971                 :            :                                         /* Page was replaced by swap: retry */
     972                 :          0 :                                         unlock_page(page);
     973                 :          0 :                                         index--;
     974                 :          0 :                                         break;
     975                 :            :                                 }
     976                 :            :                         }
     977                 :          0 :                         unlock_page(page);
     978                 :            :                 }
     979                 :          0 :                 pagevec_remove_exceptionals(&pvec);
     980         [ #  # ]:          0 :                 pagevec_release(&pvec);
     981                 :          0 :                 index++;
     982                 :            :         }
     983                 :            : 
     984                 :       8837 :         spin_lock_irq(&info->lock);
     985                 :       8837 :         info->swapped -= nr_swaps_freed;
     986                 :       8837 :         shmem_recalc_inode(inode);
     987                 :       8837 :         spin_unlock_irq(&info->lock);
     988                 :            : }
     989                 :            : 
     990                 :       8837 : void shmem_truncate_range(struct inode *inode, loff_t lstart, loff_t lend)
     991                 :            : {
     992                 :       8837 :         shmem_undo_range(inode, lstart, lend, false);
     993                 :       8837 :         inode->i_ctime = inode->i_mtime = current_time(inode);
     994                 :       8837 : }
     995                 :            : EXPORT_SYMBOL_GPL(shmem_truncate_range);
     996                 :            : 
     997                 :      24149 : static int shmem_getattr(const struct path *path, struct kstat *stat,
     998                 :            :                          u32 request_mask, unsigned int query_flags)
     999                 :            : {
    1000                 :      24149 :         struct inode *inode = path->dentry->d_inode;
    1001         [ -  + ]:      24149 :         struct shmem_inode_info *info = SHMEM_I(inode);
    1002                 :      24149 :         struct shmem_sb_info *sb_info = SHMEM_SB(inode->i_sb);
    1003                 :            : 
    1004         [ -  + ]:      24149 :         if (info->alloced - info->swapped != inode->i_mapping->nrpages) {
    1005                 :          0 :                 spin_lock_irq(&info->lock);
    1006                 :          0 :                 shmem_recalc_inode(inode);
    1007                 :          0 :                 spin_unlock_irq(&info->lock);
    1008                 :            :         }
    1009                 :      24149 :         generic_fillattr(inode, stat);
    1010                 :            : 
    1011                 :      24149 :         if (is_huge_enabled(sb_info))
    1012                 :            :                 stat->blksize = HPAGE_PMD_SIZE;
    1013                 :            : 
    1014                 :      24149 :         return 0;
    1015                 :            : }
    1016                 :            : 
    1017                 :      60728 : static int shmem_setattr(struct dentry *dentry, struct iattr *attr)
    1018                 :            : {
    1019                 :      60728 :         struct inode *inode = d_inode(dentry);
    1020                 :      60728 :         struct shmem_inode_info *info = SHMEM_I(inode);
    1021                 :      60728 :         struct shmem_sb_info *sbinfo = SHMEM_SB(inode->i_sb);
    1022                 :      60728 :         int error;
    1023                 :            : 
    1024                 :      60728 :         error = setattr_prepare(dentry, attr);
    1025         [ +  - ]:      60728 :         if (error)
    1026                 :            :                 return error;
    1027                 :            : 
    1028   [ +  +  +  + ]:      60728 :         if (S_ISREG(inode->i_mode) && (attr->ia_valid & ATTR_SIZE)) {
    1029                 :        642 :                 loff_t oldsize = inode->i_size;
    1030                 :        642 :                 loff_t newsize = attr->ia_size;
    1031                 :            : 
    1032                 :            :                 /* protected by i_mutex */
    1033   [ +  +  +  -  :        642 :                 if ((newsize < oldsize && (info->seals & F_SEAL_SHRINK)) ||
                   -  + ]
    1034         [ #  # ]:          0 :                     (newsize > oldsize && (info->seals & F_SEAL_GROW)))
    1035                 :            :                         return -EPERM;
    1036                 :            : 
    1037         [ +  + ]:        642 :                 if (newsize != oldsize) {
    1038                 :         78 :                         error = shmem_reacct_size(SHMEM_I(inode)->flags,
    1039                 :            :                                         oldsize, newsize);
    1040         [ +  - ]:         78 :                         if (error)
    1041                 :            :                                 return error;
    1042                 :         78 :                         i_size_write(inode, newsize);
    1043                 :         78 :                         inode->i_ctime = inode->i_mtime = current_time(inode);
    1044                 :            :                 }
    1045         [ +  - ]:        642 :                 if (newsize <= oldsize) {
    1046                 :        642 :                         loff_t holebegin = round_up(newsize, PAGE_SIZE);
    1047         [ +  + ]:        642 :                         if (oldsize > holebegin)
    1048                 :         78 :                                 unmap_mapping_range(inode->i_mapping,
    1049                 :            :                                                         holebegin, 0, 1);
    1050         [ +  + ]:        642 :                         if (info->alloced)
    1051                 :        564 :                                 shmem_truncate_range(inode,
    1052                 :            :                                                         newsize, (loff_t)-1);
    1053                 :            :                         /* unmap again to remove racily COWed private pages */
    1054         [ +  + ]:        642 :                         if (oldsize > holebegin)
    1055                 :         78 :                                 unmap_mapping_range(inode->i_mapping,
    1056                 :            :                                                         holebegin, 0, 1);
    1057                 :            : 
    1058                 :            :                         /*
    1059                 :            :                          * Part of the huge page can be beyond i_size: subject
    1060                 :            :                          * to shrink under memory pressure.
    1061                 :            :                          */
    1062                 :            :                         if (IS_ENABLED(CONFIG_TRANSPARENT_HUGE_PAGECACHE)) {
    1063                 :            :                                 spin_lock(&sbinfo->shrinklist_lock);
    1064                 :            :                                 /*
    1065                 :            :                                  * _careful to defend against unlocked access to
    1066                 :            :                                  * ->shrink_list in shmem_unused_huge_shrink()
    1067                 :            :                                  */
    1068                 :            :                                 if (list_empty_careful(&info->shrinklist)) {
    1069                 :            :                                         list_add_tail(&info->shrinklist,
    1070                 :            :                                                         &sbinfo->shrinklist);
    1071                 :            :                                         sbinfo->shrinklist_len++;
    1072                 :            :                                 }
    1073                 :            :                                 spin_unlock(&sbinfo->shrinklist_lock);
    1074                 :            :                         }
    1075                 :            :                 }
    1076                 :            :         }
    1077                 :            : 
    1078                 :      60728 :         setattr_copy(inode, attr);
    1079         [ +  + ]:      60728 :         if (attr->ia_valid & ATTR_MODE)
    1080                 :      33561 :                 error = posix_acl_chmod(inode, inode->i_mode);
    1081                 :            :         return error;
    1082                 :            : }
    1083                 :            : 
    1084                 :       8507 : static void shmem_evict_inode(struct inode *inode)
    1085                 :            : {
    1086         [ +  + ]:       8507 :         struct shmem_inode_info *info = SHMEM_I(inode);
    1087                 :       8507 :         struct shmem_sb_info *sbinfo = SHMEM_SB(inode->i_sb);
    1088                 :            : 
    1089         [ +  + ]:       8507 :         if (inode->i_mapping->a_ops == &shmem_aops) {
    1090                 :       8273 :                 shmem_unacct_size(info->flags, inode->i_size);
    1091                 :       8273 :                 inode->i_size = 0;
    1092                 :       8273 :                 shmem_truncate_range(inode, 0, (loff_t)-1);
    1093         [ -  + ]:       8273 :                 if (!list_empty(&info->shrinklist)) {
    1094                 :          0 :                         spin_lock(&sbinfo->shrinklist_lock);
    1095         [ #  # ]:          0 :                         if (!list_empty(&info->shrinklist)) {
    1096                 :          0 :                                 list_del_init(&info->shrinklist);
    1097                 :          0 :                                 sbinfo->shrinklist_len--;
    1098                 :            :                         }
    1099                 :          0 :                         spin_unlock(&sbinfo->shrinklist_lock);
    1100                 :            :                 }
    1101         [ -  + ]:       8273 :                 while (!list_empty(&info->swaplist)) {
    1102                 :            :                         /* Wait while shmem_unuse() is scanning this inode... */
    1103   [ #  #  #  # ]:          0 :                         wait_var_event(&info->stop_eviction,
    1104                 :            :                                        !atomic_read(&info->stop_eviction));
    1105                 :          0 :                         mutex_lock(&shmem_swaplist_mutex);
    1106                 :            :                         /* ...but beware of the race if we peeked too early */
    1107         [ #  # ]:          0 :                         if (!atomic_read(&info->stop_eviction))
    1108                 :          0 :                                 list_del_init(&info->swaplist);
    1109                 :          0 :                         mutex_unlock(&shmem_swaplist_mutex);
    1110                 :            :                 }
    1111                 :            :         }
    1112                 :            : 
    1113                 :       8507 :         simple_xattrs_free(&info->xattrs);
    1114         [ -  + ]:       8507 :         WARN_ON(inode->i_blocks);
    1115                 :       8507 :         shmem_free_inode(inode->i_sb);
    1116                 :       8507 :         clear_inode(inode);
    1117                 :       8507 : }
    1118                 :            : 
    1119                 :            : extern struct swap_info_struct *swap_info[];
    1120                 :            : 
    1121                 :          0 : static int shmem_find_swap_entries(struct address_space *mapping,
    1122                 :            :                                    pgoff_t start, unsigned int nr_entries,
    1123                 :            :                                    struct page **entries, pgoff_t *indices,
    1124                 :            :                                    unsigned int type, bool frontswap)
    1125                 :            : {
    1126                 :          0 :         XA_STATE(xas, &mapping->i_pages, start);
    1127                 :          0 :         struct page *page;
    1128                 :          0 :         swp_entry_t entry;
    1129                 :          0 :         unsigned int ret = 0;
    1130                 :            : 
    1131         [ #  # ]:          0 :         if (!nr_entries)
    1132                 :            :                 return 0;
    1133                 :            : 
    1134                 :          0 :         rcu_read_lock();
    1135         [ #  # ]:          0 :         xas_for_each(&xas, page, ULONG_MAX) {
    1136         [ #  # ]:          0 :                 if (xas_retry(&xas, page))
    1137                 :          0 :                         continue;
    1138                 :            : 
    1139         [ #  # ]:          0 :                 if (!xa_is_value(page))
    1140                 :          0 :                         continue;
    1141                 :            : 
    1142         [ #  # ]:          0 :                 entry = radix_to_swp_entry(page);
    1143         [ #  # ]:          0 :                 if (swp_type(entry) != type)
    1144                 :          0 :                         continue;
    1145         [ #  # ]:          0 :                 if (frontswap &&
    1146                 :            :                     !frontswap_test(swap_info[type], swp_offset(entry)))
    1147                 :          0 :                         continue;
    1148                 :            : 
    1149                 :          0 :                 indices[ret] = xas.xa_index;
    1150                 :          0 :                 entries[ret] = page;
    1151                 :            : 
    1152         [ #  # ]:          0 :                 if (need_resched()) {
    1153                 :          0 :                         xas_pause(&xas);
    1154                 :          0 :                         cond_resched_rcu();
    1155                 :            :                 }
    1156         [ #  # ]:          0 :                 if (++ret == nr_entries)
    1157                 :            :                         break;
    1158                 :            :         }
    1159                 :          0 :         rcu_read_unlock();
    1160                 :            : 
    1161                 :          0 :         return ret;
    1162                 :            : }
    1163                 :            : 
    1164                 :            : /*
    1165                 :            :  * Move the swapped pages for an inode to page cache. Returns the count
    1166                 :            :  * of pages swapped in, or the error in case of failure.
    1167                 :            :  */
    1168                 :          0 : static int shmem_unuse_swap_entries(struct inode *inode, struct pagevec pvec,
    1169                 :            :                                     pgoff_t *indices)
    1170                 :            : {
    1171                 :          0 :         int i = 0;
    1172                 :          0 :         int ret = 0;
    1173                 :          0 :         int error = 0;
    1174                 :          0 :         struct address_space *mapping = inode->i_mapping;
    1175                 :            : 
    1176         [ #  # ]:          0 :         for (i = 0; i < pvec.nr; i++) {
    1177                 :          0 :                 struct page *page = pvec.pages[i];
    1178                 :            : 
    1179         [ #  # ]:          0 :                 if (!xa_is_value(page))
    1180                 :          0 :                         continue;
    1181                 :          0 :                 error = shmem_swapin_page(inode, indices[i],
    1182                 :            :                                           &page, SGP_CACHE,
    1183                 :            :                                           mapping_gfp_mask(mapping),
    1184                 :            :                                           NULL, NULL);
    1185         [ #  # ]:          0 :                 if (error == 0) {
    1186                 :          0 :                         unlock_page(page);
    1187                 :          0 :                         put_page(page);
    1188                 :          0 :                         ret++;
    1189                 :            :                 }
    1190         [ #  # ]:          0 :                 if (error == -ENOMEM)
    1191                 :            :                         break;
    1192                 :          0 :                 error = 0;
    1193                 :            :         }
    1194         [ #  # ]:          0 :         return error ? error : ret;
    1195                 :            : }
    1196                 :            : 
    1197                 :            : /*
    1198                 :            :  * If swap found in inode, free it and move page from swapcache to filecache.
    1199                 :            :  */
    1200                 :          0 : static int shmem_unuse_inode(struct inode *inode, unsigned int type,
    1201                 :            :                              bool frontswap, unsigned long *fs_pages_to_unuse)
    1202                 :            : {
    1203                 :          0 :         struct address_space *mapping = inode->i_mapping;
    1204                 :          0 :         pgoff_t start = 0;
    1205                 :          0 :         struct pagevec pvec;
    1206                 :          0 :         pgoff_t indices[PAGEVEC_SIZE];
    1207   [ #  #  #  # ]:          0 :         bool frontswap_partial = (frontswap && *fs_pages_to_unuse > 0);
    1208                 :          0 :         int ret = 0;
    1209                 :            : 
    1210                 :          0 :         pagevec_init(&pvec);
    1211                 :          0 :         do {
    1212                 :          0 :                 unsigned int nr_entries = PAGEVEC_SIZE;
    1213                 :            : 
    1214   [ #  #  #  # ]:          0 :                 if (frontswap_partial && *fs_pages_to_unuse < PAGEVEC_SIZE)
    1215                 :          0 :                         nr_entries = *fs_pages_to_unuse;
    1216                 :            : 
    1217                 :          0 :                 pvec.nr = shmem_find_swap_entries(mapping, start, nr_entries,
    1218                 :            :                                                   pvec.pages, indices,
    1219                 :            :                                                   type, frontswap);
    1220         [ #  # ]:          0 :                 if (pvec.nr == 0) {
    1221                 :            :                         ret = 0;
    1222                 :            :                         break;
    1223                 :            :                 }
    1224                 :            : 
    1225                 :          0 :                 ret = shmem_unuse_swap_entries(inode, pvec, indices);
    1226         [ #  # ]:          0 :                 if (ret < 0)
    1227                 :            :                         break;
    1228                 :            : 
    1229         [ #  # ]:          0 :                 if (frontswap_partial) {
    1230                 :          0 :                         *fs_pages_to_unuse -= ret;
    1231         [ #  # ]:          0 :                         if (*fs_pages_to_unuse == 0) {
    1232                 :            :                                 ret = FRONTSWAP_PAGES_UNUSED;
    1233                 :            :                                 break;
    1234                 :            :                         }
    1235                 :            :                 }
    1236                 :            : 
    1237                 :          0 :                 start = indices[pvec.nr - 1];
    1238                 :          0 :         } while (true);
    1239                 :            : 
    1240                 :          0 :         return ret;
    1241                 :            : }
    1242                 :            : 
    1243                 :            : /*
    1244                 :            :  * Read all the shared memory data that resides in the swap
    1245                 :            :  * device 'type' back into memory, so the swap device can be
    1246                 :            :  * unused.
    1247                 :            :  */
    1248                 :          0 : int shmem_unuse(unsigned int type, bool frontswap,
    1249                 :            :                 unsigned long *fs_pages_to_unuse)
    1250                 :            : {
    1251                 :          0 :         struct shmem_inode_info *info, *next;
    1252                 :          0 :         int error = 0;
    1253                 :            : 
    1254         [ #  # ]:          0 :         if (list_empty(&shmem_swaplist))
    1255                 :            :                 return 0;
    1256                 :            : 
    1257                 :          0 :         mutex_lock(&shmem_swaplist_mutex);
    1258         [ #  # ]:          0 :         list_for_each_entry_safe(info, next, &shmem_swaplist, swaplist) {
    1259         [ #  # ]:          0 :                 if (!info->swapped) {
    1260                 :          0 :                         list_del_init(&info->swaplist);
    1261                 :          0 :                         continue;
    1262                 :            :                 }
    1263                 :            :                 /*
    1264                 :            :                  * Drop the swaplist mutex while searching the inode for swap;
    1265                 :            :                  * but before doing so, make sure shmem_evict_inode() will not
    1266                 :            :                  * remove placeholder inode from swaplist, nor let it be freed
    1267                 :            :                  * (igrab() would protect from unlink, but not from unmount).
    1268                 :            :                  */
    1269                 :          0 :                 atomic_inc(&info->stop_eviction);
    1270                 :          0 :                 mutex_unlock(&shmem_swaplist_mutex);
    1271                 :            : 
    1272                 :          0 :                 error = shmem_unuse_inode(&info->vfs_inode, type, frontswap,
    1273                 :            :                                           fs_pages_to_unuse);
    1274                 :          0 :                 cond_resched();
    1275                 :            : 
    1276                 :          0 :                 mutex_lock(&shmem_swaplist_mutex);
    1277                 :          0 :                 next = list_next_entry(info, swaplist);
    1278         [ #  # ]:          0 :                 if (!info->swapped)
    1279                 :          0 :                         list_del_init(&info->swaplist);
    1280         [ #  # ]:          0 :                 if (atomic_dec_and_test(&info->stop_eviction))
    1281                 :          0 :                         wake_up_var(&info->stop_eviction);
    1282         [ #  # ]:          0 :                 if (error)
    1283                 :            :                         break;
    1284                 :            :         }
    1285                 :          0 :         mutex_unlock(&shmem_swaplist_mutex);
    1286                 :            : 
    1287                 :          0 :         return error;
    1288                 :            : }
    1289                 :            : 
    1290                 :            : /*
    1291                 :            :  * Move the page from the page cache to the swap cache.
    1292                 :            :  */
    1293                 :          0 : static int shmem_writepage(struct page *page, struct writeback_control *wbc)
    1294                 :            : {
    1295                 :          0 :         struct shmem_inode_info *info;
    1296                 :          0 :         struct address_space *mapping;
    1297                 :          0 :         struct inode *inode;
    1298                 :          0 :         swp_entry_t swap;
    1299                 :          0 :         pgoff_t index;
    1300                 :            : 
    1301                 :          0 :         VM_BUG_ON_PAGE(PageCompound(page), page);
    1302   [ #  #  #  # ]:          0 :         BUG_ON(!PageLocked(page));
    1303                 :          0 :         mapping = page->mapping;
    1304                 :          0 :         index = page->index;
    1305                 :          0 :         inode = mapping->host;
    1306         [ #  # ]:          0 :         info = SHMEM_I(inode);
    1307         [ #  # ]:          0 :         if (info->flags & VM_LOCKED)
    1308                 :          0 :                 goto redirty;
    1309         [ #  # ]:          0 :         if (!total_swap_pages)
    1310                 :          0 :                 goto redirty;
    1311                 :            : 
    1312                 :            :         /*
    1313                 :            :          * Our capabilities prevent regular writeback or sync from ever calling
    1314                 :            :          * shmem_writepage; but a stacking filesystem might use ->writepage of
    1315                 :            :          * its underlying filesystem, in which case tmpfs should write out to
    1316                 :            :          * swap only in response to memory pressure, and not for the writeback
    1317                 :            :          * threads or sync.
    1318                 :            :          */
    1319         [ #  # ]:          0 :         if (!wbc->for_reclaim) {
    1320                 :          0 :                 WARN_ON_ONCE(1);        /* Still happens? Tell us about it! */
    1321                 :          0 :                 goto redirty;
    1322                 :            :         }
    1323                 :            : 
    1324                 :            :         /*
    1325                 :            :          * This is somewhat ridiculous, but without plumbing a SWAP_MAP_FALLOC
    1326                 :            :          * value into swapfile.c, the only way we can correctly account for a
    1327                 :            :          * fallocated page arriving here is now to initialize it and write it.
    1328                 :            :          *
    1329                 :            :          * That's okay for a page already fallocated earlier, but if we have
    1330                 :            :          * not yet completed the fallocation, then (a) we want to keep track
    1331                 :            :          * of this page in case we have to undo it, and (b) it may not be a
    1332                 :            :          * good idea to continue anyway, once we're pushing into swap.  So
    1333                 :            :          * reactivate the page, and let shmem_fallocate() quit when too many.
    1334                 :            :          */
    1335         [ #  # ]:          0 :         if (!PageUptodate(page)) {
    1336         [ #  # ]:          0 :                 if (inode->i_private) {
    1337                 :          0 :                         struct shmem_falloc *shmem_falloc;
    1338                 :          0 :                         spin_lock(&inode->i_lock);
    1339                 :          0 :                         shmem_falloc = inode->i_private;
    1340         [ #  # ]:          0 :                         if (shmem_falloc &&
    1341         [ #  # ]:          0 :                             !shmem_falloc->waitq &&
    1342         [ #  # ]:          0 :                             index >= shmem_falloc->start &&
    1343         [ #  # ]:          0 :                             index < shmem_falloc->next)
    1344                 :          0 :                                 shmem_falloc->nr_unswapped++;
    1345                 :            :                         else
    1346                 :            :                                 shmem_falloc = NULL;
    1347                 :          0 :                         spin_unlock(&inode->i_lock);
    1348         [ #  # ]:          0 :                         if (shmem_falloc)
    1349                 :          0 :                                 goto redirty;
    1350                 :            :                 }
    1351                 :          0 :                 clear_highpage(page);
    1352                 :          0 :                 flush_dcache_page(page);
    1353                 :          0 :                 SetPageUptodate(page);
    1354                 :            :         }
    1355                 :            : 
    1356                 :          0 :         swap = get_swap_page(page);
    1357         [ #  # ]:          0 :         if (!swap.val)
    1358                 :          0 :                 goto redirty;
    1359                 :            : 
    1360                 :            :         /*
    1361                 :            :          * Add inode to shmem_unuse()'s list of swapped-out inodes,
    1362                 :            :          * if it's not already there.  Do it now before the page is
    1363                 :            :          * moved to swap cache, when its pagelock no longer protects
    1364                 :            :          * the inode from eviction.  But don't unlock the mutex until
    1365                 :            :          * we've incremented swapped, because shmem_unuse_inode() will
    1366                 :            :          * prune a !swapped inode from the swaplist under this mutex.
    1367                 :            :          */
    1368                 :          0 :         mutex_lock(&shmem_swaplist_mutex);
    1369         [ #  # ]:          0 :         if (list_empty(&info->swaplist))
    1370                 :          0 :                 list_add(&info->swaplist, &shmem_swaplist);
    1371                 :            : 
    1372         [ #  # ]:          0 :         if (add_to_swap_cache(page, swap,
    1373                 :            :                         __GFP_HIGH | __GFP_NOMEMALLOC | __GFP_NOWARN) == 0) {
    1374                 :          0 :                 spin_lock_irq(&info->lock);
    1375                 :          0 :                 shmem_recalc_inode(inode);
    1376                 :          0 :                 info->swapped++;
    1377                 :          0 :                 spin_unlock_irq(&info->lock);
    1378                 :            : 
    1379                 :          0 :                 swap_shmem_alloc(swap);
    1380         [ #  # ]:          0 :                 shmem_delete_from_page_cache(page, swp_to_radix_entry(swap));
    1381                 :            : 
    1382                 :          0 :                 mutex_unlock(&shmem_swaplist_mutex);
    1383         [ #  # ]:          0 :                 BUG_ON(page_mapped(page));
    1384                 :          0 :                 swap_writepage(page, wbc);
    1385                 :          0 :                 return 0;
    1386                 :            :         }
    1387                 :            : 
    1388                 :          0 :         mutex_unlock(&shmem_swaplist_mutex);
    1389                 :          0 :         put_swap_page(page, swap);
    1390                 :          0 : redirty:
    1391                 :          0 :         set_page_dirty(page);
    1392         [ #  # ]:          0 :         if (wbc->for_reclaim)
    1393                 :            :                 return AOP_WRITEPAGE_ACTIVATE;  /* Return with page locked */
    1394                 :          0 :         unlock_page(page);
    1395                 :          0 :         return 0;
    1396                 :            : }
    1397                 :            : 
    1398                 :            : #if defined(CONFIG_NUMA) && defined(CONFIG_TMPFS)
    1399                 :      65520 : static void shmem_show_mpol(struct seq_file *seq, struct mempolicy *mpol)
    1400                 :            : {
    1401                 :      65520 :         char buffer[64];
    1402                 :            : 
    1403   [ -  +  -  - ]:      65520 :         if (!mpol || mpol->mode == MPOL_DEFAULT)
    1404                 :      65520 :                 return;         /* show nothing */
    1405                 :            : 
    1406                 :          0 :         mpol_to_str(buffer, sizeof(buffer), mpol);
    1407                 :            : 
    1408                 :          0 :         seq_printf(seq, ",mpol=%s", buffer);
    1409                 :            : }
    1410                 :            : 
    1411                 :      25811 : static struct mempolicy *shmem_get_sbmpol(struct shmem_sb_info *sbinfo)
    1412                 :            : {
    1413                 :      25811 :         struct mempolicy *mpol = NULL;
    1414         [ -  + ]:      25811 :         if (sbinfo->mpol) {
    1415                 :          0 :                 spin_lock(&sbinfo->stat_lock);   /* prevent replace/use races */
    1416                 :          0 :                 mpol = sbinfo->mpol;
    1417         [ #  # ]:          0 :                 mpol_get(mpol);
    1418                 :          0 :                 spin_unlock(&sbinfo->stat_lock);
    1419                 :            :         }
    1420                 :      25811 :         return mpol;
    1421                 :            : }
    1422                 :            : #else /* !CONFIG_NUMA || !CONFIG_TMPFS */
    1423                 :            : static inline void shmem_show_mpol(struct seq_file *seq, struct mempolicy *mpol)
    1424                 :            : {
    1425                 :            : }
    1426                 :            : static inline struct mempolicy *shmem_get_sbmpol(struct shmem_sb_info *sbinfo)
    1427                 :            : {
    1428                 :            :         return NULL;
    1429                 :            : }
    1430                 :            : #endif /* CONFIG_NUMA && CONFIG_TMPFS */
    1431                 :            : #ifndef CONFIG_NUMA
    1432                 :            : #define vm_policy vm_private_data
    1433                 :            : #endif
    1434                 :            : 
    1435                 :     102636 : static void shmem_pseudo_vma_init(struct vm_area_struct *vma,
    1436                 :            :                 struct shmem_inode_info *info, pgoff_t index)
    1437                 :            : {
    1438                 :            :         /* Create a pseudo vma that just contains the policy */
    1439                 :     102636 :         vma_init(vma, NULL);
    1440                 :            :         /* Bias interleave by inode number to distribute better across nodes */
    1441                 :     102636 :         vma->vm_pgoff = index + info->vfs_inode.i_ino;
    1442                 :     102636 :         vma->vm_policy = mpol_shared_policy_lookup(&info->policy, index);
    1443                 :     102636 : }
    1444                 :            : 
    1445                 :     102636 : static void shmem_pseudo_vma_destroy(struct vm_area_struct *vma)
    1446                 :            : {
    1447                 :            :         /* Drop reference taken by mpol_shared_policy_lookup() */
    1448                 :     102636 :         mpol_cond_put(vma->vm_policy);
    1449                 :            : }
    1450                 :            : 
    1451                 :          0 : static struct page *shmem_swapin(swp_entry_t swap, gfp_t gfp,
    1452                 :            :                         struct shmem_inode_info *info, pgoff_t index)
    1453                 :            : {
    1454                 :          0 :         struct vm_area_struct pvma;
    1455                 :          0 :         struct page *page;
    1456                 :          0 :         struct vm_fault vmf;
    1457                 :            : 
    1458                 :          0 :         shmem_pseudo_vma_init(&pvma, info, index);
    1459                 :          0 :         vmf.vma = &pvma;
    1460                 :          0 :         vmf.address = 0;
    1461                 :          0 :         page = swap_cluster_readahead(swap, gfp, &vmf);
    1462         [ #  # ]:          0 :         shmem_pseudo_vma_destroy(&pvma);
    1463                 :            : 
    1464                 :          0 :         return page;
    1465                 :            : }
    1466                 :            : 
    1467                 :            : static struct page *shmem_alloc_hugepage(gfp_t gfp,
    1468                 :            :                 struct shmem_inode_info *info, pgoff_t index)
    1469                 :            : {
    1470                 :            :         struct vm_area_struct pvma;
    1471                 :            :         struct address_space *mapping = info->vfs_inode.i_mapping;
    1472                 :            :         pgoff_t hindex;
    1473                 :            :         struct page *page;
    1474                 :            : 
    1475                 :            :         if (!IS_ENABLED(CONFIG_TRANSPARENT_HUGE_PAGECACHE))
    1476                 :            :                 return NULL;
    1477                 :            : 
    1478                 :            :         hindex = round_down(index, HPAGE_PMD_NR);
    1479                 :            :         if (xa_find(&mapping->i_pages, &hindex, hindex + HPAGE_PMD_NR - 1,
    1480                 :            :                                                                 XA_PRESENT))
    1481                 :            :                 return NULL;
    1482                 :            : 
    1483                 :            :         shmem_pseudo_vma_init(&pvma, info, hindex);
    1484                 :            :         page = alloc_pages_vma(gfp | __GFP_COMP | __GFP_NORETRY | __GFP_NOWARN,
    1485                 :            :                         HPAGE_PMD_ORDER, &pvma, 0, numa_node_id(), true);
    1486                 :            :         shmem_pseudo_vma_destroy(&pvma);
    1487                 :            :         if (page)
    1488                 :            :                 prep_transhuge_page(page);
    1489                 :            :         return page;
    1490                 :            : }
    1491                 :            : 
    1492                 :     102636 : static struct page *shmem_alloc_page(gfp_t gfp,
    1493                 :            :                         struct shmem_inode_info *info, pgoff_t index)
    1494                 :            : {
    1495                 :     102636 :         struct vm_area_struct pvma;
    1496                 :     102636 :         struct page *page;
    1497                 :            : 
    1498                 :     102636 :         shmem_pseudo_vma_init(&pvma, info, index);
    1499                 :     102636 :         page = alloc_page_vma(gfp, &pvma, 0);
    1500         [ -  + ]:     102636 :         shmem_pseudo_vma_destroy(&pvma);
    1501                 :            : 
    1502                 :     102636 :         return page;
    1503                 :            : }
    1504                 :            : 
    1505                 :     102636 : static struct page *shmem_alloc_and_acct_page(gfp_t gfp,
    1506                 :            :                 struct inode *inode,
    1507                 :            :                 pgoff_t index, bool huge)
    1508                 :            : {
    1509                 :     102636 :         struct shmem_inode_info *info = SHMEM_I(inode);
    1510                 :     102636 :         struct page *page;
    1511                 :     102636 :         int nr;
    1512                 :     102636 :         int err = -ENOSPC;
    1513                 :            : 
    1514                 :     102636 :         if (!IS_ENABLED(CONFIG_TRANSPARENT_HUGE_PAGECACHE))
    1515                 :     102636 :                 huge = false;
    1516                 :     102636 :         nr = huge ? HPAGE_PMD_NR : 1;
    1517                 :            : 
    1518         [ -  + ]:     102636 :         if (!shmem_inode_acct_block(inode, nr))
    1519                 :          0 :                 goto failed;
    1520                 :            : 
    1521                 :     102636 :         if (huge)
    1522                 :            :                 page = shmem_alloc_hugepage(gfp, info, index);
    1523                 :            :         else
    1524                 :     102636 :                 page = shmem_alloc_page(gfp, info, index);
    1525         [ +  - ]:     102636 :         if (page) {
    1526         [ -  + ]:     102636 :                 __SetPageLocked(page);
    1527         [ -  + ]:     102636 :                 __SetPageSwapBacked(page);
    1528                 :     102636 :                 return page;
    1529                 :            :         }
    1530                 :            : 
    1531                 :          0 :         err = -ENOMEM;
    1532                 :          0 :         shmem_inode_unacct_blocks(inode, nr);
    1533                 :          0 : failed:
    1534                 :          0 :         return ERR_PTR(err);
    1535                 :            : }
    1536                 :            : 
    1537                 :            : /*
    1538                 :            :  * When a page is moved from swapcache to shmem filecache (either by the
    1539                 :            :  * usual swapin of shmem_getpage_gfp(), or by the less common swapoff of
    1540                 :            :  * shmem_unuse_inode()), it may have been read in earlier from swap, in
    1541                 :            :  * ignorance of the mapping it belongs to.  If that mapping has special
    1542                 :            :  * constraints (like the gma500 GEM driver, which requires RAM below 4GB),
    1543                 :            :  * we may need to copy to a suitable page before moving to filecache.
    1544                 :            :  *
    1545                 :            :  * In a future release, this may well be extended to respect cpuset and
    1546                 :            :  * NUMA mempolicy, and applied also to anonymous pages in do_swap_page();
    1547                 :            :  * but for now it is a simple matter of zone.
    1548                 :            :  */
    1549                 :          0 : static bool shmem_should_replace_page(struct page *page, gfp_t gfp)
    1550                 :            : {
    1551                 :          0 :         return page_zonenum(page) > gfp_zone(gfp);
    1552                 :            : }
    1553                 :            : 
    1554                 :          0 : static int shmem_replace_page(struct page **pagep, gfp_t gfp,
    1555                 :            :                                 struct shmem_inode_info *info, pgoff_t index)
    1556                 :            : {
    1557                 :          0 :         struct page *oldpage, *newpage;
    1558                 :          0 :         struct address_space *swap_mapping;
    1559                 :          0 :         swp_entry_t entry;
    1560                 :          0 :         pgoff_t swap_index;
    1561                 :          0 :         int error;
    1562                 :            : 
    1563                 :          0 :         oldpage = *pagep;
    1564                 :          0 :         entry.val = page_private(oldpage);
    1565                 :          0 :         swap_index = swp_offset(entry);
    1566                 :          0 :         swap_mapping = page_mapping(oldpage);
    1567                 :            : 
    1568                 :            :         /*
    1569                 :            :          * We have arrived here because our zones are constrained, so don't
    1570                 :            :          * limit chance of success by further cpuset and node constraints.
    1571                 :            :          */
    1572                 :          0 :         gfp &= ~GFP_CONSTRAINT_MASK;
    1573                 :          0 :         newpage = shmem_alloc_page(gfp, info, index);
    1574         [ #  # ]:          0 :         if (!newpage)
    1575                 :            :                 return -ENOMEM;
    1576                 :            : 
    1577         [ #  # ]:          0 :         get_page(newpage);
    1578                 :          0 :         copy_highpage(newpage, oldpage);
    1579         [ #  # ]:          0 :         flush_dcache_page(newpage);
    1580                 :            : 
    1581         [ #  # ]:          0 :         __SetPageLocked(newpage);
    1582         [ #  # ]:          0 :         __SetPageSwapBacked(newpage);
    1583                 :          0 :         SetPageUptodate(newpage);
    1584                 :          0 :         set_page_private(newpage, entry.val);
    1585         [ #  # ]:          0 :         SetPageSwapCache(newpage);
    1586                 :            : 
    1587                 :            :         /*
    1588                 :            :          * Our caller will very soon move newpage out of swapcache, but it's
    1589                 :            :          * a nice clean interface for us to replace oldpage by newpage there.
    1590                 :            :          */
    1591                 :          0 :         xa_lock_irq(&swap_mapping->i_pages);
    1592                 :          0 :         error = shmem_replace_entry(swap_mapping, swap_index, oldpage, newpage);
    1593         [ #  # ]:          0 :         if (!error) {
    1594                 :          0 :                 __inc_node_page_state(newpage, NR_FILE_PAGES);
    1595                 :          0 :                 __dec_node_page_state(oldpage, NR_FILE_PAGES);
    1596                 :            :         }
    1597                 :          0 :         xa_unlock_irq(&swap_mapping->i_pages);
    1598                 :            : 
    1599         [ #  # ]:          0 :         if (unlikely(error)) {
    1600                 :            :                 /*
    1601                 :            :                  * Is this possible?  I think not, now that our callers check
    1602                 :            :                  * both PageSwapCache and page_private after getting page lock;
    1603                 :            :                  * but be defensive.  Reverse old to newpage for clear and free.
    1604                 :            :                  */
    1605                 :            :                 oldpage = newpage;
    1606                 :            :         } else {
    1607                 :          0 :                 mem_cgroup_migrate(oldpage, newpage);
    1608                 :          0 :                 lru_cache_add_anon(newpage);
    1609                 :          0 :                 *pagep = newpage;
    1610                 :            :         }
    1611                 :            : 
    1612         [ #  # ]:          0 :         ClearPageSwapCache(oldpage);
    1613                 :          0 :         set_page_private(oldpage, 0);
    1614                 :            : 
    1615                 :          0 :         unlock_page(oldpage);
    1616                 :          0 :         put_page(oldpage);
    1617                 :          0 :         put_page(oldpage);
    1618                 :          0 :         return error;
    1619                 :            : }
    1620                 :            : 
    1621                 :            : /*
    1622                 :            :  * Swap in the page pointed to by *pagep.
    1623                 :            :  * Caller has to make sure that *pagep contains a valid swapped page.
    1624                 :            :  * Returns 0 and the page in pagep if success. On failure, returns the
    1625                 :            :  * the error code and NULL in *pagep.
    1626                 :            :  */
    1627                 :          0 : static int shmem_swapin_page(struct inode *inode, pgoff_t index,
    1628                 :            :                              struct page **pagep, enum sgp_type sgp,
    1629                 :            :                              gfp_t gfp, struct vm_area_struct *vma,
    1630                 :            :                              vm_fault_t *fault_type)
    1631                 :            : {
    1632                 :          0 :         struct address_space *mapping = inode->i_mapping;
    1633         [ #  # ]:          0 :         struct shmem_inode_info *info = SHMEM_I(inode);
    1634         [ #  # ]:          0 :         struct mm_struct *charge_mm = vma ? vma->vm_mm : current->mm;
    1635                 :          0 :         struct mem_cgroup *memcg;
    1636                 :          0 :         struct page *page;
    1637                 :          0 :         swp_entry_t swap;
    1638                 :          0 :         int error;
    1639                 :            : 
    1640                 :          0 :         VM_BUG_ON(!*pagep || !xa_is_value(*pagep));
    1641                 :          0 :         swap = radix_to_swp_entry(*pagep);
    1642                 :          0 :         *pagep = NULL;
    1643                 :            : 
    1644                 :            :         /* Look it up and read it in.. */
    1645                 :          0 :         page = lookup_swap_cache(swap, NULL, 0);
    1646         [ #  # ]:          0 :         if (!page) {
    1647                 :            :                 /* Or update major stats only when swapin succeeds?? */
    1648         [ #  # ]:          0 :                 if (fault_type) {
    1649                 :          0 :                         *fault_type |= VM_FAULT_MAJOR;
    1650                 :          0 :                         count_vm_event(PGMAJFAULT);
    1651                 :            :                         count_memcg_event_mm(charge_mm, PGMAJFAULT);
    1652                 :            :                 }
    1653                 :            :                 /* Here we actually start the io */
    1654                 :          0 :                 page = shmem_swapin(swap, gfp, info, index);
    1655         [ #  # ]:          0 :                 if (!page) {
    1656                 :          0 :                         error = -ENOMEM;
    1657                 :          0 :                         goto failed;
    1658                 :            :                 }
    1659                 :            :         }
    1660                 :            : 
    1661                 :            :         /* We have to do this with page locked to prevent races */
    1662                 :          0 :         lock_page(page);
    1663   [ #  #  #  #  :          0 :         if (!PageSwapCache(page) || page_private(page) != swap.val ||
                   #  # ]
    1664                 :          0 :             !shmem_confirm_swap(mapping, index, swap)) {
    1665                 :          0 :                 error = -EEXIST;
    1666                 :          0 :                 goto unlock;
    1667                 :            :         }
    1668         [ #  # ]:          0 :         if (!PageUptodate(page)) {
    1669                 :          0 :                 error = -EIO;
    1670                 :          0 :                 goto failed;
    1671                 :            :         }
    1672                 :          0 :         wait_on_page_writeback(page);
    1673                 :            : 
    1674         [ #  # ]:          0 :         if (shmem_should_replace_page(page, gfp)) {
    1675                 :          0 :                 error = shmem_replace_page(&page, gfp, info, index);
    1676         [ #  # ]:          0 :                 if (error)
    1677                 :          0 :                         goto failed;
    1678                 :            :         }
    1679                 :            : 
    1680                 :          0 :         error = mem_cgroup_try_charge_delay(page, charge_mm, gfp, &memcg,
    1681                 :            :                                             false);
    1682                 :          0 :         if (!error) {
    1683                 :          0 :                 error = shmem_add_to_page_cache(page, mapping, index,
    1684                 :            :                                                 swp_to_radix_entry(swap), gfp);
    1685                 :            :                 /*
    1686                 :            :                  * We already confirmed swap under page lock, and make
    1687                 :            :                  * no memory allocation here, so usually no possibility
    1688                 :            :                  * of error; but free_swap_and_cache() only trylocks a
    1689                 :            :                  * page, so it is just possible that the entry has been
    1690                 :            :                  * truncated or holepunched since swap was confirmed.
    1691                 :            :                  * shmem_undo_range() will have done some of the
    1692                 :            :                  * unaccounting, now delete_from_swap_cache() will do
    1693                 :            :                  * the rest.
    1694                 :            :                  */
    1695         [ #  # ]:          0 :                 if (error) {
    1696                 :          0 :                         mem_cgroup_cancel_charge(page, memcg, false);
    1697                 :          0 :                         delete_from_swap_cache(page);
    1698                 :            :                 }
    1699                 :            :         }
    1700         [ #  # ]:          0 :         if (error)
    1701                 :          0 :                 goto failed;
    1702                 :            : 
    1703                 :          0 :         mem_cgroup_commit_charge(page, memcg, true, false);
    1704                 :            : 
    1705                 :          0 :         spin_lock_irq(&info->lock);
    1706                 :          0 :         info->swapped--;
    1707                 :          0 :         shmem_recalc_inode(inode);
    1708                 :          0 :         spin_unlock_irq(&info->lock);
    1709                 :            : 
    1710         [ #  # ]:          0 :         if (sgp == SGP_WRITE)
    1711                 :          0 :                 mark_page_accessed(page);
    1712                 :            : 
    1713                 :          0 :         delete_from_swap_cache(page);
    1714                 :          0 :         set_page_dirty(page);
    1715                 :          0 :         swap_free(swap);
    1716                 :            : 
    1717                 :          0 :         *pagep = page;
    1718                 :          0 :         return 0;
    1719                 :          0 : failed:
    1720         [ #  # ]:          0 :         if (!shmem_confirm_swap(mapping, index, swap))
    1721                 :          0 :                 error = -EEXIST;
    1722                 :          0 : unlock:
    1723         [ #  # ]:          0 :         if (page) {
    1724                 :          0 :                 unlock_page(page);
    1725                 :          0 :                 put_page(page);
    1726                 :            :         }
    1727                 :            : 
    1728                 :            :         return error;
    1729                 :            : }
    1730                 :            : 
    1731                 :            : /*
    1732                 :            :  * shmem_getpage_gfp - find page in cache, or get from swap, or allocate
    1733                 :            :  *
    1734                 :            :  * If we allocate a new one we do not mark it dirty. That's up to the
    1735                 :            :  * vm. If we swap it in we mark it dirty since we also free the swap
    1736                 :            :  * entry since a page cannot live in both the swap and page cache.
    1737                 :            :  *
    1738                 :            :  * vmf and fault_type are only supplied by shmem_fault:
    1739                 :            :  * otherwise they are NULL.
    1740                 :            :  */
    1741                 :            : static int shmem_getpage_gfp(struct inode *inode, pgoff_t index,
    1742                 :            :         struct page **pagep, enum sgp_type sgp, gfp_t gfp,
    1743                 :            :         struct vm_area_struct *vma, struct vm_fault *vmf,
    1744                 :            :                         vm_fault_t *fault_type)
    1745                 :            : {
    1746                 :            :         struct address_space *mapping = inode->i_mapping;
    1747                 :            :         struct shmem_inode_info *info = SHMEM_I(inode);
    1748                 :            :         struct shmem_sb_info *sbinfo;
    1749                 :            :         struct mm_struct *charge_mm;
    1750                 :            :         struct mem_cgroup *memcg;
    1751                 :            :         struct page *page;
    1752                 :            :         enum sgp_type sgp_huge = sgp;
    1753                 :            :         pgoff_t hindex = index;
    1754                 :            :         int error;
    1755                 :            :         int once = 0;
    1756                 :            :         int alloced = 0;
    1757                 :            : 
    1758                 :            :         if (index > (MAX_LFS_FILESIZE >> PAGE_SHIFT))
    1759                 :            :                 return -EFBIG;
    1760                 :            :         if (sgp == SGP_NOHUGE || sgp == SGP_HUGE)
    1761                 :            :                 sgp = SGP_CACHE;
    1762                 :            : repeat:
    1763                 :            :         if (sgp <= SGP_CACHE &&
    1764                 :            :             ((loff_t)index << PAGE_SHIFT) >= i_size_read(inode)) {
    1765                 :            :                 return -EINVAL;
    1766                 :            :         }
    1767                 :            : 
    1768                 :            :         sbinfo = SHMEM_SB(inode->i_sb);
    1769                 :            :         charge_mm = vma ? vma->vm_mm : current->mm;
    1770                 :            : 
    1771                 :            :         page = find_lock_entry(mapping, index);
    1772                 :            :         if (xa_is_value(page)) {
    1773                 :            :                 error = shmem_swapin_page(inode, index, &page,
    1774                 :            :                                           sgp, gfp, vma, fault_type);
    1775                 :            :                 if (error == -EEXIST)
    1776                 :            :                         goto repeat;
    1777                 :            : 
    1778                 :            :                 *pagep = page;
    1779                 :            :                 return error;
    1780                 :            :         }
    1781                 :            : 
    1782                 :            :         if (page && sgp == SGP_WRITE)
    1783                 :            :                 mark_page_accessed(page);
    1784                 :            : 
    1785                 :            :         /* fallocated page? */
    1786                 :            :         if (page && !PageUptodate(page)) {
    1787                 :            :                 if (sgp != SGP_READ)
    1788                 :            :                         goto clear;
    1789                 :            :                 unlock_page(page);
    1790                 :            :                 put_page(page);
    1791                 :            :                 page = NULL;
    1792                 :            :         }
    1793                 :            :         if (page || sgp == SGP_READ) {
    1794                 :            :                 *pagep = page;
    1795                 :            :                 return 0;
    1796                 :            :         }
    1797                 :            : 
    1798                 :            :         /*
    1799                 :            :          * Fast cache lookup did not find it:
    1800                 :            :          * bring it back from swap or allocate.
    1801                 :            :          */
    1802                 :            : 
    1803                 :            :         if (vma && userfaultfd_missing(vma)) {
    1804                 :            :                 *fault_type = handle_userfault(vmf, VM_UFFD_MISSING);
    1805                 :            :                 return 0;
    1806                 :            :         }
    1807                 :            : 
    1808                 :            :         /* shmem_symlink() */
    1809                 :            :         if (mapping->a_ops != &shmem_aops)
    1810                 :            :                 goto alloc_nohuge;
    1811                 :            :         if (shmem_huge == SHMEM_HUGE_DENY || sgp_huge == SGP_NOHUGE)
    1812                 :            :                 goto alloc_nohuge;
    1813                 :            :         if (shmem_huge == SHMEM_HUGE_FORCE)
    1814                 :            :                 goto alloc_huge;
    1815                 :            :         switch (sbinfo->huge) {
    1816                 :            :                 loff_t i_size;
    1817                 :            :                 pgoff_t off;
    1818                 :            :         case SHMEM_HUGE_NEVER:
    1819                 :            :                 goto alloc_nohuge;
    1820                 :            :         case SHMEM_HUGE_WITHIN_SIZE:
    1821                 :            :                 off = round_up(index, HPAGE_PMD_NR);
    1822                 :            :                 i_size = round_up(i_size_read(inode), PAGE_SIZE);
    1823                 :            :                 if (i_size >= HPAGE_PMD_SIZE &&
    1824                 :            :                     i_size >> PAGE_SHIFT >= off)
    1825                 :            :                         goto alloc_huge;
    1826                 :            :                 /* fallthrough */
    1827                 :            :         case SHMEM_HUGE_ADVISE:
    1828                 :            :                 if (sgp_huge == SGP_HUGE)
    1829                 :            :                         goto alloc_huge;
    1830                 :            :                 /* TODO: implement fadvise() hints */
    1831                 :            :                 goto alloc_nohuge;
    1832                 :            :         }
    1833                 :            : 
    1834                 :            : alloc_huge:
    1835                 :            :         page = shmem_alloc_and_acct_page(gfp, inode, index, true);
    1836                 :            :         if (IS_ERR(page)) {
    1837                 :            : alloc_nohuge:
    1838                 :            :                 page = shmem_alloc_and_acct_page(gfp, inode,
    1839                 :            :                                                  index, false);
    1840                 :            :         }
    1841                 :            :         if (IS_ERR(page)) {
    1842                 :            :                 int retry = 5;
    1843                 :            : 
    1844                 :            :                 error = PTR_ERR(page);
    1845                 :            :                 page = NULL;
    1846                 :            :                 if (error != -ENOSPC)
    1847                 :            :                         goto unlock;
    1848                 :            :                 /*
    1849                 :            :                  * Try to reclaim some space by splitting a huge page
    1850                 :            :                  * beyond i_size on the filesystem.
    1851                 :            :                  */
    1852                 :            :                 while (retry--) {
    1853                 :            :                         int ret;
    1854                 :            : 
    1855                 :            :                         ret = shmem_unused_huge_shrink(sbinfo, NULL, 1);
    1856                 :            :                         if (ret == SHRINK_STOP)
    1857                 :            :                                 break;
    1858                 :            :                         if (ret)
    1859                 :            :                                 goto alloc_nohuge;
    1860                 :            :                 }
    1861                 :            :                 goto unlock;
    1862                 :            :         }
    1863                 :            : 
    1864                 :            :         if (PageTransHuge(page))
    1865                 :            :                 hindex = round_down(index, HPAGE_PMD_NR);
    1866                 :            :         else
    1867                 :            :                 hindex = index;
    1868                 :            : 
    1869                 :            :         if (sgp == SGP_WRITE)
    1870                 :            :                 __SetPageReferenced(page);
    1871                 :            : 
    1872                 :            :         error = mem_cgroup_try_charge_delay(page, charge_mm, gfp, &memcg,
    1873                 :            :                                             PageTransHuge(page));
    1874                 :            :         if (error)
    1875                 :            :                 goto unacct;
    1876                 :            :         error = shmem_add_to_page_cache(page, mapping, hindex,
    1877                 :            :                                         NULL, gfp & GFP_RECLAIM_MASK);
    1878                 :            :         if (error) {
    1879                 :            :                 mem_cgroup_cancel_charge(page, memcg,
    1880                 :            :                                          PageTransHuge(page));
    1881                 :            :                 goto unacct;
    1882                 :            :         }
    1883                 :            :         mem_cgroup_commit_charge(page, memcg, false,
    1884                 :            :                                  PageTransHuge(page));
    1885                 :            :         lru_cache_add_anon(page);
    1886                 :            : 
    1887                 :            :         spin_lock_irq(&info->lock);
    1888                 :            :         info->alloced += compound_nr(page);
    1889                 :            :         inode->i_blocks += BLOCKS_PER_PAGE << compound_order(page);
    1890                 :            :         shmem_recalc_inode(inode);
    1891                 :            :         spin_unlock_irq(&info->lock);
    1892                 :            :         alloced = true;
    1893                 :            : 
    1894                 :            :         if (PageTransHuge(page) &&
    1895                 :            :             DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE) <
    1896                 :            :                         hindex + HPAGE_PMD_NR - 1) {
    1897                 :            :                 /*
    1898                 :            :                  * Part of the huge page is beyond i_size: subject
    1899                 :            :                  * to shrink under memory pressure.
    1900                 :            :                  */
    1901                 :            :                 spin_lock(&sbinfo->shrinklist_lock);
    1902                 :            :                 /*
    1903                 :            :                  * _careful to defend against unlocked access to
    1904                 :            :                  * ->shrink_list in shmem_unused_huge_shrink()
    1905                 :            :                  */
    1906                 :            :                 if (list_empty_careful(&info->shrinklist)) {
    1907                 :            :                         list_add_tail(&info->shrinklist,
    1908                 :            :                                       &sbinfo->shrinklist);
    1909                 :            :                         sbinfo->shrinklist_len++;
    1910                 :            :                 }
    1911                 :            :                 spin_unlock(&sbinfo->shrinklist_lock);
    1912                 :            :         }
    1913                 :            : 
    1914                 :            :         /*
    1915                 :            :          * Let SGP_FALLOC use the SGP_WRITE optimization on a new page.
    1916                 :            :          */
    1917                 :            :         if (sgp == SGP_FALLOC)
    1918                 :            :                 sgp = SGP_WRITE;
    1919                 :            : clear:
    1920                 :            :         /*
    1921                 :            :          * Let SGP_WRITE caller clear ends if write does not fill page;
    1922                 :            :          * but SGP_FALLOC on a page fallocated earlier must initialize
    1923                 :            :          * it now, lest undo on failure cancel our earlier guarantee.
    1924                 :            :          */
    1925                 :            :         if (sgp != SGP_WRITE && !PageUptodate(page)) {
    1926                 :            :                 struct page *head = compound_head(page);
    1927                 :            :                 int i;
    1928                 :            : 
    1929                 :            :                 for (i = 0; i < compound_nr(head); i++) {
    1930                 :            :                         clear_highpage(head + i);
    1931                 :            :                         flush_dcache_page(head + i);
    1932                 :            :                 }
    1933                 :            :                 SetPageUptodate(head);
    1934                 :            :         }
    1935                 :            : 
    1936                 :            :         /* Perhaps the file has been truncated since we checked */
    1937                 :            :         if (sgp <= SGP_CACHE &&
    1938                 :            :             ((loff_t)index << PAGE_SHIFT) >= i_size_read(inode)) {
    1939                 :            :                 if (alloced) {
    1940                 :            :                         ClearPageDirty(page);
    1941                 :            :                         delete_from_page_cache(page);
    1942                 :            :                         spin_lock_irq(&info->lock);
    1943                 :            :                         shmem_recalc_inode(inode);
    1944                 :            :                         spin_unlock_irq(&info->lock);
    1945                 :            :                 }
    1946                 :            :                 error = -EINVAL;
    1947                 :            :                 goto unlock;
    1948                 :            :         }
    1949                 :            :         *pagep = page + index - hindex;
    1950                 :            :         return 0;
    1951                 :            : 
    1952                 :            :         /*
    1953                 :            :          * Error recovery.
    1954                 :            :          */
    1955                 :            : unacct:
    1956                 :            :         shmem_inode_unacct_blocks(inode, compound_nr(page));
    1957                 :            : 
    1958                 :            :         if (PageTransHuge(page)) {
    1959                 :            :                 unlock_page(page);
    1960                 :            :                 put_page(page);
    1961                 :            :                 goto alloc_nohuge;
    1962                 :            :         }
    1963                 :            : unlock:
    1964                 :            :         if (page) {
    1965                 :            :                 unlock_page(page);
    1966                 :            :                 put_page(page);
    1967                 :            :         }
    1968                 :            :         if (error == -ENOSPC && !once++) {
    1969                 :            :                 spin_lock_irq(&info->lock);
    1970                 :            :                 shmem_recalc_inode(inode);
    1971                 :            :                 spin_unlock_irq(&info->lock);
    1972                 :            :                 goto repeat;
    1973                 :            :         }
    1974                 :            :         if (error == -EEXIST)
    1975                 :            :                 goto repeat;
    1976                 :            :         return error;
    1977                 :            : }
    1978                 :            : 
    1979                 :            : /*
    1980                 :            :  * This is like autoremove_wake_function, but it removes the wait queue
    1981                 :            :  * entry unconditionally - even if something else had already woken the
    1982                 :            :  * target.
    1983                 :            :  */
    1984                 :          0 : static int synchronous_wake_function(wait_queue_entry_t *wait, unsigned mode, int sync, void *key)
    1985                 :            : {
    1986                 :          0 :         int ret = default_wake_function(wait, mode, sync, key);
    1987                 :          0 :         list_del_init(&wait->entry);
    1988                 :          0 :         return ret;
    1989                 :            : }
    1990                 :            : 
    1991                 :      10490 : static vm_fault_t shmem_fault(struct vm_fault *vmf)
    1992                 :            : {
    1993                 :      10490 :         struct vm_area_struct *vma = vmf->vma;
    1994         [ -  + ]:      10490 :         struct inode *inode = file_inode(vma->vm_file);
    1995         [ -  + ]:      10490 :         gfp_t gfp = mapping_gfp_mask(inode->i_mapping);
    1996                 :      10490 :         enum sgp_type sgp;
    1997                 :      10490 :         int err;
    1998                 :      10490 :         vm_fault_t ret = VM_FAULT_LOCKED;
    1999                 :            : 
    2000                 :            :         /*
    2001                 :            :          * Trinity finds that probing a hole which tmpfs is punching can
    2002                 :            :          * prevent the hole-punch from ever completing: which in turn
    2003                 :            :          * locks writers out with its hold on i_mutex.  So refrain from
    2004                 :            :          * faulting pages into the hole while it's being punched.  Although
    2005                 :            :          * shmem_undo_range() does remove the additions, it may be unable to
    2006                 :            :          * keep up, as each new page needs its own unmap_mapping_range() call,
    2007                 :            :          * and the i_mmap tree grows ever slower to scan if new vmas are added.
    2008                 :            :          *
    2009                 :            :          * It does not matter if we sometimes reach this check just before the
    2010                 :            :          * hole-punch begins, so that one fault then races with the punch:
    2011                 :            :          * we just need to make racing faults a rare case.
    2012                 :            :          *
    2013                 :            :          * The implementation below would be much simpler if we just used a
    2014                 :            :          * standard mutex or completion: but we cannot take i_mutex in fault,
    2015                 :            :          * and bloating every shmem inode for this unlikely case would be sad.
    2016                 :            :          */
    2017         [ -  + ]:      10490 :         if (unlikely(inode->i_private)) {
    2018                 :          0 :                 struct shmem_falloc *shmem_falloc;
    2019                 :            : 
    2020                 :          0 :                 spin_lock(&inode->i_lock);
    2021                 :          0 :                 shmem_falloc = inode->i_private;
    2022         [ #  # ]:          0 :                 if (shmem_falloc &&
    2023         [ #  # ]:          0 :                     shmem_falloc->waitq &&
    2024         [ #  # ]:          0 :                     vmf->pgoff >= shmem_falloc->start &&
    2025         [ #  # ]:          0 :                     vmf->pgoff < shmem_falloc->next) {
    2026                 :          0 :                         struct file *fpin;
    2027                 :          0 :                         wait_queue_head_t *shmem_falloc_waitq;
    2028                 :          0 :                         DEFINE_WAIT_FUNC(shmem_fault_wait, synchronous_wake_function);
    2029                 :            : 
    2030                 :          0 :                         ret = VM_FAULT_NOPAGE;
    2031                 :          0 :                         fpin = maybe_unlock_mmap_for_io(vmf, NULL);
    2032         [ #  # ]:          0 :                         if (fpin)
    2033                 :          0 :                                 ret = VM_FAULT_RETRY;
    2034                 :            : 
    2035                 :          0 :                         shmem_falloc_waitq = shmem_falloc->waitq;
    2036                 :          0 :                         prepare_to_wait(shmem_falloc_waitq, &shmem_fault_wait,
    2037                 :            :                                         TASK_UNINTERRUPTIBLE);
    2038                 :          0 :                         spin_unlock(&inode->i_lock);
    2039                 :          0 :                         schedule();
    2040                 :            : 
    2041                 :            :                         /*
    2042                 :            :                          * shmem_falloc_waitq points into the shmem_fallocate()
    2043                 :            :                          * stack of the hole-punching task: shmem_falloc_waitq
    2044                 :            :                          * is usually invalid by the time we reach here, but
    2045                 :            :                          * finish_wait() does not dereference it in that case;
    2046                 :            :                          * though i_lock needed lest racing with wake_up_all().
    2047                 :            :                          */
    2048                 :          0 :                         spin_lock(&inode->i_lock);
    2049                 :          0 :                         finish_wait(shmem_falloc_waitq, &shmem_fault_wait);
    2050                 :          0 :                         spin_unlock(&inode->i_lock);
    2051                 :            : 
    2052         [ #  # ]:          0 :                         if (fpin)
    2053                 :          0 :                                 fput(fpin);
    2054                 :          0 :                         return ret;
    2055                 :            :                 }
    2056                 :          0 :                 spin_unlock(&inode->i_lock);
    2057                 :            :         }
    2058                 :            : 
    2059                 :      10490 :         sgp = SGP_CACHE;
    2060                 :            : 
    2061   [ +  -  +  - ]:      20980 :         if ((vma->vm_flags & VM_NOHUGEPAGE) ||
    2062                 :      10490 :             test_bit(MMF_DISABLE_THP, &vma->vm_mm->flags))
    2063                 :            :                 sgp = SGP_NOHUGE;
    2064         [ -  + ]:      10490 :         else if (vma->vm_flags & VM_HUGEPAGE)
    2065                 :          0 :                 sgp = SGP_HUGE;
    2066                 :            : 
    2067                 :      10490 :         err = shmem_getpage_gfp(inode, vmf->pgoff, &vmf->page, sgp,
    2068                 :            :                                   gfp, vma, vmf, &ret);
    2069         [ -  + ]:      10490 :         if (err)
    2070         [ #  # ]:          0 :                 return vmf_error(err);
    2071                 :      10490 :         return ret;
    2072                 :            : }
    2073                 :            : 
    2074                 :        234 : unsigned long shmem_get_unmapped_area(struct file *file,
    2075                 :            :                                       unsigned long uaddr, unsigned long len,
    2076                 :            :                                       unsigned long pgoff, unsigned long flags)
    2077                 :            : {
    2078                 :        234 :         unsigned long (*get_area)(struct file *,
    2079                 :            :                 unsigned long, unsigned long, unsigned long, unsigned long);
    2080                 :        234 :         unsigned long addr;
    2081                 :        234 :         unsigned long offset;
    2082                 :        234 :         unsigned long inflated_len;
    2083                 :        234 :         unsigned long inflated_addr;
    2084                 :        234 :         unsigned long inflated_offset;
    2085                 :            : 
    2086   [ -  +  -  -  :        468 :         if (len > TASK_SIZE)
                   +  - ]
    2087                 :            :                 return -ENOMEM;
    2088                 :            : 
    2089                 :        234 :         get_area = current->mm->get_unmapped_area;
    2090                 :        234 :         addr = get_area(file, uaddr, len, pgoff, flags);
    2091                 :            : 
    2092                 :        234 :         if (!IS_ENABLED(CONFIG_TRANSPARENT_HUGE_PAGECACHE))
    2093                 :        234 :                 return addr;
    2094                 :            :         if (IS_ERR_VALUE(addr))
    2095                 :            :                 return addr;
    2096                 :            :         if (addr & ~PAGE_MASK)
    2097                 :            :                 return addr;
    2098                 :            :         if (addr > TASK_SIZE - len)
    2099                 :            :                 return addr;
    2100                 :            : 
    2101                 :            :         if (shmem_huge == SHMEM_HUGE_DENY)
    2102                 :            :                 return addr;
    2103                 :            :         if (len < HPAGE_PMD_SIZE)
    2104                 :            :                 return addr;
    2105                 :            :         if (flags & MAP_FIXED)
    2106                 :            :                 return addr;
    2107                 :            :         /*
    2108                 :            :          * Our priority is to support MAP_SHARED mapped hugely;
    2109                 :            :          * and support MAP_PRIVATE mapped hugely too, until it is COWed.
    2110                 :            :          * But if caller specified an address hint and we allocated area there
    2111                 :            :          * successfully, respect that as before.
    2112                 :            :          */
    2113                 :            :         if (uaddr == addr)
    2114                 :            :                 return addr;
    2115                 :            : 
    2116                 :            :         if (shmem_huge != SHMEM_HUGE_FORCE) {
    2117                 :            :                 struct super_block *sb;
    2118                 :            : 
    2119                 :            :                 if (file) {
    2120                 :            :                         VM_BUG_ON(file->f_op != &shmem_file_operations);
    2121                 :            :                         sb = file_inode(file)->i_sb;
    2122                 :            :                 } else {
    2123                 :            :                         /*
    2124                 :            :                          * Called directly from mm/mmap.c, or drivers/char/mem.c
    2125                 :            :                          * for "/dev/zero", to create a shared anonymous object.
    2126                 :            :                          */
    2127                 :            :                         if (IS_ERR(shm_mnt))
    2128                 :            :                                 return addr;
    2129                 :            :                         sb = shm_mnt->mnt_sb;
    2130                 :            :                 }
    2131                 :            :                 if (SHMEM_SB(sb)->huge == SHMEM_HUGE_NEVER)
    2132                 :            :                         return addr;
    2133                 :            :         }
    2134                 :            : 
    2135                 :            :         offset = (pgoff << PAGE_SHIFT) & (HPAGE_PMD_SIZE-1);
    2136                 :            :         if (offset && offset + len < 2 * HPAGE_PMD_SIZE)
    2137                 :            :                 return addr;
    2138                 :            :         if ((addr & (HPAGE_PMD_SIZE-1)) == offset)
    2139                 :            :                 return addr;
    2140                 :            : 
    2141                 :            :         inflated_len = len + HPAGE_PMD_SIZE - PAGE_SIZE;
    2142                 :            :         if (inflated_len > TASK_SIZE)
    2143                 :            :                 return addr;
    2144                 :            :         if (inflated_len < len)
    2145                 :            :                 return addr;
    2146                 :            : 
    2147                 :            :         inflated_addr = get_area(NULL, uaddr, inflated_len, 0, flags);
    2148                 :            :         if (IS_ERR_VALUE(inflated_addr))
    2149                 :            :                 return addr;
    2150                 :            :         if (inflated_addr & ~PAGE_MASK)
    2151                 :            :                 return addr;
    2152                 :            : 
    2153                 :            :         inflated_offset = inflated_addr & (HPAGE_PMD_SIZE-1);
    2154                 :            :         inflated_addr += offset - inflated_offset;
    2155                 :            :         if (inflated_offset > offset)
    2156                 :            :                 inflated_addr += HPAGE_PMD_SIZE;
    2157                 :            : 
    2158                 :            :         if (inflated_addr > TASK_SIZE - len)
    2159                 :            :                 return addr;
    2160                 :            :         return inflated_addr;
    2161                 :            : }
    2162                 :            : 
    2163                 :            : #ifdef CONFIG_NUMA
    2164                 :          0 : static int shmem_set_policy(struct vm_area_struct *vma, struct mempolicy *mpol)
    2165                 :            : {
    2166                 :          0 :         struct inode *inode = file_inode(vma->vm_file);
    2167                 :          0 :         return mpol_set_shared_policy(&SHMEM_I(inode)->policy, vma, mpol);
    2168                 :            : }
    2169                 :            : 
    2170                 :          0 : static struct mempolicy *shmem_get_policy(struct vm_area_struct *vma,
    2171                 :            :                                           unsigned long addr)
    2172                 :            : {
    2173                 :          0 :         struct inode *inode = file_inode(vma->vm_file);
    2174                 :          0 :         pgoff_t index;
    2175                 :            : 
    2176                 :          0 :         index = ((addr - vma->vm_start) >> PAGE_SHIFT) + vma->vm_pgoff;
    2177                 :          0 :         return mpol_shared_policy_lookup(&SHMEM_I(inode)->policy, index);
    2178                 :            : }
    2179                 :            : #endif
    2180                 :            : 
    2181                 :          0 : int shmem_lock(struct file *file, int lock, struct user_struct *user)
    2182                 :            : {
    2183                 :          0 :         struct inode *inode = file_inode(file);
    2184                 :          0 :         struct shmem_inode_info *info = SHMEM_I(inode);
    2185                 :          0 :         int retval = -ENOMEM;
    2186                 :            : 
    2187                 :          0 :         spin_lock_irq(&info->lock);
    2188   [ #  #  #  # ]:          0 :         if (lock && !(info->flags & VM_LOCKED)) {
    2189         [ #  # ]:          0 :                 if (!user_shm_lock(inode->i_size, user))
    2190                 :          0 :                         goto out_nomem;
    2191                 :          0 :                 info->flags |= VM_LOCKED;
    2192                 :          0 :                 mapping_set_unevictable(file->f_mapping);
    2193                 :            :         }
    2194   [ #  #  #  #  :          0 :         if (!lock && (info->flags & VM_LOCKED) && user) {
                   #  # ]
    2195                 :          0 :                 user_shm_unlock(inode->i_size, user);
    2196                 :          0 :                 info->flags &= ~VM_LOCKED;
    2197                 :          0 :                 mapping_clear_unevictable(file->f_mapping);
    2198                 :            :         }
    2199                 :            :         retval = 0;
    2200                 :            : 
    2201                 :          0 : out_nomem:
    2202                 :          0 :         spin_unlock_irq(&info->lock);
    2203                 :          0 :         return retval;
    2204                 :            : }
    2205                 :            : 
    2206                 :        234 : static int shmem_mmap(struct file *file, struct vm_area_struct *vma)
    2207                 :            : {
    2208         [ -  + ]:        234 :         struct shmem_inode_info *info = SHMEM_I(file_inode(file));
    2209                 :            : 
    2210         [ -  + ]:        234 :         if (info->seals & F_SEAL_FUTURE_WRITE) {
    2211                 :            :                 /*
    2212                 :            :                  * New PROT_WRITE and MAP_SHARED mmaps are not allowed when
    2213                 :            :                  * "future write" seal active.
    2214                 :            :                  */
    2215         [ #  # ]:          0 :                 if ((vma->vm_flags & VM_SHARED) && (vma->vm_flags & VM_WRITE))
    2216                 :            :                         return -EPERM;
    2217                 :            : 
    2218                 :            :                 /*
    2219                 :            :                  * Since an F_SEAL_FUTURE_WRITE sealed memfd can be mapped as
    2220                 :            :                  * MAP_SHARED and read-only, take care to not allow mprotect to
    2221                 :            :                  * revert protections on such mappings. Do this only for shared
    2222                 :            :                  * mappings. For private mappings, don't need to mask
    2223                 :            :                  * VM_MAYWRITE as we still want them to be COW-writable.
    2224                 :            :                  */
    2225         [ #  # ]:          0 :                 if (vma->vm_flags & VM_SHARED)
    2226                 :          0 :                         vma->vm_flags &= ~(VM_MAYWRITE);
    2227                 :            :         }
    2228                 :            : 
    2229         [ +  - ]:        234 :         file_accessed(file);
    2230                 :        234 :         vma->vm_ops = &shmem_vm_ops;
    2231                 :        234 :         if (IS_ENABLED(CONFIG_TRANSPARENT_HUGE_PAGECACHE) &&
    2232                 :            :                         ((vma->vm_start + ~HPAGE_PMD_MASK) & HPAGE_PMD_MASK) <
    2233                 :            :                         (vma->vm_end & HPAGE_PMD_MASK)) {
    2234                 :            :                 khugepaged_enter(vma, vma->vm_flags);
    2235                 :            :         }
    2236                 :        234 :         return 0;
    2237                 :            : }
    2238                 :            : 
    2239                 :      59351 : static struct inode *shmem_get_inode(struct super_block *sb, const struct inode *dir,
    2240                 :            :                                      umode_t mode, dev_t dev, unsigned long flags)
    2241                 :            : {
    2242                 :      59351 :         struct inode *inode;
    2243                 :      59351 :         struct shmem_inode_info *info;
    2244                 :      59351 :         struct shmem_sb_info *sbinfo = SHMEM_SB(sb);
    2245                 :            : 
    2246         [ +  - ]:      59351 :         if (shmem_reserve_inode(sb))
    2247                 :            :                 return NULL;
    2248                 :            : 
    2249                 :      59351 :         inode = new_inode(sb);
    2250         [ +  - ]:      59351 :         if (inode) {
    2251                 :      59351 :                 inode->i_ino = get_next_ino();
    2252                 :      59351 :                 inode_init_owner(inode, dir, mode);
    2253                 :      59351 :                 inode->i_blocks = 0;
    2254                 :      59351 :                 inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
    2255                 :      59351 :                 inode->i_generation = prandom_u32();
    2256                 :      59351 :                 info = SHMEM_I(inode);
    2257                 :      59351 :                 memset(info, 0, (char *)inode - (char *)info);
    2258                 :      59351 :                 spin_lock_init(&info->lock);
    2259                 :      59351 :                 atomic_set(&info->stop_eviction, 0);
    2260                 :      59351 :                 info->seals = F_SEAL_SEAL;
    2261                 :      59351 :                 info->flags = flags & VM_NORESERVE;
    2262   [ +  +  +  + ]:      59351 :                 INIT_LIST_HEAD(&info->shrinklist);
    2263                 :      59351 :                 INIT_LIST_HEAD(&info->swaplist);
    2264   [ +  +  +  + ]:      59351 :                 simple_xattrs_init(&info->xattrs);
    2265   [ +  +  +  + ]:      59351 :                 cache_no_acl(inode);
    2266                 :            : 
    2267   [ +  +  +  + ]:      59351 :                 switch (mode & S_IFMT) {
    2268                 :      11154 :                 default:
    2269                 :      11154 :                         inode->i_op = &shmem_special_inode_operations;
    2270                 :      11154 :                         init_special_inode(inode, mode, dev);
    2271                 :      11154 :                         break;
    2272                 :      25811 :                 case S_IFREG:
    2273                 :      25811 :                         inode->i_mapping->a_ops = &shmem_aops;
    2274                 :      25811 :                         inode->i_op = &shmem_inode_operations;
    2275                 :      25811 :                         inode->i_fop = &shmem_file_operations;
    2276                 :      25811 :                         mpol_shared_policy_init(&info->policy,
    2277                 :            :                                                  shmem_get_sbmpol(sbinfo));
    2278                 :      25811 :                         break;
    2279                 :       6396 :                 case S_IFDIR:
    2280                 :       6396 :                         inc_nlink(inode);
    2281                 :            :                         /* Some things misbehave if size == 0 on a directory */
    2282                 :       6396 :                         inode->i_size = 2 * BOGO_DIRENT_SIZE;
    2283                 :       6396 :                         inode->i_op = &shmem_dir_inode_operations;
    2284                 :       6396 :                         inode->i_fop = &simple_dir_operations;
    2285                 :       6396 :                         break;
    2286                 :      15990 :                 case S_IFLNK:
    2287                 :            :                         /*
    2288                 :            :                          * Must not load anything in the rbtree,
    2289                 :            :                          * mpol_free_shared_policy will not be called.
    2290                 :            :                          */
    2291                 :      15990 :                         mpol_shared_policy_init(&info->policy, NULL);
    2292                 :      15990 :                         break;
    2293                 :            :                 }
    2294                 :            : 
    2295                 :            :                 lockdep_annotate_inode_mutex_key(inode);
    2296                 :            :         } else
    2297                 :          0 :                 shmem_free_inode(sb);
    2298                 :            :         return inode;
    2299                 :            : }
    2300                 :            : 
    2301                 :     907635 : bool shmem_mapping(struct address_space *mapping)
    2302                 :            : {
    2303                 :     907635 :         return mapping->a_ops == &shmem_aops;
    2304                 :            : }
    2305                 :            : 
    2306                 :          0 : static int shmem_mfill_atomic_pte(struct mm_struct *dst_mm,
    2307                 :            :                                   pmd_t *dst_pmd,
    2308                 :            :                                   struct vm_area_struct *dst_vma,
    2309                 :            :                                   unsigned long dst_addr,
    2310                 :            :                                   unsigned long src_addr,
    2311                 :            :                                   bool zeropage,
    2312                 :            :                                   struct page **pagep)
    2313                 :            : {
    2314                 :          0 :         struct inode *inode = file_inode(dst_vma->vm_file);
    2315                 :          0 :         struct shmem_inode_info *info = SHMEM_I(inode);
    2316                 :          0 :         struct address_space *mapping = inode->i_mapping;
    2317                 :          0 :         gfp_t gfp = mapping_gfp_mask(mapping);
    2318                 :          0 :         pgoff_t pgoff = linear_page_index(dst_vma, dst_addr);
    2319                 :          0 :         struct mem_cgroup *memcg;
    2320                 :          0 :         spinlock_t *ptl;
    2321                 :          0 :         void *page_kaddr;
    2322                 :          0 :         struct page *page;
    2323                 :          0 :         pte_t _dst_pte, *dst_pte;
    2324                 :          0 :         int ret;
    2325                 :          0 :         pgoff_t offset, max_off;
    2326                 :            : 
    2327                 :          0 :         ret = -ENOMEM;
    2328         [ #  # ]:          0 :         if (!shmem_inode_acct_block(inode, 1))
    2329                 :          0 :                 goto out;
    2330                 :            : 
    2331         [ #  # ]:          0 :         if (!*pagep) {
    2332                 :          0 :                 page = shmem_alloc_page(gfp, info, pgoff);
    2333         [ #  # ]:          0 :                 if (!page)
    2334                 :          0 :                         goto out_unacct_blocks;
    2335                 :            : 
    2336         [ #  # ]:          0 :                 if (!zeropage) {        /* mcopy_atomic */
    2337                 :          0 :                         page_kaddr = kmap_atomic(page);
    2338         [ #  # ]:          0 :                         ret = copy_from_user(page_kaddr,
    2339                 :            :                                              (const void __user *)src_addr,
    2340                 :            :                                              PAGE_SIZE);
    2341                 :          0 :                         kunmap_atomic(page_kaddr);
    2342                 :            : 
    2343                 :            :                         /* fallback to copy_from_user outside mmap_sem */
    2344         [ #  # ]:          0 :                         if (unlikely(ret)) {
    2345                 :          0 :                                 *pagep = page;
    2346                 :          0 :                                 shmem_inode_unacct_blocks(inode, 1);
    2347                 :            :                                 /* don't free the page */
    2348                 :          0 :                                 return -ENOENT;
    2349                 :            :                         }
    2350                 :            :                 } else {                /* mfill_zeropage_atomic */
    2351                 :          0 :                         clear_highpage(page);
    2352                 :            :                 }
    2353                 :            :         } else {
    2354                 :          0 :                 page = *pagep;
    2355                 :          0 :                 *pagep = NULL;
    2356                 :            :         }
    2357                 :            : 
    2358                 :          0 :         VM_BUG_ON(PageLocked(page) || PageSwapBacked(page));
    2359         [ #  # ]:          0 :         __SetPageLocked(page);
    2360         [ #  # ]:          0 :         __SetPageSwapBacked(page);
    2361                 :          0 :         __SetPageUptodate(page);
    2362                 :            : 
    2363                 :          0 :         ret = -EFAULT;
    2364                 :          0 :         offset = linear_page_index(dst_vma, dst_addr);
    2365         [ #  # ]:          0 :         max_off = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
    2366         [ #  # ]:          0 :         if (unlikely(offset >= max_off))
    2367                 :          0 :                 goto out_release;
    2368                 :            : 
    2369                 :          0 :         ret = mem_cgroup_try_charge_delay(page, dst_mm, gfp, &memcg, false);
    2370                 :          0 :         if (ret)
    2371                 :            :                 goto out_release;
    2372                 :            : 
    2373                 :          0 :         ret = shmem_add_to_page_cache(page, mapping, pgoff, NULL,
    2374                 :            :                                                 gfp & GFP_RECLAIM_MASK);
    2375         [ #  # ]:          0 :         if (ret)
    2376                 :          0 :                 goto out_release_uncharge;
    2377                 :            : 
    2378         [ #  # ]:          0 :         mem_cgroup_commit_charge(page, memcg, false, false);
    2379                 :            : 
    2380         [ #  # ]:          0 :         _dst_pte = mk_pte(page, dst_vma->vm_page_prot);
    2381         [ #  # ]:          0 :         if (dst_vma->vm_flags & VM_WRITE)
    2382                 :          0 :                 _dst_pte = pte_mkwrite(pte_mkdirty(_dst_pte));
    2383                 :            :         else {
    2384                 :            :                 /*
    2385                 :            :                  * We don't set the pte dirty if the vma has no
    2386                 :            :                  * VM_WRITE permission, so mark the page dirty or it
    2387                 :            :                  * could be freed from under us. We could do it
    2388                 :            :                  * unconditionally before unlock_page(), but doing it
    2389                 :            :                  * only if VM_WRITE is not set is faster.
    2390                 :            :                  */
    2391                 :          0 :                 set_page_dirty(page);
    2392                 :            :         }
    2393                 :            : 
    2394         [ #  # ]:          0 :         dst_pte = pte_offset_map_lock(dst_mm, dst_pmd, dst_addr, &ptl);
    2395                 :            : 
    2396                 :          0 :         ret = -EFAULT;
    2397         [ #  # ]:          0 :         max_off = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
    2398         [ #  # ]:          0 :         if (unlikely(offset >= max_off))
    2399                 :          0 :                 goto out_release_uncharge_unlock;
    2400                 :            : 
    2401                 :          0 :         ret = -EEXIST;
    2402         [ #  # ]:          0 :         if (!pte_none(*dst_pte))
    2403                 :          0 :                 goto out_release_uncharge_unlock;
    2404                 :            : 
    2405                 :          0 :         lru_cache_add_anon(page);
    2406                 :            : 
    2407                 :          0 :         spin_lock(&info->lock);
    2408                 :          0 :         info->alloced++;
    2409                 :          0 :         inode->i_blocks += BLOCKS_PER_PAGE;
    2410                 :          0 :         shmem_recalc_inode(inode);
    2411                 :          0 :         spin_unlock(&info->lock);
    2412                 :            : 
    2413                 :          0 :         inc_mm_counter(dst_mm, mm_counter_file(page));
    2414                 :          0 :         page_add_file_rmap(page, false);
    2415                 :          0 :         set_pte_at(dst_mm, dst_addr, dst_pte, _dst_pte);
    2416                 :            : 
    2417                 :            :         /* No need to invalidate - it was non-present before */
    2418                 :          0 :         update_mmu_cache(dst_vma, dst_addr, dst_pte);
    2419                 :          0 :         pte_unmap_unlock(dst_pte, ptl);
    2420                 :          0 :         unlock_page(page);
    2421                 :          0 :         ret = 0;
    2422                 :            : out:
    2423                 :            :         return ret;
    2424                 :          0 : out_release_uncharge_unlock:
    2425                 :          0 :         pte_unmap_unlock(dst_pte, ptl);
    2426         [ #  # ]:          0 :         ClearPageDirty(page);
    2427                 :          0 :         delete_from_page_cache(page);
    2428                 :            : out_release_uncharge:
    2429                 :            :         mem_cgroup_cancel_charge(page, memcg, false);
    2430                 :          0 : out_release:
    2431                 :          0 :         unlock_page(page);
    2432                 :          0 :         put_page(page);
    2433                 :          0 : out_unacct_blocks:
    2434                 :          0 :         shmem_inode_unacct_blocks(inode, 1);
    2435                 :          0 :         goto out;
    2436                 :            : }
    2437                 :            : 
    2438                 :          0 : int shmem_mcopy_atomic_pte(struct mm_struct *dst_mm,
    2439                 :            :                            pmd_t *dst_pmd,
    2440                 :            :                            struct vm_area_struct *dst_vma,
    2441                 :            :                            unsigned long dst_addr,
    2442                 :            :                            unsigned long src_addr,
    2443                 :            :                            struct page **pagep)
    2444                 :            : {
    2445                 :          0 :         return shmem_mfill_atomic_pte(dst_mm, dst_pmd, dst_vma,
    2446                 :            :                                       dst_addr, src_addr, false, pagep);
    2447                 :            : }
    2448                 :            : 
    2449                 :          0 : int shmem_mfill_zeropage_pte(struct mm_struct *dst_mm,
    2450                 :            :                              pmd_t *dst_pmd,
    2451                 :            :                              struct vm_area_struct *dst_vma,
    2452                 :            :                              unsigned long dst_addr)
    2453                 :            : {
    2454                 :          0 :         struct page *page = NULL;
    2455                 :            : 
    2456                 :          0 :         return shmem_mfill_atomic_pte(dst_mm, dst_pmd, dst_vma,
    2457                 :            :                                       dst_addr, 0, true, &page);
    2458                 :            : }
    2459                 :            : 
    2460                 :            : #ifdef CONFIG_TMPFS
    2461                 :            : static const struct inode_operations shmem_symlink_inode_operations;
    2462                 :            : static const struct inode_operations shmem_short_symlink_operations;
    2463                 :            : 
    2464                 :            : #ifdef CONFIG_TMPFS_XATTR
    2465                 :            : static int shmem_initxattrs(struct inode *, const struct xattr *, void *);
    2466                 :            : #else
    2467                 :            : #define shmem_initxattrs NULL
    2468                 :            : #endif
    2469                 :            : 
    2470                 :            : static int
    2471                 :       8724 : shmem_write_begin(struct file *file, struct address_space *mapping,
    2472                 :            :                         loff_t pos, unsigned len, unsigned flags,
    2473                 :            :                         struct page **pagep, void **fsdata)
    2474                 :            : {
    2475                 :       8724 :         struct inode *inode = mapping->host;
    2476         [ -  + ]:       8724 :         struct shmem_inode_info *info = SHMEM_I(inode);
    2477                 :       8724 :         pgoff_t index = pos >> PAGE_SHIFT;
    2478                 :            : 
    2479                 :            :         /* i_mutex is held by caller */
    2480         [ -  + ]:       8724 :         if (unlikely(info->seals & (F_SEAL_GROW |
    2481                 :            :                                    F_SEAL_WRITE | F_SEAL_FUTURE_WRITE))) {
    2482         [ #  # ]:          0 :                 if (info->seals & (F_SEAL_WRITE | F_SEAL_FUTURE_WRITE))
    2483                 :            :                         return -EPERM;
    2484   [ #  #  #  # ]:          0 :                 if ((info->seals & F_SEAL_GROW) && pos + len > inode->i_size)
    2485                 :            :                         return -EPERM;
    2486                 :            :         }
    2487                 :            : 
    2488                 :       8724 :         return shmem_getpage(inode, index, pagep, SGP_WRITE);
    2489                 :            : }
    2490                 :            : 
    2491                 :            : static int
    2492                 :       8724 : shmem_write_end(struct file *file, struct address_space *mapping,
    2493                 :            :                         loff_t pos, unsigned len, unsigned copied,
    2494                 :            :                         struct page *page, void *fsdata)
    2495                 :            : {
    2496                 :       8724 :         struct inode *inode = mapping->host;
    2497                 :            : 
    2498         [ +  + ]:       8724 :         if (pos + copied > inode->i_size)
    2499                 :       8646 :                 i_size_write(inode, pos + copied);
    2500                 :            : 
    2501         [ +  + ]:       8724 :         if (!PageUptodate(page)) {
    2502         [ -  + ]:       8646 :                 struct page *head = compound_head(page);
    2503         [ +  - ]:       8646 :                 if (PageTransCompound(page)) {
    2504                 :            :                         int i;
    2505                 :            : 
    2506                 :            :                         for (i = 0; i < HPAGE_PMD_NR; i++) {
    2507                 :            :                                 if (head + i == page)
    2508                 :            :                                         continue;
    2509                 :            :                                 clear_highpage(head + i);
    2510                 :            :                                 flush_dcache_page(head + i);
    2511                 :            :                         }
    2512                 :            :                 }
    2513         [ +  - ]:       8646 :                 if (copied < PAGE_SIZE) {
    2514                 :       8646 :                         unsigned from = pos & (PAGE_SIZE - 1);
    2515                 :       8646 :                         zero_user_segments(page, 0, from,
    2516                 :            :                                         from + copied, PAGE_SIZE);
    2517                 :            :                 }
    2518                 :       8646 :                 SetPageUptodate(head);
    2519                 :            :         }
    2520                 :       8724 :         set_page_dirty(page);
    2521                 :       8724 :         unlock_page(page);
    2522                 :       8724 :         put_page(page);
    2523                 :            : 
    2524                 :       8724 :         return copied;
    2525                 :            : }
    2526                 :            : 
    2527                 :      14406 : static ssize_t shmem_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
    2528                 :            : {
    2529                 :      14406 :         struct file *file = iocb->ki_filp;
    2530         [ -  + ]:      14406 :         struct inode *inode = file_inode(file);
    2531                 :      14406 :         struct address_space *mapping = inode->i_mapping;
    2532                 :      14406 :         pgoff_t index;
    2533                 :      14406 :         unsigned long offset;
    2534                 :      14406 :         enum sgp_type sgp = SGP_READ;
    2535                 :      14406 :         int error = 0;
    2536                 :      14406 :         ssize_t retval = 0;
    2537                 :      14406 :         loff_t *ppos = &iocb->ki_pos;
    2538                 :            : 
    2539                 :            :         /*
    2540                 :            :          * Might this read be for a stacking filesystem?  Then when reading
    2541                 :            :          * holes of a sparse file, we actually need to allocate those pages,
    2542                 :            :          * and even mark them dirty, so it cannot exceed the max_blocks limit.
    2543                 :            :          */
    2544         [ -  + ]:      14406 :         if (!iter_is_iovec(to))
    2545                 :          0 :                 sgp = SGP_CACHE;
    2546                 :            : 
    2547                 :      14406 :         index = *ppos >> PAGE_SHIFT;
    2548                 :      14406 :         offset = *ppos & ~PAGE_MASK;
    2549                 :            : 
    2550                 :       7125 :         for (;;) {
    2551                 :      21531 :                 struct page *page = NULL;
    2552                 :      21531 :                 pgoff_t end_index;
    2553                 :      21531 :                 unsigned long nr, ret;
    2554         [ +  - ]:      21531 :                 loff_t i_size = i_size_read(inode);
    2555                 :            : 
    2556                 :      21531 :                 end_index = i_size >> PAGE_SHIFT;
    2557         [ +  - ]:      21531 :                 if (index > end_index)
    2558                 :            :                         break;
    2559         [ +  - ]:      21531 :                 if (index == end_index) {
    2560                 :      21531 :                         nr = i_size & ~PAGE_MASK;
    2561         [ +  + ]:      21531 :                         if (nr <= offset)
    2562                 :            :                                 break;
    2563                 :            :                 }
    2564                 :            : 
    2565                 :       7125 :                 error = shmem_getpage(inode, index, &page, sgp);
    2566         [ -  + ]:       7125 :                 if (error) {
    2567         [ #  # ]:          0 :                         if (error == -EINVAL)
    2568                 :          0 :                                 error = 0;
    2569                 :            :                         break;
    2570                 :            :                 }
    2571         [ +  - ]:       7125 :                 if (page) {
    2572         [ -  + ]:       7125 :                         if (sgp == SGP_CACHE)
    2573                 :          0 :                                 set_page_dirty(page);
    2574                 :       7125 :                         unlock_page(page);
    2575                 :            :                 }
    2576                 :            : 
    2577                 :            :                 /*
    2578                 :            :                  * We must evaluate after, since reads (unlike writes)
    2579                 :            :                  * are called without i_mutex protection against truncate
    2580                 :            :                  */
    2581                 :       7125 :                 nr = PAGE_SIZE;
    2582         [ +  - ]:       7125 :                 i_size = i_size_read(inode);
    2583                 :       7125 :                 end_index = i_size >> PAGE_SHIFT;
    2584         [ +  - ]:       7125 :                 if (index == end_index) {
    2585                 :       7125 :                         nr = i_size & ~PAGE_MASK;
    2586         [ -  + ]:       7125 :                         if (nr <= offset) {
    2587         [ #  # ]:          0 :                                 if (page)
    2588                 :          0 :                                         put_page(page);
    2589                 :            :                                 break;
    2590                 :            :                         }
    2591                 :            :                 }
    2592                 :       7125 :                 nr -= offset;
    2593                 :            : 
    2594         [ +  - ]:       7125 :                 if (page) {
    2595                 :            :                         /*
    2596                 :            :                          * If users can be writing to this page using arbitrary
    2597                 :            :                          * virtual addresses, take care about potential aliasing
    2598                 :            :                          * before reading the page on the kernel side.
    2599                 :            :                          */
    2600                 :       7125 :                         if (mapping_writably_mapped(mapping))
    2601                 :            :                                 flush_dcache_page(page);
    2602                 :            :                         /*
    2603                 :            :                          * Mark the page accessed if we read the beginning.
    2604                 :            :                          */
    2605         [ +  - ]:       7125 :                         if (!offset)
    2606                 :       7125 :                                 mark_page_accessed(page);
    2607                 :            :                 } else {
    2608         [ #  # ]:          0 :                         page = ZERO_PAGE(0);
    2609         [ #  # ]:          0 :                         get_page(page);
    2610                 :            :                 }
    2611                 :            : 
    2612                 :            :                 /*
    2613                 :            :                  * Ok, we have the page, and it's up-to-date, so
    2614                 :            :                  * now we can copy it to user space...
    2615                 :            :                  */
    2616                 :       7125 :                 ret = copy_page_to_iter(page, offset, nr, to);
    2617                 :       7125 :                 retval += ret;
    2618                 :       7125 :                 offset += ret;
    2619                 :       7125 :                 index += offset >> PAGE_SHIFT;
    2620                 :       7125 :                 offset &= ~PAGE_MASK;
    2621                 :            : 
    2622                 :       7125 :                 put_page(page);
    2623         [ +  - ]:       7125 :                 if (!iov_iter_count(to))
    2624                 :            :                         break;
    2625         [ +  - ]:       7125 :                 if (ret < nr) {
    2626                 :            :                         error = -EFAULT;
    2627                 :            :                         break;
    2628                 :            :                 }
    2629                 :       7125 :                 cond_resched();
    2630                 :            :         }
    2631                 :            : 
    2632                 :      14406 :         *ppos = ((loff_t) index << PAGE_SHIFT) + offset;
    2633         [ +  - ]:      14406 :         file_accessed(file);
    2634         [ +  + ]:      14406 :         return retval ? retval : error;
    2635                 :            : }
    2636                 :            : 
    2637                 :            : /*
    2638                 :            :  * llseek SEEK_DATA or SEEK_HOLE through the page cache.
    2639                 :            :  */
    2640                 :          0 : static pgoff_t shmem_seek_hole_data(struct address_space *mapping,
    2641                 :            :                                     pgoff_t index, pgoff_t end, int whence)
    2642                 :            : {
    2643                 :          0 :         struct page *page;
    2644                 :          0 :         struct pagevec pvec;
    2645                 :          0 :         pgoff_t indices[PAGEVEC_SIZE];
    2646                 :          0 :         bool done = false;
    2647                 :          0 :         int i;
    2648                 :            : 
    2649                 :          0 :         pagevec_init(&pvec);
    2650                 :          0 :         pvec.nr = 1;            /* start small: we may be there already */
    2651         [ #  # ]:          0 :         while (!done) {
    2652                 :          0 :                 pvec.nr = find_get_entries(mapping, index,
    2653                 :          0 :                                         pvec.nr, pvec.pages, indices);
    2654         [ #  # ]:          0 :                 if (!pvec.nr) {
    2655         [ #  # ]:          0 :                         if (whence == SEEK_DATA)
    2656                 :          0 :                                 index = end;
    2657                 :            :                         break;
    2658                 :            :                 }
    2659         [ #  # ]:          0 :                 for (i = 0; i < pvec.nr; i++, index++) {
    2660         [ #  # ]:          0 :                         if (index < indices[i]) {
    2661         [ #  # ]:          0 :                                 if (whence == SEEK_HOLE) {
    2662                 :            :                                         done = true;
    2663                 :            :                                         break;
    2664                 :            :                                 }
    2665                 :            :                                 index = indices[i];
    2666                 :            :                         }
    2667                 :          0 :                         page = pvec.pages[i];
    2668   [ #  #  #  # ]:          0 :                         if (page && !xa_is_value(page)) {
    2669         [ #  # ]:          0 :                                 if (!PageUptodate(page))
    2670                 :          0 :                                         page = NULL;
    2671                 :            :                         }
    2672         [ #  # ]:          0 :                         if (index >= end ||
    2673         [ #  # ]:          0 :                             (page && whence == SEEK_DATA) ||
    2674         [ #  # ]:          0 :                             (!page && whence == SEEK_HOLE)) {
    2675                 :            :                                 done = true;
    2676                 :            :                                 break;
    2677                 :            :                         }
    2678                 :            :                 }
    2679                 :          0 :                 pagevec_remove_exceptionals(&pvec);
    2680         [ #  # ]:          0 :                 pagevec_release(&pvec);
    2681                 :          0 :                 pvec.nr = PAGEVEC_SIZE;
    2682                 :          0 :                 cond_resched();
    2683                 :            :         }
    2684                 :          0 :         return index;
    2685                 :            : }
    2686                 :            : 
    2687                 :        468 : static loff_t shmem_file_llseek(struct file *file, loff_t offset, int whence)
    2688                 :            : {
    2689                 :        468 :         struct address_space *mapping = file->f_mapping;
    2690                 :        468 :         struct inode *inode = mapping->host;
    2691                 :        468 :         pgoff_t start, end;
    2692                 :        468 :         loff_t new_offset;
    2693                 :            : 
    2694         [ +  - ]:        468 :         if (whence != SEEK_DATA && whence != SEEK_HOLE)
    2695                 :        468 :                 return generic_file_llseek_size(file, offset, whence,
    2696                 :            :                                         MAX_LFS_FILESIZE, i_size_read(inode));
    2697                 :          0 :         inode_lock(inode);
    2698                 :            :         /* We're holding i_mutex so we can access i_size directly */
    2699                 :            : 
    2700   [ #  #  #  # ]:          0 :         if (offset < 0 || offset >= inode->i_size)
    2701                 :            :                 offset = -ENXIO;
    2702                 :            :         else {
    2703                 :          0 :                 start = offset >> PAGE_SHIFT;
    2704                 :          0 :                 end = (inode->i_size + PAGE_SIZE - 1) >> PAGE_SHIFT;
    2705                 :          0 :                 new_offset = shmem_seek_hole_data(mapping, start, end, whence);
    2706                 :          0 :                 new_offset <<= PAGE_SHIFT;
    2707         [ #  # ]:          0 :                 if (new_offset > offset) {
    2708         [ #  # ]:          0 :                         if (new_offset < inode->i_size)
    2709                 :            :                                 offset = new_offset;
    2710         [ #  # ]:          0 :                         else if (whence == SEEK_DATA)
    2711                 :            :                                 offset = -ENXIO;
    2712                 :            :                         else
    2713                 :            :                                 offset = inode->i_size;
    2714                 :            :                 }
    2715                 :            :         }
    2716                 :            : 
    2717         [ #  # ]:          0 :         if (offset >= 0)
    2718                 :          0 :                 offset = vfs_setpos(file, offset, MAX_LFS_FILESIZE);
    2719                 :          0 :         inode_unlock(inode);
    2720                 :          0 :         return offset;
    2721                 :            : }
    2722                 :            : 
    2723                 :        156 : static long shmem_fallocate(struct file *file, int mode, loff_t offset,
    2724                 :            :                                                          loff_t len)
    2725                 :            : {
    2726         [ +  - ]:        156 :         struct inode *inode = file_inode(file);
    2727                 :        156 :         struct shmem_sb_info *sbinfo = SHMEM_SB(inode->i_sb);
    2728         [ +  - ]:        156 :         struct shmem_inode_info *info = SHMEM_I(inode);
    2729                 :        156 :         struct shmem_falloc shmem_falloc;
    2730                 :        156 :         pgoff_t start, index, end;
    2731                 :        156 :         int error;
    2732                 :            : 
    2733         [ +  - ]:        156 :         if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE))
    2734                 :            :                 return -EOPNOTSUPP;
    2735                 :            : 
    2736                 :        156 :         inode_lock(inode);
    2737                 :            : 
    2738         [ -  + ]:        156 :         if (mode & FALLOC_FL_PUNCH_HOLE) {
    2739                 :          0 :                 struct address_space *mapping = file->f_mapping;
    2740                 :          0 :                 loff_t unmap_start = round_up(offset, PAGE_SIZE);
    2741                 :          0 :                 loff_t unmap_end = round_down(offset + len, PAGE_SIZE) - 1;
    2742                 :          0 :                 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(shmem_falloc_waitq);
    2743                 :            : 
    2744                 :            :                 /* protected by i_mutex */
    2745         [ #  # ]:          0 :                 if (info->seals & (F_SEAL_WRITE | F_SEAL_FUTURE_WRITE)) {
    2746                 :          0 :                         error = -EPERM;
    2747                 :          0 :                         goto out;
    2748                 :            :                 }
    2749                 :            : 
    2750                 :          0 :                 shmem_falloc.waitq = &shmem_falloc_waitq;
    2751                 :          0 :                 shmem_falloc.start = (u64)unmap_start >> PAGE_SHIFT;
    2752                 :          0 :                 shmem_falloc.next = (unmap_end + 1) >> PAGE_SHIFT;
    2753                 :          0 :                 spin_lock(&inode->i_lock);
    2754                 :          0 :                 inode->i_private = &shmem_falloc;
    2755                 :          0 :                 spin_unlock(&inode->i_lock);
    2756                 :            : 
    2757         [ #  # ]:          0 :                 if ((u64)unmap_end > (u64)unmap_start)
    2758                 :          0 :                         unmap_mapping_range(mapping, unmap_start,
    2759                 :          0 :                                             1 + unmap_end - unmap_start, 0);
    2760                 :          0 :                 shmem_truncate_range(inode, offset, offset + len - 1);
    2761                 :            :                 /* No need to unmap again: hole-punching leaves COWed pages */
    2762                 :            : 
    2763                 :          0 :                 spin_lock(&inode->i_lock);
    2764                 :          0 :                 inode->i_private = NULL;
    2765                 :          0 :                 wake_up_all(&shmem_falloc_waitq);
    2766         [ #  # ]:          0 :                 WARN_ON_ONCE(!list_empty(&shmem_falloc_waitq.head));
    2767                 :          0 :                 spin_unlock(&inode->i_lock);
    2768                 :          0 :                 error = 0;
    2769                 :          0 :                 goto out;
    2770                 :            :         }
    2771                 :            : 
    2772                 :            :         /* We need to check rlimit even when FALLOC_FL_KEEP_SIZE */
    2773                 :        156 :         error = inode_newsize_ok(inode, offset + len);
    2774         [ -  + ]:        156 :         if (error)
    2775                 :          0 :                 goto out;
    2776                 :            : 
    2777   [ -  +  -  - ]:        156 :         if ((info->seals & F_SEAL_GROW) && offset + len > inode->i_size) {
    2778                 :          0 :                 error = -EPERM;
    2779                 :          0 :                 goto out;
    2780                 :            :         }
    2781                 :            : 
    2782                 :        156 :         start = offset >> PAGE_SHIFT;
    2783                 :        156 :         end = (offset + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
    2784                 :            :         /* Try to avoid a swapstorm if len is impossible to satisfy */
    2785   [ +  -  -  + ]:        156 :         if (sbinfo->max_blocks && end - start > sbinfo->max_blocks) {
    2786                 :          0 :                 error = -ENOSPC;
    2787                 :          0 :                 goto out;
    2788                 :            :         }
    2789                 :            : 
    2790                 :        156 :         shmem_falloc.waitq = NULL;
    2791                 :        156 :         shmem_falloc.start = start;
    2792                 :        156 :         shmem_falloc.next  = start;
    2793                 :        156 :         shmem_falloc.nr_falloced = 0;
    2794                 :        156 :         shmem_falloc.nr_unswapped = 0;
    2795                 :        156 :         spin_lock(&inode->i_lock);
    2796                 :        156 :         inode->i_private = &shmem_falloc;
    2797                 :        156 :         spin_unlock(&inode->i_lock);
    2798                 :            : 
    2799         [ +  + ]:      94380 :         for (index = start; index < end; index++) {
    2800                 :      94068 :                 struct page *page;
    2801                 :            : 
    2802                 :            :                 /*
    2803                 :            :                  * Good, the fallocate(2) manpage permits EINTR: we may have
    2804                 :            :                  * been interrupted because we are using up too much memory.
    2805                 :            :                  */
    2806         [ +  - ]:      94068 :                 if (signal_pending(current))
    2807                 :            :                         error = -EINTR;
    2808         [ +  - ]:      94068 :                 else if (shmem_falloc.nr_unswapped > shmem_falloc.nr_falloced)
    2809                 :            :                         error = -ENOMEM;
    2810                 :            :                 else
    2811                 :      94068 :                         error = shmem_getpage(inode, index, &page, SGP_FALLOC);
    2812         [ -  + ]:      94068 :                 if (error) {
    2813                 :            :                         /* Remove the !PageUptodate pages we added */
    2814         [ #  # ]:          0 :                         if (index > start) {
    2815                 :          0 :                                 shmem_undo_range(inode,
    2816                 :            :                                     (loff_t)start << PAGE_SHIFT,
    2817                 :          0 :                                     ((loff_t)index << PAGE_SHIFT) - 1, true);
    2818                 :            :                         }
    2819                 :          0 :                         goto undone;
    2820                 :            :                 }
    2821                 :            : 
    2822                 :            :                 /*
    2823                 :            :                  * Inform shmem_writepage() how far we have reached.
    2824                 :            :                  * No need for lock or barrier: we have the page lock.
    2825                 :            :                  */
    2826                 :      94068 :                 shmem_falloc.next++;
    2827         [ +  + ]:      94068 :                 if (!PageUptodate(page))
    2828                 :      93990 :                         shmem_falloc.nr_falloced++;
    2829                 :            : 
    2830                 :            :                 /*
    2831                 :            :                  * If !PageUptodate, leave it that way so that freeable pages
    2832                 :            :                  * can be recognized if we need to rollback on error later.
    2833                 :            :                  * But set_page_dirty so that memory pressure will swap rather
    2834                 :            :                  * than free the pages we are allocating (and SGP_CACHE pages
    2835                 :            :                  * might still be clean: we now need to mark those dirty too).
    2836                 :            :                  */
    2837                 :      94068 :                 set_page_dirty(page);
    2838                 :      94068 :                 unlock_page(page);
    2839                 :      94068 :                 put_page(page);
    2840                 :      94068 :                 cond_resched();
    2841                 :            :         }
    2842                 :            : 
    2843   [ +  -  +  - ]:        156 :         if (!(mode & FALLOC_FL_KEEP_SIZE) && offset + len > inode->i_size)
    2844                 :        156 :                 i_size_write(inode, offset + len);
    2845                 :        156 :         inode->i_ctime = current_time(inode);
    2846                 :        156 : undone:
    2847                 :        156 :         spin_lock(&inode->i_lock);
    2848                 :        156 :         inode->i_private = NULL;
    2849                 :        156 :         spin_unlock(&inode->i_lock);
    2850                 :        156 : out:
    2851                 :        156 :         inode_unlock(inode);
    2852                 :        156 :         return error;
    2853                 :            : }
    2854                 :            : 
    2855                 :       9282 : static int shmem_statfs(struct dentry *dentry, struct kstatfs *buf)
    2856                 :            : {
    2857                 :       9282 :         struct shmem_sb_info *sbinfo = SHMEM_SB(dentry->d_sb);
    2858                 :            : 
    2859                 :       9282 :         buf->f_type = TMPFS_MAGIC;
    2860                 :       9282 :         buf->f_bsize = PAGE_SIZE;
    2861                 :       9282 :         buf->f_namelen = NAME_MAX;
    2862         [ +  - ]:       9282 :         if (sbinfo->max_blocks) {
    2863                 :       9282 :                 buf->f_blocks = sbinfo->max_blocks;
    2864                 :      18564 :                 buf->f_bavail =
    2865                 :      18564 :                 buf->f_bfree  = sbinfo->max_blocks -
    2866                 :       9282 :                                 percpu_counter_sum(&sbinfo->used_blocks);
    2867                 :            :         }
    2868         [ +  - ]:       9282 :         if (sbinfo->max_inodes) {
    2869                 :       9282 :                 buf->f_files = sbinfo->max_inodes;
    2870                 :       9282 :                 buf->f_ffree = sbinfo->free_inodes;
    2871                 :            :         }
    2872                 :            :         /* else leave those fields 0 like simple_statfs */
    2873                 :       9282 :         return 0;
    2874                 :            : }
    2875                 :            : 
    2876                 :            : /*
    2877                 :            :  * File creation. Allocate an inode, and we're done..
    2878                 :            :  */
    2879                 :            : static int
    2880                 :      42815 : shmem_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev)
    2881                 :            : {
    2882                 :      42815 :         struct inode *inode;
    2883                 :      42815 :         int error = -ENOSPC;
    2884                 :            : 
    2885                 :      42815 :         inode = shmem_get_inode(dir->i_sb, dir, mode, dev, VM_NORESERVE);
    2886         [ +  - ]:      42815 :         if (inode) {
    2887                 :      42815 :                 error = simple_acl_create(dir, inode);
    2888         [ -  + ]:      42815 :                 if (error)
    2889                 :          0 :                         goto out_iput;
    2890                 :      42815 :                 error = security_inode_init_security(inode, dir,
    2891                 :      42815 :                                                      &dentry->d_name,
    2892                 :            :                                                      shmem_initxattrs, NULL);
    2893         [ -  + ]:      42815 :                 if (error && error != -EOPNOTSUPP)
    2894                 :          0 :                         goto out_iput;
    2895                 :            : 
    2896                 :      42815 :                 error = 0;
    2897                 :      42815 :                 dir->i_size += BOGO_DIRENT_SIZE;
    2898                 :      42815 :                 dir->i_ctime = dir->i_mtime = current_time(dir);
    2899                 :      42815 :                 d_instantiate(dentry, inode);
    2900         [ +  - ]:      42815 :                 dget(dentry); /* Extra count - pin the dentry in core */
    2901                 :            :         }
    2902                 :            :         return error;
    2903                 :          0 : out_iput:
    2904                 :          0 :         iput(inode);
    2905                 :          0 :         return error;
    2906                 :            : }
    2907                 :            : 
    2908                 :            : static int
    2909                 :          0 : shmem_tmpfile(struct inode *dir, struct dentry *dentry, umode_t mode)
    2910                 :            : {
    2911                 :          0 :         struct inode *inode;
    2912                 :          0 :         int error = -ENOSPC;
    2913                 :            : 
    2914                 :          0 :         inode = shmem_get_inode(dir->i_sb, dir, mode, 0, VM_NORESERVE);
    2915         [ #  # ]:          0 :         if (inode) {
    2916                 :          0 :                 error = security_inode_init_security(inode, dir,
    2917                 :            :                                                      NULL,
    2918                 :            :                                                      shmem_initxattrs, NULL);
    2919         [ #  # ]:          0 :                 if (error && error != -EOPNOTSUPP)
    2920                 :          0 :                         goto out_iput;
    2921                 :          0 :                 error = simple_acl_create(dir, inode);
    2922         [ #  # ]:          0 :                 if (error)
    2923                 :          0 :                         goto out_iput;
    2924                 :          0 :                 d_tmpfile(dentry, inode);
    2925                 :            :         }
    2926                 :            :         return error;
    2927                 :          0 : out_iput:
    2928                 :          0 :         iput(inode);
    2929                 :          0 :         return error;
    2930                 :            : }
    2931                 :            : 
    2932                 :       5850 : static int shmem_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
    2933                 :            : {
    2934                 :       5850 :         int error;
    2935                 :            : 
    2936         [ +  - ]:       5850 :         if ((error = shmem_mknod(dir, dentry, mode | S_IFDIR, 0)))
    2937                 :            :                 return error;
    2938                 :       5850 :         inc_nlink(dir);
    2939                 :       5850 :         return 0;
    2940                 :            : }
    2941                 :            : 
    2942                 :      25811 : static int shmem_create(struct inode *dir, struct dentry *dentry, umode_t mode,
    2943                 :            :                 bool excl)
    2944                 :            : {
    2945                 :      25811 :         return shmem_mknod(dir, dentry, mode | S_IFREG, 0);
    2946                 :            : }
    2947                 :            : 
    2948                 :            : /*
    2949                 :            :  * Link a file..
    2950                 :            :  */
    2951                 :          0 : static int shmem_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
    2952                 :            : {
    2953         [ #  # ]:          0 :         struct inode *inode = d_inode(old_dentry);
    2954                 :          0 :         int ret = 0;
    2955                 :            : 
    2956                 :            :         /*
    2957                 :            :          * No ordinary (disk based) filesystem counts links as inodes;
    2958                 :            :          * but each new link needs a new dentry, pinning lowmem, and
    2959                 :            :          * tmpfs dentries cannot be pruned until they are unlinked.
    2960                 :            :          * But if an O_TMPFILE file is linked into the tmpfs, the
    2961                 :            :          * first link must skip that, to get the accounting right.
    2962                 :            :          */
    2963         [ #  # ]:          0 :         if (inode->i_nlink) {
    2964                 :          0 :                 ret = shmem_reserve_inode(inode->i_sb);
    2965         [ #  # ]:          0 :                 if (ret)
    2966                 :          0 :                         goto out;
    2967                 :            :         }
    2968                 :            : 
    2969                 :          0 :         dir->i_size += BOGO_DIRENT_SIZE;
    2970                 :          0 :         inode->i_ctime = dir->i_ctime = dir->i_mtime = current_time(inode);
    2971                 :          0 :         inc_nlink(inode);
    2972                 :          0 :         ihold(inode);   /* New dentry reference */
    2973         [ #  # ]:          0 :         dget(dentry);           /* Extra pinning count for the created dentry */
    2974                 :          0 :         d_instantiate(dentry, inode);
    2975                 :          0 : out:
    2976                 :          0 :         return ret;
    2977                 :            : }
    2978                 :            : 
    2979                 :       8507 : static int shmem_unlink(struct inode *dir, struct dentry *dentry)
    2980                 :            : {
    2981         [ -  + ]:       8507 :         struct inode *inode = d_inode(dentry);
    2982                 :            : 
    2983   [ -  +  -  - ]:       8507 :         if (inode->i_nlink > 1 && !S_ISDIR(inode->i_mode))
    2984                 :          0 :                 shmem_free_inode(inode->i_sb);
    2985                 :            : 
    2986                 :       8507 :         dir->i_size -= BOGO_DIRENT_SIZE;
    2987                 :       8507 :         inode->i_ctime = dir->i_ctime = dir->i_mtime = current_time(inode);
    2988                 :       8507 :         drop_nlink(inode);
    2989                 :       8507 :         dput(dentry);   /* Undo the count from "create" - this does all the work */
    2990                 :       8507 :         return 0;
    2991                 :            : }
    2992                 :            : 
    2993                 :        234 : static int shmem_rmdir(struct inode *dir, struct dentry *dentry)
    2994                 :            : {
    2995         [ +  + ]:        234 :         if (!simple_empty(dentry))
    2996                 :            :                 return -ENOTEMPTY;
    2997                 :            : 
    2998                 :        156 :         drop_nlink(d_inode(dentry));
    2999                 :        156 :         drop_nlink(dir);
    3000                 :        156 :         return shmem_unlink(dir, dentry);
    3001                 :            : }
    3002                 :            : 
    3003                 :          0 : static int shmem_exchange(struct inode *old_dir, struct dentry *old_dentry, struct inode *new_dir, struct dentry *new_dentry)
    3004                 :            : {
    3005         [ #  # ]:          0 :         bool old_is_dir = d_is_dir(old_dentry);
    3006         [ #  # ]:          0 :         bool new_is_dir = d_is_dir(new_dentry);
    3007                 :            : 
    3008         [ #  # ]:          0 :         if (old_dir != new_dir && old_is_dir != new_is_dir) {
    3009         [ #  # ]:          0 :                 if (old_is_dir) {
    3010                 :          0 :                         drop_nlink(old_dir);
    3011                 :          0 :                         inc_nlink(new_dir);
    3012                 :            :                 } else {
    3013                 :          0 :                         drop_nlink(new_dir);
    3014                 :          0 :                         inc_nlink(old_dir);
    3015                 :            :                 }
    3016                 :            :         }
    3017                 :          0 :         old_dir->i_ctime = old_dir->i_mtime =
    3018                 :          0 :         new_dir->i_ctime = new_dir->i_mtime =
    3019                 :          0 :         d_inode(old_dentry)->i_ctime =
    3020                 :          0 :         d_inode(new_dentry)->i_ctime = current_time(old_dir);
    3021                 :            : 
    3022                 :          0 :         return 0;
    3023                 :            : }
    3024                 :            : 
    3025                 :          0 : static int shmem_whiteout(struct inode *old_dir, struct dentry *old_dentry)
    3026                 :            : {
    3027                 :          0 :         struct dentry *whiteout;
    3028                 :          0 :         int error;
    3029                 :            : 
    3030                 :          0 :         whiteout = d_alloc(old_dentry->d_parent, &old_dentry->d_name);
    3031         [ #  # ]:          0 :         if (!whiteout)
    3032                 :            :                 return -ENOMEM;
    3033                 :            : 
    3034                 :          0 :         error = shmem_mknod(old_dir, whiteout,
    3035                 :            :                             S_IFCHR | WHITEOUT_MODE, WHITEOUT_DEV);
    3036                 :          0 :         dput(whiteout);
    3037         [ #  # ]:          0 :         if (error)
    3038                 :            :                 return error;
    3039                 :            : 
    3040                 :            :         /*
    3041                 :            :          * Cheat and hash the whiteout while the old dentry is still in
    3042                 :            :          * place, instead of playing games with FS_RENAME_DOES_D_MOVE.
    3043                 :            :          *
    3044                 :            :          * d_lookup() will consistently find one of them at this point,
    3045                 :            :          * not sure which one, but that isn't even important.
    3046                 :            :          */
    3047                 :          0 :         d_rehash(whiteout);
    3048                 :          0 :         return 0;
    3049                 :            : }
    3050                 :            : 
    3051                 :            : /*
    3052                 :            :  * The VFS layer already does all the dentry stuff for rename,
    3053                 :            :  * we just have to decrement the usage count for the target if
    3054                 :            :  * it exists so that the VFS layer correctly free's it when it
    3055                 :            :  * gets overwritten.
    3056                 :            :  */
    3057                 :      17616 : static int shmem_rename2(struct inode *old_dir, struct dentry *old_dentry, struct inode *new_dir, struct dentry *new_dentry, unsigned int flags)
    3058                 :            : {
    3059         [ +  - ]:      17616 :         struct inode *inode = d_inode(old_dentry);
    3060                 :      17616 :         int they_are_dirs = S_ISDIR(inode->i_mode);
    3061                 :            : 
    3062         [ +  - ]:      17616 :         if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE | RENAME_WHITEOUT))
    3063                 :            :                 return -EINVAL;
    3064                 :            : 
    3065         [ -  + ]:      17616 :         if (flags & RENAME_EXCHANGE)
    3066                 :          0 :                 return shmem_exchange(old_dir, old_dentry, new_dir, new_dentry);
    3067                 :            : 
    3068         [ +  - ]:      17616 :         if (!simple_empty(new_dentry))
    3069                 :            :                 return -ENOTEMPTY;
    3070                 :            : 
    3071         [ -  + ]:      17616 :         if (flags & RENAME_WHITEOUT) {
    3072                 :          0 :                 int error;
    3073                 :            : 
    3074                 :          0 :                 error = shmem_whiteout(old_dir, old_dentry);
    3075         [ #  # ]:          0 :                 if (error)
    3076                 :            :                         return error;
    3077                 :            :         }
    3078                 :            : 
    3079         [ +  + ]:      17616 :         if (d_really_is_positive(new_dentry)) {
    3080                 :       1047 :                 (void) shmem_unlink(new_dir, new_dentry);
    3081         [ -  + ]:       1047 :                 if (they_are_dirs) {
    3082                 :          0 :                         drop_nlink(d_inode(new_dentry));
    3083                 :          0 :                         drop_nlink(old_dir);
    3084                 :            :                 }
    3085         [ -  + ]:      16569 :         } else if (they_are_dirs) {
    3086                 :          0 :                 drop_nlink(old_dir);
    3087                 :          0 :                 inc_nlink(new_dir);
    3088                 :            :         }
    3089                 :            : 
    3090                 :      17616 :         old_dir->i_size -= BOGO_DIRENT_SIZE;
    3091                 :      17616 :         new_dir->i_size += BOGO_DIRENT_SIZE;
    3092                 :      35232 :         old_dir->i_ctime = old_dir->i_mtime =
    3093                 :      17616 :         new_dir->i_ctime = new_dir->i_mtime =
    3094                 :      17616 :         inode->i_ctime = current_time(old_dir);
    3095                 :      17616 :         return 0;
    3096                 :            : }
    3097                 :            : 
    3098                 :      15990 : static int shmem_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
    3099                 :            : {
    3100                 :      15990 :         int error;
    3101                 :      15990 :         int len;
    3102                 :      15990 :         struct inode *inode;
    3103                 :      15990 :         struct page *page;
    3104                 :            : 
    3105                 :      15990 :         len = strlen(symname) + 1;
    3106         [ +  - ]:      15990 :         if (len > PAGE_SIZE)
    3107                 :            :                 return -ENAMETOOLONG;
    3108                 :            : 
    3109                 :      15990 :         inode = shmem_get_inode(dir->i_sb, dir, S_IFLNK | 0777, 0,
    3110                 :            :                                 VM_NORESERVE);
    3111         [ +  - ]:      15990 :         if (!inode)
    3112                 :            :                 return -ENOSPC;
    3113                 :            : 
    3114                 :      15990 :         error = security_inode_init_security(inode, dir, &dentry->d_name,
    3115                 :            :                                              shmem_initxattrs, NULL);
    3116         [ -  + ]:      15990 :         if (error) {
    3117         [ #  # ]:          0 :                 if (error != -EOPNOTSUPP) {
    3118                 :          0 :                         iput(inode);
    3119                 :          0 :                         return error;
    3120                 :            :                 }
    3121                 :            :                 error = 0;
    3122                 :            :         }
    3123                 :            : 
    3124                 :      15990 :         inode->i_size = len-1;
    3125         [ +  - ]:      15990 :         if (len <= SHORT_SYMLINK_LEN) {
    3126                 :      15990 :                 inode->i_link = kmemdup(symname, len, GFP_KERNEL);
    3127         [ -  + ]:      15990 :                 if (!inode->i_link) {
    3128                 :          0 :                         iput(inode);
    3129                 :          0 :                         return -ENOMEM;
    3130                 :            :                 }
    3131                 :      15990 :                 inode->i_op = &shmem_short_symlink_operations;
    3132                 :            :         } else {
    3133                 :          0 :                 inode_nohighmem(inode);
    3134                 :          0 :                 error = shmem_getpage(inode, 0, &page, SGP_WRITE);
    3135         [ #  # ]:          0 :                 if (error) {
    3136                 :          0 :                         iput(inode);
    3137                 :          0 :                         return error;
    3138                 :            :                 }
    3139                 :          0 :                 inode->i_mapping->a_ops = &shmem_aops;
    3140                 :          0 :                 inode->i_op = &shmem_symlink_inode_operations;
    3141                 :          0 :                 memcpy(page_address(page), symname, len);
    3142                 :          0 :                 SetPageUptodate(page);
    3143                 :          0 :                 set_page_dirty(page);
    3144                 :          0 :                 unlock_page(page);
    3145                 :          0 :                 put_page(page);
    3146                 :            :         }
    3147                 :      15990 :         dir->i_size += BOGO_DIRENT_SIZE;
    3148                 :      15990 :         dir->i_ctime = dir->i_mtime = current_time(dir);
    3149                 :      15990 :         d_instantiate(dentry, inode);
    3150         [ +  - ]:      15990 :         dget(dentry);
    3151                 :            :         return 0;
    3152                 :            : }
    3153                 :            : 
    3154                 :          0 : static void shmem_put_link(void *arg)
    3155                 :            : {
    3156                 :          0 :         mark_page_accessed(arg);
    3157                 :          0 :         put_page(arg);
    3158                 :          0 : }
    3159                 :            : 
    3160                 :          0 : static const char *shmem_get_link(struct dentry *dentry,
    3161                 :            :                                   struct inode *inode,
    3162                 :            :                                   struct delayed_call *done)
    3163                 :            : {
    3164                 :          0 :         struct page *page = NULL;
    3165                 :          0 :         int error;
    3166         [ #  # ]:          0 :         if (!dentry) {
    3167                 :          0 :                 page = find_get_page(inode->i_mapping, 0);
    3168         [ #  # ]:          0 :                 if (!page)
    3169                 :            :                         return ERR_PTR(-ECHILD);
    3170         [ #  # ]:          0 :                 if (!PageUptodate(page)) {
    3171                 :          0 :                         put_page(page);
    3172                 :          0 :                         return ERR_PTR(-ECHILD);
    3173                 :            :                 }
    3174                 :            :         } else {
    3175                 :          0 :                 error = shmem_getpage(inode, 0, &page, SGP_READ);
    3176         [ #  # ]:          0 :                 if (error)
    3177                 :          0 :                         return ERR_PTR(error);
    3178                 :          0 :                 unlock_page(page);
    3179                 :            :         }
    3180                 :          0 :         set_delayed_call(done, shmem_put_link, page);
    3181                 :          0 :         return page_address(page);
    3182                 :            : }
    3183                 :            : 
    3184                 :            : #ifdef CONFIG_TMPFS_XATTR
    3185                 :            : /*
    3186                 :            :  * Superblocks without xattr inode operations may get some security.* xattr
    3187                 :            :  * support from the LSM "for free". As soon as we have any other xattrs
    3188                 :            :  * like ACLs, we also need to implement the security.* handlers at
    3189                 :            :  * filesystem level, though.
    3190                 :            :  */
    3191                 :            : 
    3192                 :            : /*
    3193                 :            :  * Callback for security_inode_init_security() for acquiring xattrs.
    3194                 :            :  */
    3195                 :          0 : static int shmem_initxattrs(struct inode *inode,
    3196                 :            :                             const struct xattr *xattr_array,
    3197                 :            :                             void *fs_info)
    3198                 :            : {
    3199                 :          0 :         struct shmem_inode_info *info = SHMEM_I(inode);
    3200                 :          0 :         const struct xattr *xattr;
    3201                 :          0 :         struct simple_xattr *new_xattr;
    3202                 :          0 :         size_t len;
    3203                 :            : 
    3204         [ #  # ]:          0 :         for (xattr = xattr_array; xattr->name != NULL; xattr++) {
    3205                 :          0 :                 new_xattr = simple_xattr_alloc(xattr->value, xattr->value_len);
    3206         [ #  # ]:          0 :                 if (!new_xattr)
    3207                 :            :                         return -ENOMEM;
    3208                 :            : 
    3209                 :          0 :                 len = strlen(xattr->name) + 1;
    3210         [ #  # ]:          0 :                 new_xattr->name = kmalloc(XATTR_SECURITY_PREFIX_LEN + len,
    3211                 :            :                                           GFP_KERNEL);
    3212         [ #  # ]:          0 :                 if (!new_xattr->name) {
    3213                 :          0 :                         kfree(new_xattr);
    3214                 :          0 :                         return -ENOMEM;
    3215                 :            :                 }
    3216                 :            : 
    3217                 :          0 :                 memcpy(new_xattr->name, XATTR_SECURITY_PREFIX,
    3218                 :            :                        XATTR_SECURITY_PREFIX_LEN);
    3219                 :          0 :                 memcpy(new_xattr->name + XATTR_SECURITY_PREFIX_LEN,
    3220                 :          0 :                        xattr->name, len);
    3221                 :            : 
    3222                 :          0 :                 simple_xattr_list_add(&info->xattrs, new_xattr);
    3223                 :            :         }
    3224                 :            : 
    3225                 :            :         return 0;
    3226                 :            : }
    3227                 :            : 
    3228                 :      16602 : static int shmem_xattr_handler_get(const struct xattr_handler *handler,
    3229                 :            :                                    struct dentry *unused, struct inode *inode,
    3230                 :            :                                    const char *name, void *buffer, size_t size)
    3231                 :            : {
    3232                 :      16602 :         struct shmem_inode_info *info = SHMEM_I(inode);
    3233                 :            : 
    3234                 :      16602 :         name = xattr_full_name(handler, name);
    3235                 :      16602 :         return simple_xattr_get(&info->xattrs, name, buffer, size);
    3236                 :            : }
    3237                 :            : 
    3238                 :          0 : static int shmem_xattr_handler_set(const struct xattr_handler *handler,
    3239                 :            :                                    struct dentry *unused, struct inode *inode,
    3240                 :            :                                    const char *name, const void *value,
    3241                 :            :                                    size_t size, int flags)
    3242                 :            : {
    3243                 :          0 :         struct shmem_inode_info *info = SHMEM_I(inode);
    3244                 :            : 
    3245                 :          0 :         name = xattr_full_name(handler, name);
    3246                 :          0 :         return simple_xattr_set(&info->xattrs, name, value, size, flags);
    3247                 :            : }
    3248                 :            : 
    3249                 :            : static const struct xattr_handler shmem_security_xattr_handler = {
    3250                 :            :         .prefix = XATTR_SECURITY_PREFIX,
    3251                 :            :         .get = shmem_xattr_handler_get,
    3252                 :            :         .set = shmem_xattr_handler_set,
    3253                 :            : };
    3254                 :            : 
    3255                 :            : static const struct xattr_handler shmem_trusted_xattr_handler = {
    3256                 :            :         .prefix = XATTR_TRUSTED_PREFIX,
    3257                 :            :         .get = shmem_xattr_handler_get,
    3258                 :            :         .set = shmem_xattr_handler_set,
    3259                 :            : };
    3260                 :            : 
    3261                 :            : static const struct xattr_handler *shmem_xattr_handlers[] = {
    3262                 :            : #ifdef CONFIG_TMPFS_POSIX_ACL
    3263                 :            :         &posix_acl_access_xattr_handler,
    3264                 :            :         &posix_acl_default_xattr_handler,
    3265                 :            : #endif
    3266                 :            :         &shmem_security_xattr_handler,
    3267                 :            :         &shmem_trusted_xattr_handler,
    3268                 :            :         NULL
    3269                 :            : };
    3270                 :            : 
    3271                 :          0 : static ssize_t shmem_listxattr(struct dentry *dentry, char *buffer, size_t size)
    3272                 :            : {
    3273                 :          0 :         struct shmem_inode_info *info = SHMEM_I(d_inode(dentry));
    3274                 :          0 :         return simple_xattr_list(d_inode(dentry), &info->xattrs, buffer, size);
    3275                 :            : }
    3276                 :            : #endif /* CONFIG_TMPFS_XATTR */
    3277                 :            : 
    3278                 :            : static const struct inode_operations shmem_short_symlink_operations = {
    3279                 :            :         .get_link       = simple_get_link,
    3280                 :            : #ifdef CONFIG_TMPFS_XATTR
    3281                 :            :         .listxattr      = shmem_listxattr,
    3282                 :            : #endif
    3283                 :            : };
    3284                 :            : 
    3285                 :            : static const struct inode_operations shmem_symlink_inode_operations = {
    3286                 :            :         .get_link       = shmem_get_link,
    3287                 :            : #ifdef CONFIG_TMPFS_XATTR
    3288                 :            :         .listxattr      = shmem_listxattr,
    3289                 :            : #endif
    3290                 :            : };
    3291                 :            : 
    3292                 :          0 : static struct dentry *shmem_get_parent(struct dentry *child)
    3293                 :            : {
    3294                 :          0 :         return ERR_PTR(-ESTALE);
    3295                 :            : }
    3296                 :            : 
    3297                 :          0 : static int shmem_match(struct inode *ino, void *vfh)
    3298                 :            : {
    3299                 :          0 :         __u32 *fh = vfh;
    3300                 :          0 :         __u64 inum = fh[2];
    3301                 :          0 :         inum = (inum << 32) | fh[1];
    3302   [ #  #  #  # ]:          0 :         return ino->i_ino == inum && fh[0] == ino->i_generation;
    3303                 :            : }
    3304                 :            : 
    3305                 :            : /* Find any alias of inode, but prefer a hashed alias */
    3306                 :          0 : static struct dentry *shmem_find_alias(struct inode *inode)
    3307                 :            : {
    3308                 :          0 :         struct dentry *alias = d_find_alias(inode);
    3309                 :            : 
    3310         [ #  # ]:          0 :         return alias ?: d_find_any_alias(inode);
    3311                 :            : }
    3312                 :            : 
    3313                 :            : 
    3314                 :          0 : static struct dentry *shmem_fh_to_dentry(struct super_block *sb,
    3315                 :            :                 struct fid *fid, int fh_len, int fh_type)
    3316                 :            : {
    3317                 :          0 :         struct inode *inode;
    3318                 :          0 :         struct dentry *dentry = NULL;
    3319                 :          0 :         u64 inum;
    3320                 :            : 
    3321         [ #  # ]:          0 :         if (fh_len < 3)
    3322                 :            :                 return NULL;
    3323                 :            : 
    3324                 :          0 :         inum = fid->raw[2];
    3325                 :          0 :         inum = (inum << 32) | fid->raw[1];
    3326                 :            : 
    3327                 :          0 :         inode = ilookup5(sb, (unsigned long)(inum + fid->raw[0]),
    3328                 :          0 :                         shmem_match, fid->raw);
    3329         [ #  # ]:          0 :         if (inode) {
    3330                 :          0 :                 dentry = shmem_find_alias(inode);
    3331                 :          0 :                 iput(inode);
    3332                 :            :         }
    3333                 :            : 
    3334                 :            :         return dentry;
    3335                 :            : }
    3336                 :            : 
    3337                 :       1716 : static int shmem_encode_fh(struct inode *inode, __u32 *fh, int *len,
    3338                 :            :                                 struct inode *parent)
    3339                 :            : {
    3340         [ -  + ]:       1716 :         if (*len < 3) {
    3341                 :          0 :                 *len = 3;
    3342                 :          0 :                 return FILEID_INVALID;
    3343                 :            :         }
    3344                 :            : 
    3345         [ +  + ]:       1716 :         if (inode_unhashed(inode)) {
    3346                 :            :                 /* Unfortunately insert_inode_hash is not idempotent,
    3347                 :            :                  * so as we hash inodes here rather than at creation
    3348                 :            :                  * time, we need a lock to ensure we only try
    3349                 :            :                  * to do it once
    3350                 :            :                  */
    3351                 :        546 :                 static DEFINE_SPINLOCK(lock);
    3352                 :        546 :                 spin_lock(&lock);
    3353         [ +  - ]:        546 :                 if (inode_unhashed(inode))
    3354                 :        546 :                         __insert_inode_hash(inode,
    3355                 :        546 :                                             inode->i_ino + inode->i_generation);
    3356                 :        546 :                 spin_unlock(&lock);
    3357                 :            :         }
    3358                 :            : 
    3359                 :       1716 :         fh[0] = inode->i_generation;
    3360                 :       1716 :         fh[1] = inode->i_ino;
    3361                 :       1716 :         fh[2] = ((__u64)inode->i_ino) >> 32;
    3362                 :            : 
    3363                 :       1716 :         *len = 3;
    3364                 :       1716 :         return 1;
    3365                 :            : }
    3366                 :            : 
    3367                 :            : static const struct export_operations shmem_export_ops = {
    3368                 :            :         .get_parent     = shmem_get_parent,
    3369                 :            :         .encode_fh      = shmem_encode_fh,
    3370                 :            :         .fh_to_dentry   = shmem_fh_to_dentry,
    3371                 :            : };
    3372                 :            : 
    3373                 :            : enum shmem_param {
    3374                 :            :         Opt_gid,
    3375                 :            :         Opt_huge,
    3376                 :            :         Opt_mode,
    3377                 :            :         Opt_mpol,
    3378                 :            :         Opt_nr_blocks,
    3379                 :            :         Opt_nr_inodes,
    3380                 :            :         Opt_size,
    3381                 :            :         Opt_uid,
    3382                 :            : };
    3383                 :            : 
    3384                 :            : static const struct constant_table shmem_param_enums_huge[] = {
    3385                 :            :         {"never",     SHMEM_HUGE_NEVER },
    3386                 :            :         {"always",    SHMEM_HUGE_ALWAYS },
    3387                 :            :         {"within_size",       SHMEM_HUGE_WITHIN_SIZE },
    3388                 :            :         {"advise",    SHMEM_HUGE_ADVISE },
    3389                 :            :         {}
    3390                 :            : };
    3391                 :            : 
    3392                 :            : const struct fs_parameter_spec shmem_fs_parameters[] = {
    3393                 :            :         fsparam_u32   ("gid",         Opt_gid),
    3394                 :            :         fsparam_enum  ("huge",                Opt_huge,  shmem_param_enums_huge),
    3395                 :            :         fsparam_u32oct("mode",                Opt_mode),
    3396                 :            :         fsparam_string("mpol",                Opt_mpol),
    3397                 :            :         fsparam_string("nr_blocks",   Opt_nr_blocks),
    3398                 :            :         fsparam_string("nr_inodes",   Opt_nr_inodes),
    3399                 :            :         fsparam_string("size",                Opt_size),
    3400                 :            :         fsparam_u32   ("uid",         Opt_uid),
    3401                 :            :         {}
    3402                 :            : };
    3403                 :            : 
    3404                 :       1170 : static int shmem_parse_one(struct fs_context *fc, struct fs_parameter *param)
    3405                 :            : {
    3406                 :       1170 :         struct shmem_options *ctx = fc->fs_private;
    3407                 :       1170 :         struct fs_parse_result result;
    3408                 :       1170 :         unsigned long long size;
    3409                 :       1170 :         char *rest;
    3410                 :       1170 :         int opt;
    3411                 :            : 
    3412                 :       1170 :         opt = fs_parse(fc, shmem_fs_parameters, param, &result);
    3413         [ +  + ]:       1170 :         if (opt < 0)
    3414                 :            :                 return opt;
    3415                 :            : 
    3416   [ +  -  -  +  :        624 :         switch (opt) {
             -  -  -  -  
                      - ]
    3417                 :         78 :         case Opt_size:
    3418                 :         78 :                 size = memparse(param->string, &rest);
    3419         [ -  + ]:         78 :                 if (*rest == '%') {
    3420                 :          0 :                         size <<= PAGE_SHIFT;
    3421                 :          0 :                         size *= totalram_pages();
    3422                 :          0 :                         do_div(size, 100);
    3423                 :          0 :                         rest++;
    3424                 :            :                 }
    3425         [ -  + ]:         78 :                 if (*rest)
    3426                 :          0 :                         goto bad_value;
    3427                 :         78 :                 ctx->blocks = DIV_ROUND_UP(size, PAGE_SIZE);
    3428                 :         78 :                 ctx->seen |= SHMEM_SEEN_BLOCKS;
    3429                 :         78 :                 break;
    3430                 :          0 :         case Opt_nr_blocks:
    3431                 :          0 :                 ctx->blocks = memparse(param->string, &rest);
    3432         [ #  # ]:          0 :                 if (*rest)
    3433                 :          0 :                         goto bad_value;
    3434                 :          0 :                 ctx->seen |= SHMEM_SEEN_BLOCKS;
    3435                 :          0 :                 break;
    3436                 :          0 :         case Opt_nr_inodes:
    3437                 :          0 :                 ctx->inodes = memparse(param->string, &rest);
    3438         [ #  # ]:          0 :                 if (*rest)
    3439                 :          0 :                         goto bad_value;
    3440                 :          0 :                 ctx->seen |= SHMEM_SEEN_INODES;
    3441                 :          0 :                 break;
    3442                 :        546 :         case Opt_mode:
    3443                 :        546 :                 ctx->mode = result.uint_32 & 07777;
    3444                 :        546 :                 break;
    3445                 :          0 :         case Opt_uid:
    3446         [ #  # ]:          0 :                 ctx->uid = make_kuid(current_user_ns(), result.uint_32);
    3447         [ #  # ]:          0 :                 if (!uid_valid(ctx->uid))
    3448                 :          0 :                         goto bad_value;
    3449                 :            :                 break;
    3450                 :          0 :         case Opt_gid:
    3451         [ #  # ]:          0 :                 ctx->gid = make_kgid(current_user_ns(), result.uint_32);
    3452         [ #  # ]:          0 :                 if (!gid_valid(ctx->gid))
    3453                 :          0 :                         goto bad_value;
    3454                 :            :                 break;
    3455                 :          0 :         case Opt_huge:
    3456                 :          0 :                 ctx->huge = result.uint_32;
    3457         [ #  # ]:          0 :                 if (ctx->huge != SHMEM_HUGE_NEVER &&
    3458                 :            :                     !(IS_ENABLED(CONFIG_TRANSPARENT_HUGE_PAGECACHE) &&
    3459                 :            :                       has_transparent_hugepage()))
    3460                 :          0 :                         goto unsupported_parameter;
    3461                 :          0 :                 ctx->seen |= SHMEM_SEEN_HUGE;
    3462                 :          0 :                 break;
    3463                 :            :         case Opt_mpol:
    3464                 :          0 :                 if (IS_ENABLED(CONFIG_NUMA)) {
    3465         [ #  # ]:          0 :                         mpol_put(ctx->mpol);
    3466                 :          0 :                         ctx->mpol = NULL;
    3467         [ #  # ]:          0 :                         if (mpol_parse_str(param->string, &ctx->mpol))
    3468                 :          0 :                                 goto bad_value;
    3469                 :            :                         break;
    3470                 :            :                 }
    3471                 :            :                 goto unsupported_parameter;
    3472                 :            :         }
    3473                 :            :         return 0;
    3474                 :            : 
    3475                 :            : unsupported_parameter:
    3476                 :          0 :         return invalfc(fc, "Unsupported parameter '%s'", param->key);
    3477                 :          0 : bad_value:
    3478                 :          0 :         return invalfc(fc, "Bad value for '%s'", param->key);
    3479                 :            : }
    3480                 :            : 
    3481                 :        624 : static int shmem_parse_options(struct fs_context *fc, void *data)
    3482                 :            : {
    3483                 :        624 :         char *options = data;
    3484                 :            : 
    3485         [ +  + ]:        624 :         if (options) {
    3486                 :        546 :                 int err = security_sb_eat_lsm_opts(options, &fc->security);
    3487         [ +  - ]:        546 :                 if (err)
    3488                 :            :                         return err;
    3489                 :            :         }
    3490                 :            : 
    3491         [ +  + ]:       1248 :         while (options != NULL) {
    3492                 :            :                 char *this_char = options;
    3493                 :        624 :                 for (;;) {
    3494                 :            :                         /*
    3495                 :            :                          * NUL-terminate this option: unfortunately,
    3496                 :            :                          * mount options form a comma-separated list,
    3497                 :            :                          * but mpol's nodelist may also contain commas.
    3498                 :            :                          */
    3499                 :        624 :                         options = strchr(options, ',');
    3500         [ +  + ]:        624 :                         if (options == NULL)
    3501                 :            :                                 break;
    3502                 :         78 :                         options++;
    3503         [ -  + ]:         78 :                         if (!isdigit(*options)) {
    3504                 :         78 :                                 options[-1] = '\0';
    3505                 :         78 :                                 break;
    3506                 :            :                         }
    3507                 :            :                 }
    3508         [ +  - ]:        624 :                 if (*this_char) {
    3509                 :        624 :                         char *value = strchr(this_char,'=');
    3510                 :        624 :                         size_t len = 0;
    3511                 :        624 :                         int err;
    3512                 :            : 
    3513         [ +  - ]:        624 :                         if (value) {
    3514                 :        624 :                                 *value++ = '\0';
    3515                 :        624 :                                 len = strlen(value);
    3516                 :            :                         }
    3517                 :        624 :                         err = vfs_parse_fs_string(fc, this_char, value, len);
    3518         [ -  + ]:        624 :                         if (err < 0)
    3519                 :          0 :                                 return err;
    3520                 :            :                 }
    3521                 :            :         }
    3522                 :            :         return 0;
    3523                 :            : }
    3524                 :            : 
    3525                 :            : /*
    3526                 :            :  * Reconfigure a shmem filesystem.
    3527                 :            :  *
    3528                 :            :  * Note that we disallow change from limited->unlimited blocks/inodes while any
    3529                 :            :  * are in use; but we must separately disallow unlimited->limited, because in
    3530                 :            :  * that case we have no record of how much is already in use.
    3531                 :            :  */
    3532                 :         78 : static int shmem_reconfigure(struct fs_context *fc)
    3533                 :            : {
    3534                 :         78 :         struct shmem_options *ctx = fc->fs_private;
    3535                 :         78 :         struct shmem_sb_info *sbinfo = SHMEM_SB(fc->root->d_sb);
    3536                 :         78 :         unsigned long inodes;
    3537                 :         78 :         const char *err;
    3538                 :            : 
    3539                 :         78 :         spin_lock(&sbinfo->stat_lock);
    3540                 :         78 :         inodes = sbinfo->max_inodes - sbinfo->free_inodes;
    3541   [ -  +  -  - ]:         78 :         if ((ctx->seen & SHMEM_SEEN_BLOCKS) && ctx->blocks) {
    3542         [ #  # ]:          0 :                 if (!sbinfo->max_blocks) {
    3543                 :          0 :                         err = "Cannot retroactively limit size";
    3544                 :          0 :                         goto out;
    3545                 :            :                 }
    3546         [ #  # ]:          0 :                 if (percpu_counter_compare(&sbinfo->used_blocks,
    3547                 :            :                                            ctx->blocks) > 0) {
    3548                 :          0 :                         err = "Too small a size for current use";
    3549                 :          0 :                         goto out;
    3550                 :            :                 }
    3551                 :            :         }
    3552   [ -  +  -  - ]:         78 :         if ((ctx->seen & SHMEM_SEEN_INODES) && ctx->inodes) {
    3553         [ #  # ]:          0 :                 if (!sbinfo->max_inodes) {
    3554                 :          0 :                         err = "Cannot retroactively limit inodes";
    3555                 :          0 :                         goto out;
    3556                 :            :                 }
    3557         [ #  # ]:          0 :                 if (ctx->inodes < inodes) {
    3558                 :          0 :                         err = "Too few inodes for current use";
    3559                 :          0 :                         goto out;
    3560                 :            :                 }
    3561                 :            :         }
    3562                 :            : 
    3563         [ -  + ]:         78 :         if (ctx->seen & SHMEM_SEEN_HUGE)
    3564                 :          0 :                 sbinfo->huge = ctx->huge;
    3565         [ -  + ]:         78 :         if (ctx->seen & SHMEM_SEEN_BLOCKS)
    3566                 :          0 :                 sbinfo->max_blocks  = ctx->blocks;
    3567         [ -  + ]:         78 :         if (ctx->seen & SHMEM_SEEN_INODES) {
    3568                 :          0 :                 sbinfo->max_inodes  = ctx->inodes;
    3569                 :          0 :                 sbinfo->free_inodes = ctx->inodes - inodes;
    3570                 :            :         }
    3571                 :            : 
    3572                 :            :         /*
    3573                 :            :          * Preserve previous mempolicy unless mpol remount option was specified.
    3574                 :            :          */
    3575         [ -  + ]:         78 :         if (ctx->mpol) {
    3576         [ #  # ]:          0 :                 mpol_put(sbinfo->mpol);
    3577                 :          0 :                 sbinfo->mpol = ctx->mpol; /* transfers initial ref */
    3578                 :          0 :                 ctx->mpol = NULL;
    3579                 :            :         }
    3580                 :         78 :         spin_unlock(&sbinfo->stat_lock);
    3581                 :         78 :         return 0;
    3582                 :          0 : out:
    3583                 :          0 :         spin_unlock(&sbinfo->stat_lock);
    3584                 :          0 :         return invalfc(fc, "%s", err);
    3585                 :            : }
    3586                 :            : 
    3587                 :      65520 : static int shmem_show_options(struct seq_file *seq, struct dentry *root)
    3588                 :            : {
    3589                 :      65520 :         struct shmem_sb_info *sbinfo = SHMEM_SB(root->d_sb);
    3590                 :            : 
    3591         [ +  + ]:      65520 :         if (sbinfo->max_blocks != shmem_default_max_blocks())
    3592                 :      13806 :                 seq_printf(seq, ",size=%luk",
    3593                 :      13806 :                         sbinfo->max_blocks << (PAGE_SHIFT - 10));
    3594         [ +  + ]:      65520 :         if (sbinfo->max_inodes != shmem_default_max_inodes())
    3595                 :       5148 :                 seq_printf(seq, ",nr_inodes=%lu", sbinfo->max_inodes);
    3596         [ +  + ]:      65520 :         if (sbinfo->mode != (0777 | S_ISVTX))
    3597                 :      48126 :                 seq_printf(seq, ",mode=%03ho", sbinfo->mode);
    3598         [ -  + ]:      65520 :         if (!uid_eq(sbinfo->uid, GLOBAL_ROOT_UID))
    3599         [ #  # ]:          0 :                 seq_printf(seq, ",uid=%u",
    3600                 :            :                                 from_kuid_munged(&init_user_ns, sbinfo->uid));
    3601         [ -  + ]:      65520 :         if (!gid_eq(sbinfo->gid, GLOBAL_ROOT_GID))
    3602         [ #  # ]:          0 :                 seq_printf(seq, ",gid=%u",
    3603                 :            :                                 from_kgid_munged(&init_user_ns, sbinfo->gid));
    3604                 :            : #ifdef CONFIG_TRANSPARENT_HUGE_PAGECACHE
    3605                 :            :         /* Rightly or wrongly, show huge mount option unmasked by shmem_huge */
    3606                 :            :         if (sbinfo->huge)
    3607                 :            :                 seq_printf(seq, ",huge=%s", shmem_format_huge(sbinfo->huge));
    3608                 :            : #endif
    3609                 :      65520 :         shmem_show_mpol(seq, sbinfo->mpol);
    3610                 :      65520 :         return 0;
    3611                 :            : }
    3612                 :            : 
    3613                 :            : #endif /* CONFIG_TMPFS */
    3614                 :            : 
    3615                 :          0 : static void shmem_put_super(struct super_block *sb)
    3616                 :            : {
    3617                 :          0 :         struct shmem_sb_info *sbinfo = SHMEM_SB(sb);
    3618                 :            : 
    3619                 :          0 :         percpu_counter_destroy(&sbinfo->used_blocks);
    3620         [ #  # ]:          0 :         mpol_put(sbinfo->mpol);
    3621                 :          0 :         kfree(sbinfo);
    3622                 :          0 :         sb->s_fs_info = NULL;
    3623                 :          0 : }
    3624                 :            : 
    3625                 :        546 : static int shmem_fill_super(struct super_block *sb, struct fs_context *fc)
    3626                 :            : {
    3627                 :        546 :         struct shmem_options *ctx = fc->fs_private;
    3628                 :        546 :         struct inode *inode;
    3629                 :        546 :         struct shmem_sb_info *sbinfo;
    3630                 :        546 :         int err = -ENOMEM;
    3631                 :            : 
    3632                 :            :         /* Round up to L1_CACHE_BYTES to resist false sharing */
    3633                 :        546 :         sbinfo = kzalloc(max((int)sizeof(struct shmem_sb_info),
    3634                 :            :                                 L1_CACHE_BYTES), GFP_KERNEL);
    3635         [ +  - ]:        546 :         if (!sbinfo)
    3636                 :            :                 return -ENOMEM;
    3637                 :            : 
    3638                 :        546 :         sb->s_fs_info = sbinfo;
    3639                 :            : 
    3640                 :            : #ifdef CONFIG_TMPFS
    3641                 :            :         /*
    3642                 :            :          * Per default we only allow half of the physical ram per
    3643                 :            :          * tmpfs instance, limiting inodes to one per page of lowmem;
    3644                 :            :          * but the internal instance is left unlimited.
    3645                 :            :          */
    3646         [ +  + ]:        546 :         if (!(sb->s_flags & SB_KERNMOUNT)) {
    3647         [ +  + ]:        468 :                 if (!(ctx->seen & SHMEM_SEEN_BLOCKS))
    3648                 :        390 :                         ctx->blocks = shmem_default_max_blocks();
    3649         [ +  - ]:        468 :                 if (!(ctx->seen & SHMEM_SEEN_INODES))
    3650                 :        468 :                         ctx->inodes = shmem_default_max_inodes();
    3651                 :            :         } else {
    3652                 :         78 :                 sb->s_flags |= SB_NOUSER;
    3653                 :            :         }
    3654                 :        546 :         sb->s_export_op = &shmem_export_ops;
    3655                 :        546 :         sb->s_flags |= SB_NOSEC;
    3656                 :            : #else
    3657                 :            :         sb->s_flags |= SB_NOUSER;
    3658                 :            : #endif
    3659                 :        546 :         sbinfo->max_blocks = ctx->blocks;
    3660                 :        546 :         sbinfo->free_inodes = sbinfo->max_inodes = ctx->inodes;
    3661                 :        546 :         sbinfo->uid = ctx->uid;
    3662                 :        546 :         sbinfo->gid = ctx->gid;
    3663                 :        546 :         sbinfo->mode = ctx->mode;
    3664                 :        546 :         sbinfo->huge = ctx->huge;
    3665                 :        546 :         sbinfo->mpol = ctx->mpol;
    3666                 :        546 :         ctx->mpol = NULL;
    3667                 :            : 
    3668                 :        546 :         spin_lock_init(&sbinfo->stat_lock);
    3669         [ -  + ]:        546 :         if (percpu_counter_init(&sbinfo->used_blocks, 0, GFP_KERNEL))
    3670                 :          0 :                 goto failed;
    3671                 :        546 :         spin_lock_init(&sbinfo->shrinklist_lock);
    3672                 :        546 :         INIT_LIST_HEAD(&sbinfo->shrinklist);
    3673                 :            : 
    3674                 :        546 :         sb->s_maxbytes = MAX_LFS_FILESIZE;
    3675                 :        546 :         sb->s_blocksize = PAGE_SIZE;
    3676                 :        546 :         sb->s_blocksize_bits = PAGE_SHIFT;
    3677                 :        546 :         sb->s_magic = TMPFS_MAGIC;
    3678                 :        546 :         sb->s_op = &shmem_ops;
    3679                 :        546 :         sb->s_time_gran = 1;
    3680                 :            : #ifdef CONFIG_TMPFS_XATTR
    3681                 :        546 :         sb->s_xattr = shmem_xattr_handlers;
    3682                 :            : #endif
    3683                 :            : #ifdef CONFIG_TMPFS_POSIX_ACL
    3684                 :        546 :         sb->s_flags |= SB_POSIXACL;
    3685                 :            : #endif
    3686                 :        546 :         uuid_gen(&sb->s_uuid);
    3687                 :            : 
    3688                 :        546 :         inode = shmem_get_inode(sb, NULL, S_IFDIR | sbinfo->mode, 0, VM_NORESERVE);
    3689         [ -  + ]:        546 :         if (!inode)
    3690                 :          0 :                 goto failed;
    3691                 :        546 :         inode->i_uid = sbinfo->uid;
    3692                 :        546 :         inode->i_gid = sbinfo->gid;
    3693                 :        546 :         sb->s_root = d_make_root(inode);
    3694         [ -  + ]:        546 :         if (!sb->s_root)
    3695                 :          0 :                 goto failed;
    3696                 :            :         return 0;
    3697                 :            : 
    3698                 :          0 : failed:
    3699                 :          0 :         shmem_put_super(sb);
    3700                 :          0 :         return err;
    3701                 :            : }
    3702                 :            : 
    3703                 :        546 : static int shmem_get_tree(struct fs_context *fc)
    3704                 :            : {
    3705                 :        546 :         return get_tree_nodev(fc, shmem_fill_super);
    3706                 :            : }
    3707                 :            : 
    3708                 :        624 : static void shmem_free_fc(struct fs_context *fc)
    3709                 :            : {
    3710                 :        624 :         struct shmem_options *ctx = fc->fs_private;
    3711                 :            : 
    3712         [ +  - ]:        624 :         if (ctx) {
    3713         [ -  + ]:        624 :                 mpol_put(ctx->mpol);
    3714                 :        624 :                 kfree(ctx);
    3715                 :            :         }
    3716                 :        624 : }
    3717                 :            : 
    3718                 :            : static const struct fs_context_operations shmem_fs_context_ops = {
    3719                 :            :         .free                   = shmem_free_fc,
    3720                 :            :         .get_tree               = shmem_get_tree,
    3721                 :            : #ifdef CONFIG_TMPFS
    3722                 :            :         .parse_monolithic       = shmem_parse_options,
    3723                 :            :         .parse_param            = shmem_parse_one,
    3724                 :            :         .reconfigure            = shmem_reconfigure,
    3725                 :            : #endif
    3726                 :            : };
    3727                 :            : 
    3728                 :            : static struct kmem_cache *shmem_inode_cachep;
    3729                 :            : 
    3730                 :      59351 : static struct inode *shmem_alloc_inode(struct super_block *sb)
    3731                 :            : {
    3732                 :      59351 :         struct shmem_inode_info *info;
    3733                 :      59351 :         info = kmem_cache_alloc(shmem_inode_cachep, GFP_KERNEL);
    3734         [ +  - ]:      59351 :         if (!info)
    3735                 :            :                 return NULL;
    3736                 :      59351 :         return &info->vfs_inode;
    3737                 :            : }
    3738                 :            : 
    3739                 :       8507 : static void shmem_free_in_core_inode(struct inode *inode)
    3740                 :            : {
    3741         [ +  + ]:       8507 :         if (S_ISLNK(inode->i_mode))
    3742                 :         78 :                 kfree(inode->i_link);
    3743                 :       8507 :         kmem_cache_free(shmem_inode_cachep, SHMEM_I(inode));
    3744                 :       8507 : }
    3745                 :            : 
    3746                 :       8507 : static void shmem_destroy_inode(struct inode *inode)
    3747                 :            : {
    3748         [ +  + ]:       8507 :         if (S_ISREG(inode->i_mode))
    3749                 :       8273 :                 mpol_free_shared_policy(&SHMEM_I(inode)->policy);
    3750                 :       8507 : }
    3751                 :            : 
    3752                 :      51760 : static void shmem_init_inode(void *foo)
    3753                 :            : {
    3754                 :      51760 :         struct shmem_inode_info *info = foo;
    3755                 :      51760 :         inode_init_once(&info->vfs_inode);
    3756                 :      51760 : }
    3757                 :            : 
    3758                 :         78 : static void shmem_init_inodecache(void)
    3759                 :            : {
    3760                 :        156 :         shmem_inode_cachep = kmem_cache_create("shmem_inode_cache",
    3761                 :            :                                 sizeof(struct shmem_inode_info),
    3762                 :            :                                 0, SLAB_PANIC|SLAB_ACCOUNT, shmem_init_inode);
    3763                 :            : }
    3764                 :            : 
    3765                 :          0 : static void shmem_destroy_inodecache(void)
    3766                 :            : {
    3767                 :          0 :         kmem_cache_destroy(shmem_inode_cachep);
    3768                 :            : }
    3769                 :            : 
    3770                 :            : static const struct address_space_operations shmem_aops = {
    3771                 :            :         .writepage      = shmem_writepage,
    3772                 :            :         .set_page_dirty = __set_page_dirty_no_writeback,
    3773                 :            : #ifdef CONFIG_TMPFS
    3774                 :            :         .write_begin    = shmem_write_begin,
    3775                 :            :         .write_end      = shmem_write_end,
    3776                 :            : #endif
    3777                 :            : #ifdef CONFIG_MIGRATION
    3778                 :            :         .migratepage    = migrate_page,
    3779                 :            : #endif
    3780                 :            :         .error_remove_page = generic_error_remove_page,
    3781                 :            : };
    3782                 :            : 
    3783                 :            : static const struct file_operations shmem_file_operations = {
    3784                 :            :         .mmap           = shmem_mmap,
    3785                 :            :         .get_unmapped_area = shmem_get_unmapped_area,
    3786                 :            : #ifdef CONFIG_TMPFS
    3787                 :            :         .llseek         = shmem_file_llseek,
    3788                 :            :         .read_iter      = shmem_file_read_iter,
    3789                 :            :         .write_iter     = generic_file_write_iter,
    3790                 :            :         .fsync          = noop_fsync,
    3791                 :            :         .splice_read    = generic_file_splice_read,
    3792                 :            :         .splice_write   = iter_file_splice_write,
    3793                 :            :         .fallocate      = shmem_fallocate,
    3794                 :            : #endif
    3795                 :            : };
    3796                 :            : 
    3797                 :            : static const struct inode_operations shmem_inode_operations = {
    3798                 :            :         .getattr        = shmem_getattr,
    3799                 :            :         .setattr        = shmem_setattr,
    3800                 :            : #ifdef CONFIG_TMPFS_XATTR
    3801                 :            :         .listxattr      = shmem_listxattr,
    3802                 :            :         .set_acl        = simple_set_acl,
    3803                 :            : #endif
    3804                 :            : };
    3805                 :            : 
    3806                 :            : static const struct inode_operations shmem_dir_inode_operations = {
    3807                 :            : #ifdef CONFIG_TMPFS
    3808                 :            :         .create         = shmem_create,
    3809                 :            :         .lookup         = simple_lookup,
    3810                 :            :         .link           = shmem_link,
    3811                 :            :         .unlink         = shmem_unlink,
    3812                 :            :         .symlink        = shmem_symlink,
    3813                 :            :         .mkdir          = shmem_mkdir,
    3814                 :            :         .rmdir          = shmem_rmdir,
    3815                 :            :         .mknod          = shmem_mknod,
    3816                 :            :         .rename         = shmem_rename2,
    3817                 :            :         .tmpfile        = shmem_tmpfile,
    3818                 :            : #endif
    3819                 :            : #ifdef CONFIG_TMPFS_XATTR
    3820                 :            :         .listxattr      = shmem_listxattr,
    3821                 :            : #endif
    3822                 :            : #ifdef CONFIG_TMPFS_POSIX_ACL
    3823                 :            :         .setattr        = shmem_setattr,
    3824                 :            :         .set_acl        = simple_set_acl,
    3825                 :            : #endif
    3826                 :            : };
    3827                 :            : 
    3828                 :            : static const struct inode_operations shmem_special_inode_operations = {
    3829                 :            : #ifdef CONFIG_TMPFS_XATTR
    3830                 :            :         .listxattr      = shmem_listxattr,
    3831                 :            : #endif
    3832                 :            : #ifdef CONFIG_TMPFS_POSIX_ACL
    3833                 :            :         .setattr        = shmem_setattr,
    3834                 :            :         .set_acl        = simple_set_acl,
    3835                 :            : #endif
    3836                 :            : };
    3837                 :            : 
    3838                 :            : static const struct super_operations shmem_ops = {
    3839                 :            :         .alloc_inode    = shmem_alloc_inode,
    3840                 :            :         .free_inode     = shmem_free_in_core_inode,
    3841                 :            :         .destroy_inode  = shmem_destroy_inode,
    3842                 :            : #ifdef CONFIG_TMPFS
    3843                 :            :         .statfs         = shmem_statfs,
    3844                 :            :         .show_options   = shmem_show_options,
    3845                 :            : #endif
    3846                 :            :         .evict_inode    = shmem_evict_inode,
    3847                 :            :         .drop_inode     = generic_delete_inode,
    3848                 :            :         .put_super      = shmem_put_super,
    3849                 :            : #ifdef CONFIG_TRANSPARENT_HUGE_PAGECACHE
    3850                 :            :         .nr_cached_objects      = shmem_unused_huge_count,
    3851                 :            :         .free_cached_objects    = shmem_unused_huge_scan,
    3852                 :            : #endif
    3853                 :            : };
    3854                 :            : 
    3855                 :            : static const struct vm_operations_struct shmem_vm_ops = {
    3856                 :            :         .fault          = shmem_fault,
    3857                 :            :         .map_pages      = filemap_map_pages,
    3858                 :            : #ifdef CONFIG_NUMA
    3859                 :            :         .set_policy     = shmem_set_policy,
    3860                 :            :         .get_policy     = shmem_get_policy,
    3861                 :            : #endif
    3862                 :            : };
    3863                 :            : 
    3864                 :        624 : int shmem_init_fs_context(struct fs_context *fc)
    3865                 :            : {
    3866                 :        624 :         struct shmem_options *ctx;
    3867                 :            : 
    3868                 :        624 :         ctx = kzalloc(sizeof(struct shmem_options), GFP_KERNEL);
    3869         [ +  - ]:        624 :         if (!ctx)
    3870                 :            :                 return -ENOMEM;
    3871                 :            : 
    3872                 :        624 :         ctx->mode = 0777 | S_ISVTX;
    3873                 :        624 :         ctx->uid = current_fsuid();
    3874                 :        624 :         ctx->gid = current_fsgid();
    3875                 :            : 
    3876                 :        624 :         fc->fs_private = ctx;
    3877                 :        624 :         fc->ops = &shmem_fs_context_ops;
    3878                 :        624 :         return 0;
    3879                 :            : }
    3880                 :            : 
    3881                 :            : static struct file_system_type shmem_fs_type = {
    3882                 :            :         .owner          = THIS_MODULE,
    3883                 :            :         .name           = "tmpfs",
    3884                 :            :         .init_fs_context = shmem_init_fs_context,
    3885                 :            : #ifdef CONFIG_TMPFS
    3886                 :            :         .parameters     = shmem_fs_parameters,
    3887                 :            : #endif
    3888                 :            :         .kill_sb        = kill_litter_super,
    3889                 :            :         .fs_flags       = FS_USERNS_MOUNT,
    3890                 :            : };
    3891                 :            : 
    3892                 :         78 : int __init shmem_init(void)
    3893                 :            : {
    3894                 :         78 :         int error;
    3895                 :            : 
    3896                 :         78 :         shmem_init_inodecache();
    3897                 :            : 
    3898                 :         78 :         error = register_filesystem(&shmem_fs_type);
    3899         [ -  + ]:         78 :         if (error) {
    3900                 :          0 :                 pr_err("Could not register tmpfs\n");
    3901                 :          0 :                 goto out2;
    3902                 :            :         }
    3903                 :            : 
    3904                 :         78 :         shm_mnt = kern_mount(&shmem_fs_type);
    3905         [ -  + ]:         78 :         if (IS_ERR(shm_mnt)) {
    3906                 :          0 :                 error = PTR_ERR(shm_mnt);
    3907                 :          0 :                 pr_err("Could not kern_mount tmpfs\n");
    3908                 :          0 :                 goto out1;
    3909                 :            :         }
    3910                 :            : 
    3911                 :            : #ifdef CONFIG_TRANSPARENT_HUGE_PAGECACHE
    3912                 :            :         if (has_transparent_hugepage() && shmem_huge > SHMEM_HUGE_DENY)
    3913                 :            :                 SHMEM_SB(shm_mnt->mnt_sb)->huge = shmem_huge;
    3914                 :            :         else
    3915                 :            :                 shmem_huge = 0; /* just in case it was patched */
    3916                 :            : #endif
    3917                 :            :         return 0;
    3918                 :            : 
    3919                 :            : out1:
    3920                 :          0 :         unregister_filesystem(&shmem_fs_type);
    3921                 :          0 : out2:
    3922                 :          0 :         shmem_destroy_inodecache();
    3923                 :          0 :         shm_mnt = ERR_PTR(error);
    3924                 :          0 :         return error;
    3925                 :            : }
    3926                 :            : 
    3927                 :            : #if defined(CONFIG_TRANSPARENT_HUGE_PAGECACHE) && defined(CONFIG_SYSFS)
    3928                 :            : static ssize_t shmem_enabled_show(struct kobject *kobj,
    3929                 :            :                 struct kobj_attribute *attr, char *buf)
    3930                 :            : {
    3931                 :            :         static const int values[] = {
    3932                 :            :                 SHMEM_HUGE_ALWAYS,
    3933                 :            :                 SHMEM_HUGE_WITHIN_SIZE,
    3934                 :            :                 SHMEM_HUGE_ADVISE,
    3935                 :            :                 SHMEM_HUGE_NEVER,
    3936                 :            :                 SHMEM_HUGE_DENY,
    3937                 :            :                 SHMEM_HUGE_FORCE,
    3938                 :            :         };
    3939                 :            :         int i, count;
    3940                 :            : 
    3941                 :            :         for (i = 0, count = 0; i < ARRAY_SIZE(values); i++) {
    3942                 :            :                 const char *fmt = shmem_huge == values[i] ? "[%s] " : "%s ";
    3943                 :            : 
    3944                 :            :                 count += sprintf(buf + count, fmt,
    3945                 :            :                                 shmem_format_huge(values[i]));
    3946                 :            :         }
    3947                 :            :         buf[count - 1] = '\n';
    3948                 :            :         return count;
    3949                 :            : }
    3950                 :            : 
    3951                 :            : static ssize_t shmem_enabled_store(struct kobject *kobj,
    3952                 :            :                 struct kobj_attribute *attr, const char *buf, size_t count)
    3953                 :            : {
    3954                 :            :         char tmp[16];
    3955                 :            :         int huge;
    3956                 :            : 
    3957                 :            :         if (count + 1 > sizeof(tmp))
    3958                 :            :                 return -EINVAL;
    3959                 :            :         memcpy(tmp, buf, count);
    3960                 :            :         tmp[count] = '\0';
    3961                 :            :         if (count && tmp[count - 1] == '\n')
    3962                 :            :                 tmp[count - 1] = '\0';
    3963                 :            : 
    3964                 :            :         huge = shmem_parse_huge(tmp);
    3965                 :            :         if (huge == -EINVAL)
    3966                 :            :                 return -EINVAL;
    3967                 :            :         if (!has_transparent_hugepage() &&
    3968                 :            :                         huge != SHMEM_HUGE_NEVER && huge != SHMEM_HUGE_DENY)
    3969                 :            :                 return -EINVAL;
    3970                 :            : 
    3971                 :            :         shmem_huge = huge;
    3972                 :            :         if (shmem_huge > SHMEM_HUGE_DENY)
    3973                 :            :                 SHMEM_SB(shm_mnt->mnt_sb)->huge = shmem_huge;
    3974                 :            :         return count;
    3975                 :            : }
    3976                 :            : 
    3977                 :            : struct kobj_attribute shmem_enabled_attr =
    3978                 :            :         __ATTR(shmem_enabled, 0644, shmem_enabled_show, shmem_enabled_store);
    3979                 :            : #endif /* CONFIG_TRANSPARENT_HUGE_PAGECACHE && CONFIG_SYSFS */
    3980                 :            : 
    3981                 :            : #ifdef CONFIG_TRANSPARENT_HUGE_PAGECACHE
    3982                 :            : bool shmem_huge_enabled(struct vm_area_struct *vma)
    3983                 :            : {
    3984                 :            :         struct inode *inode = file_inode(vma->vm_file);
    3985                 :            :         struct shmem_sb_info *sbinfo = SHMEM_SB(inode->i_sb);
    3986                 :            :         loff_t i_size;
    3987                 :            :         pgoff_t off;
    3988                 :            : 
    3989                 :            :         if ((vma->vm_flags & VM_NOHUGEPAGE) ||
    3990                 :            :             test_bit(MMF_DISABLE_THP, &vma->vm_mm->flags))
    3991                 :            :                 return false;
    3992                 :            :         if (shmem_huge == SHMEM_HUGE_FORCE)
    3993                 :            :                 return true;
    3994                 :            :         if (shmem_huge == SHMEM_HUGE_DENY)
    3995                 :            :                 return false;
    3996                 :            :         switch (sbinfo->huge) {
    3997                 :            :                 case SHMEM_HUGE_NEVER:
    3998                 :            :                         return false;
    3999                 :            :                 case SHMEM_HUGE_ALWAYS:
    4000                 :            :                         return true;
    4001                 :            :                 case SHMEM_HUGE_WITHIN_SIZE:
    4002                 :            :                         off = round_up(vma->vm_pgoff, HPAGE_PMD_NR);
    4003                 :            :                         i_size = round_up(i_size_read(inode), PAGE_SIZE);
    4004                 :            :                         if (i_size >= HPAGE_PMD_SIZE &&
    4005                 :            :                                         i_size >> PAGE_SHIFT >= off)
    4006                 :            :                                 return true;
    4007                 :            :                         /* fall through */
    4008                 :            :                 case SHMEM_HUGE_ADVISE:
    4009                 :            :                         /* TODO: implement fadvise() hints */
    4010                 :            :                         return (vma->vm_flags & VM_HUGEPAGE);
    4011                 :            :                 default:
    4012                 :            :                         VM_BUG_ON(1);
    4013                 :            :                         return false;
    4014                 :            :         }
    4015                 :            : }
    4016                 :            : #endif /* CONFIG_TRANSPARENT_HUGE_PAGECACHE */
    4017                 :            : 
    4018                 :            : #else /* !CONFIG_SHMEM */
    4019                 :            : 
    4020                 :            : /*
    4021                 :            :  * tiny-shmem: simple shmemfs and tmpfs using ramfs code
    4022                 :            :  *
    4023                 :            :  * This is intended for small system where the benefits of the full
    4024                 :            :  * shmem code (swap-backed and resource-limited) are outweighed by
    4025                 :            :  * their complexity. On systems without swap this code should be
    4026                 :            :  * effectively equivalent, but much lighter weight.
    4027                 :            :  */
    4028                 :            : 
    4029                 :            : static struct file_system_type shmem_fs_type = {
    4030                 :            :         .name           = "tmpfs",
    4031                 :            :         .init_fs_context = ramfs_init_fs_context,
    4032                 :            :         .parameters     = ramfs_fs_parameters,
    4033                 :            :         .kill_sb        = kill_litter_super,
    4034                 :            :         .fs_flags       = FS_USERNS_MOUNT,
    4035                 :            : };
    4036                 :            : 
    4037                 :            : int __init shmem_init(void)
    4038                 :            : {
    4039                 :            :         BUG_ON(register_filesystem(&shmem_fs_type) != 0);
    4040                 :            : 
    4041                 :            :         shm_mnt = kern_mount(&shmem_fs_type);
    4042                 :            :         BUG_ON(IS_ERR(shm_mnt));
    4043                 :            : 
    4044                 :            :         return 0;
    4045                 :            : }
    4046                 :            : 
    4047                 :            : int shmem_unuse(unsigned int type, bool frontswap,
    4048                 :            :                 unsigned long *fs_pages_to_unuse)
    4049                 :            : {
    4050                 :            :         return 0;
    4051                 :            : }
    4052                 :            : 
    4053                 :            : int shmem_lock(struct file *file, int lock, struct user_struct *user)
    4054                 :            : {
    4055                 :            :         return 0;
    4056                 :            : }
    4057                 :            : 
    4058                 :            : void shmem_unlock_mapping(struct address_space *mapping)
    4059                 :            : {
    4060                 :            : }
    4061                 :            : 
    4062                 :            : #ifdef CONFIG_MMU
    4063                 :            : unsigned long shmem_get_unmapped_area(struct file *file,
    4064                 :            :                                       unsigned long addr, unsigned long len,
    4065                 :            :                                       unsigned long pgoff, unsigned long flags)
    4066                 :            : {
    4067                 :            :         return current->mm->get_unmapped_area(file, addr, len, pgoff, flags);
    4068                 :            : }
    4069                 :            : #endif
    4070                 :            : 
    4071                 :            : void shmem_truncate_range(struct inode *inode, loff_t lstart, loff_t lend)
    4072                 :            : {
    4073                 :            :         truncate_inode_pages_range(inode->i_mapping, lstart, lend);
    4074                 :            : }
    4075                 :            : EXPORT_SYMBOL_GPL(shmem_truncate_range);
    4076                 :            : 
    4077                 :            : #define shmem_vm_ops                            generic_file_vm_ops
    4078                 :            : #define shmem_file_operations                   ramfs_file_operations
    4079                 :            : #define shmem_get_inode(sb, dir, mode, dev, flags)      ramfs_get_inode(sb, dir, mode, dev)
    4080                 :            : #define shmem_acct_size(flags, size)            0
    4081                 :            : #define shmem_unacct_size(flags, size)          do {} while (0)
    4082                 :            : 
    4083                 :            : #endif /* CONFIG_SHMEM */
    4084                 :            : 
    4085                 :            : /* common code */
    4086                 :            : 
    4087                 :          0 : static struct file *__shmem_file_setup(struct vfsmount *mnt, const char *name, loff_t size,
    4088                 :            :                                        unsigned long flags, unsigned int i_flags)
    4089                 :            : {
    4090                 :          0 :         struct inode *inode;
    4091                 :          0 :         struct file *res;
    4092                 :            : 
    4093         [ #  # ]:          0 :         if (IS_ERR(mnt))
    4094                 :            :                 return ERR_CAST(mnt);
    4095                 :            : 
    4096         [ #  # ]:          0 :         if (size < 0 || size > MAX_LFS_FILESIZE)
    4097                 :            :                 return ERR_PTR(-EINVAL);
    4098                 :            : 
    4099   [ #  #  #  # ]:          0 :         if (shmem_acct_size(flags, size))
    4100                 :            :                 return ERR_PTR(-ENOMEM);
    4101                 :            : 
    4102                 :          0 :         inode = shmem_get_inode(mnt->mnt_sb, NULL, S_IFREG | S_IRWXUGO, 0,
    4103                 :            :                                 flags);
    4104         [ #  # ]:          0 :         if (unlikely(!inode)) {
    4105                 :          0 :                 shmem_unacct_size(flags, size);
    4106                 :          0 :                 return ERR_PTR(-ENOSPC);
    4107                 :            :         }
    4108                 :          0 :         inode->i_flags |= i_flags;
    4109                 :          0 :         inode->i_size = size;
    4110                 :          0 :         clear_nlink(inode);     /* It is unlinked */
    4111                 :          0 :         res = ERR_PTR(ramfs_nommu_expand_for_mapping(inode, size));
    4112                 :          0 :         if (!IS_ERR(res))
    4113                 :          0 :                 res = alloc_file_pseudo(inode, mnt, name, O_RDWR,
    4114                 :            :                                 &shmem_file_operations);
    4115         [ #  # ]:          0 :         if (IS_ERR(res))
    4116                 :          0 :                 iput(inode);
    4117                 :            :         return res;
    4118                 :            : }
    4119                 :            : 
    4120                 :            : /**
    4121                 :            :  * shmem_kernel_file_setup - get an unlinked file living in tmpfs which must be
    4122                 :            :  *      kernel internal.  There will be NO LSM permission checks against the
    4123                 :            :  *      underlying inode.  So users of this interface must do LSM checks at a
    4124                 :            :  *      higher layer.  The users are the big_key and shm implementations.  LSM
    4125                 :            :  *      checks are provided at the key or shm level rather than the inode.
    4126                 :            :  * @name: name for dentry (to be seen in /proc/<pid>/maps
    4127                 :            :  * @size: size to be set for the file
    4128                 :            :  * @flags: VM_NORESERVE suppresses pre-accounting of the entire object size
    4129                 :            :  */
    4130                 :          0 : struct file *shmem_kernel_file_setup(const char *name, loff_t size, unsigned long flags)
    4131                 :            : {
    4132                 :          0 :         return __shmem_file_setup(shm_mnt, name, size, flags, S_PRIVATE);
    4133                 :            : }
    4134                 :            : 
    4135                 :            : /**
    4136                 :            :  * shmem_file_setup - get an unlinked file living in tmpfs
    4137                 :            :  * @name: name for dentry (to be seen in /proc/<pid>/maps
    4138                 :            :  * @size: size to be set for the file
    4139                 :            :  * @flags: VM_NORESERVE suppresses pre-accounting of the entire object size
    4140                 :            :  */
    4141                 :          0 : struct file *shmem_file_setup(const char *name, loff_t size, unsigned long flags)
    4142                 :            : {
    4143                 :          0 :         return __shmem_file_setup(shm_mnt, name, size, flags, 0);
    4144                 :            : }
    4145                 :            : EXPORT_SYMBOL_GPL(shmem_file_setup);
    4146                 :            : 
    4147                 :            : /**
    4148                 :            :  * shmem_file_setup_with_mnt - get an unlinked file living in tmpfs
    4149                 :            :  * @mnt: the tmpfs mount where the file will be created
    4150                 :            :  * @name: name for dentry (to be seen in /proc/<pid>/maps
    4151                 :            :  * @size: size to be set for the file
    4152                 :            :  * @flags: VM_NORESERVE suppresses pre-accounting of the entire object size
    4153                 :            :  */
    4154                 :          0 : struct file *shmem_file_setup_with_mnt(struct vfsmount *mnt, const char *name,
    4155                 :            :                                        loff_t size, unsigned long flags)
    4156                 :            : {
    4157                 :          0 :         return __shmem_file_setup(mnt, name, size, flags, 0);
    4158                 :            : }
    4159                 :            : EXPORT_SYMBOL_GPL(shmem_file_setup_with_mnt);
    4160                 :            : 
    4161                 :            : /**
    4162                 :            :  * shmem_zero_setup - setup a shared anonymous mapping
    4163                 :            :  * @vma: the vma to be mmapped is prepared by do_mmap_pgoff
    4164                 :            :  */
    4165                 :          0 : int shmem_zero_setup(struct vm_area_struct *vma)
    4166                 :            : {
    4167                 :          0 :         struct file *file;
    4168                 :          0 :         loff_t size = vma->vm_end - vma->vm_start;
    4169                 :            : 
    4170                 :            :         /*
    4171                 :            :          * Cloning a new file under mmap_sem leads to a lock ordering conflict
    4172                 :            :          * between XFS directory reading and selinux: since this file is only
    4173                 :            :          * accessible to the user through its mapping, use S_PRIVATE flag to
    4174                 :            :          * bypass file security, in the same way as shmem_kernel_file_setup().
    4175                 :            :          */
    4176                 :          0 :         file = shmem_kernel_file_setup("dev/zero", size, vma->vm_flags);
    4177         [ #  # ]:          0 :         if (IS_ERR(file))
    4178                 :          0 :                 return PTR_ERR(file);
    4179                 :            : 
    4180         [ #  # ]:          0 :         if (vma->vm_file)
    4181                 :          0 :                 fput(vma->vm_file);
    4182                 :          0 :         vma->vm_file = file;
    4183                 :          0 :         vma->vm_ops = &shmem_vm_ops;
    4184                 :            : 
    4185                 :          0 :         if (IS_ENABLED(CONFIG_TRANSPARENT_HUGE_PAGECACHE) &&
    4186                 :            :                         ((vma->vm_start + ~HPAGE_PMD_MASK) & HPAGE_PMD_MASK) <
    4187                 :            :                         (vma->vm_end & HPAGE_PMD_MASK)) {
    4188                 :            :                 khugepaged_enter(vma, vma->vm_flags);
    4189                 :            :         }
    4190                 :            : 
    4191                 :          0 :         return 0;
    4192                 :            : }
    4193                 :            : 
    4194                 :            : /**
    4195                 :            :  * shmem_read_mapping_page_gfp - read into page cache, using specified page allocation flags.
    4196                 :            :  * @mapping:    the page's address_space
    4197                 :            :  * @index:      the page index
    4198                 :            :  * @gfp:        the page allocator flags to use if allocating
    4199                 :            :  *
    4200                 :            :  * This behaves as a tmpfs "read_cache_page_gfp(mapping, index, gfp)",
    4201                 :            :  * with any new page allocations done using the specified allocation flags.
    4202                 :            :  * But read_cache_page_gfp() uses the ->readpage() method: which does not
    4203                 :            :  * suit tmpfs, since it may have pages in swapcache, and needs to find those
    4204                 :            :  * for itself; although drivers/gpu/drm i915 and ttm rely upon this support.
    4205                 :            :  *
    4206                 :            :  * i915_gem_object_get_pages_gtt() mixes __GFP_NORETRY | __GFP_NOWARN in
    4207                 :            :  * with the mapping_gfp_mask(), to avoid OOMing the machine unnecessarily.
    4208                 :            :  */
    4209                 :          0 : struct page *shmem_read_mapping_page_gfp(struct address_space *mapping,
    4210                 :            :                                          pgoff_t index, gfp_t gfp)
    4211                 :            : {
    4212                 :            : #ifdef CONFIG_SHMEM
    4213                 :          0 :         struct inode *inode = mapping->host;
    4214                 :          0 :         struct page *page;
    4215                 :          0 :         int error;
    4216                 :            : 
    4217         [ #  # ]:          0 :         BUG_ON(mapping->a_ops != &shmem_aops);
    4218                 :          0 :         error = shmem_getpage_gfp(inode, index, &page, SGP_CACHE,
    4219                 :            :                                   gfp, NULL, NULL, NULL);
    4220         [ #  # ]:          0 :         if (error)
    4221                 :          0 :                 page = ERR_PTR(error);
    4222                 :            :         else
    4223                 :          0 :                 unlock_page(page);
    4224                 :          0 :         return page;
    4225                 :            : #else
    4226                 :            :         /*
    4227                 :            :          * The tiny !SHMEM case uses ramfs without swap
    4228                 :            :          */
    4229                 :            :         return read_cache_page_gfp(mapping, index, gfp);
    4230                 :            : #endif
    4231                 :            : }
    4232                 :            : EXPORT_SYMBOL_GPL(shmem_read_mapping_page_gfp);

Generated by: LCOV version 1.14