mm/hugetlb: add missing annotation for gather_surplus_pages()

[linux-2.6-microblaze.git] / mm / swapfile.c

diff --git a/mm/swapfile.c b/mm/swapfile.c
index 2c33ff4..273a923 100644 (file)
--- a/mm/swapfile.c
+++ b/mm/swapfile.c
@@ -2132,7 +2132,7 @@ int try_to_unuse(unsigned int type, bool frontswap,
        swp_entry_t entry;
        unsigned int i;
 
-       if (!si->inuse_pages)
+       if (!READ_ONCE(si->inuse_pages))
                return 0;
 
        if (!frontswap)
@@ -2148,7 +2148,7 @@ retry:
 
        spin_lock(&mmlist_lock);
        p = &init_mm.mmlist;
-       while (si->inuse_pages &&
+       while (READ_ONCE(si->inuse_pages) &&
               !signal_pending(current) &&
               (p = p->next) != &init_mm.mmlist) {
 
@@ -2177,7 +2177,7 @@ retry:
        mmput(prev_mm);
 
        i = 0;
-       while (si->inuse_pages &&
+       while (READ_ONCE(si->inuse_pages) &&
               !signal_pending(current) &&
               (i = find_next_to_unuse(si, i, frontswap)) != 0) {
 
@@ -2219,7 +2219,7 @@ retry:
         * been preempted after get_swap_page(), temporarily hiding that swap.
         * It's easy and robust (though cpu-intensive) just to keep retrying.
         */
-       if (si->inuse_pages) {
+       if (READ_ONCE(si->inuse_pages)) {
                if (!signal_pending(current))
                        goto retry;
                retval = -EINTR;
@@ -2899,10 +2899,6 @@ static int claim_swapfile(struct swap_info_struct *p, struct inode *inode)
                p->bdev = inode->i_sb->s_bdev;
        }
 
-       inode_lock(inode);
-       if (IS_SWAPFILE(inode))
-               return -EBUSY;
-
        return 0;
 }
 
@@ -3157,36 +3153,41 @@ SYSCALL_DEFINE2(swapon, const char __user *, specialfile, int, swap_flags)
        mapping = swap_file->f_mapping;
        inode = mapping->host;
 
-       /* If S_ISREG(inode->i_mode) will do inode_lock(inode); */
        error = claim_swapfile(p, inode);
        if (unlikely(error))
                goto bad_swap;
 
+       inode_lock(inode);
+       if (IS_SWAPFILE(inode)) {
+               error = -EBUSY;
+               goto bad_swap_unlock_inode;
+       }
+
        /*
         * Read the swap header.
         */
        if (!mapping->a_ops->readpage) {
                error = -EINVAL;
-               goto bad_swap;
+               goto bad_swap_unlock_inode;
        }
        page = read_mapping_page(mapping, 0, swap_file);
        if (IS_ERR(page)) {
                error = PTR_ERR(page);
-               goto bad_swap;
+               goto bad_swap_unlock_inode;
        }
        swap_header = kmap(page);
 
        maxpages = read_swap_header(p, swap_header, inode);
        if (unlikely(!maxpages)) {
                error = -EINVAL;
-               goto bad_swap;
+               goto bad_swap_unlock_inode;
        }
 
        /* OK, set up the swap map and apply the bad block list */
        swap_map = vzalloc(maxpages);
        if (!swap_map) {
                error = -ENOMEM;
-               goto bad_swap;
+               goto bad_swap_unlock_inode;
        }
 
        if (bdi_cap_stable_pages_required(inode_to_bdi(inode)))
@@ -3211,7 +3212,7 @@ SYSCALL_DEFINE2(swapon, const char __user *, specialfile, int, swap_flags)
                                        GFP_KERNEL);
                if (!cluster_info) {
                        error = -ENOMEM;
-                       goto bad_swap;
+                       goto bad_swap_unlock_inode;
                }
 
                for (ci = 0; ci < nr_cluster; ci++)
@@ -3220,7 +3221,7 @@ SYSCALL_DEFINE2(swapon, const char __user *, specialfile, int, swap_flags)
                p->percpu_cluster = alloc_percpu(struct percpu_cluster);
                if (!p->percpu_cluster) {
                        error = -ENOMEM;
-                       goto bad_swap;
+                       goto bad_swap_unlock_inode;
                }
                for_each_possible_cpu(cpu) {
                        struct percpu_cluster *cluster;
@@ -3234,13 +3235,13 @@ SYSCALL_DEFINE2(swapon, const char __user *, specialfile, int, swap_flags)
 
        error = swap_cgroup_swapon(p->type, maxpages);
        if (error)
-               goto bad_swap;
+               goto bad_swap_unlock_inode;
 
        nr_extents = setup_swap_map_and_extents(p, swap_header, swap_map,
                cluster_info, maxpages, &span);
        if (unlikely(nr_extents < 0)) {
                error = nr_extents;
-               goto bad_swap;
+               goto bad_swap_unlock_inode;
        }
        /* frontswap enabled? set up bit-per-page map for frontswap */
        if (IS_ENABLED(CONFIG_FRONTSWAP))
@@ -3280,7 +3281,7 @@ SYSCALL_DEFINE2(swapon, const char __user *, specialfile, int, swap_flags)
 
        error = init_swap_address_space(p->type, maxpages);
        if (error)
-               goto bad_swap;
+               goto bad_swap_unlock_inode;
 
        /*
         * Flush any pending IO and dirty mappings before we start using this
@@ -3290,7 +3291,7 @@ SYSCALL_DEFINE2(swapon, const char __user *, specialfile, int, swap_flags)
        error = inode_drain_writes(inode);
        if (error) {
                inode->i_flags &= ~S_SWAPFILE;
-               goto bad_swap;
+               goto bad_swap_unlock_inode;
        }
 
        mutex_lock(&swapon_mutex);
@@ -3315,6 +3316,8 @@ SYSCALL_DEFINE2(swapon, const char __user *, specialfile, int, swap_flags)
 
        error = 0;
        goto out;
+bad_swap_unlock_inode:
+       inode_unlock(inode);
 bad_swap:
        free_percpu(p->percpu_cluster);
        p->percpu_cluster = NULL;
@@ -3322,6 +3325,7 @@ bad_swap:
                set_blocksize(p->bdev, p->old_block_size);
                blkdev_put(p->bdev, FMODE_READ | FMODE_WRITE | FMODE_EXCL);
        }
+       inode = NULL;
        destroy_swap_extents(p);
        swap_cgroup_swapoff(p->type);
        spin_lock(&swap_lock);
@@ -3333,13 +3337,8 @@ bad_swap:
        kvfree(frontswap_map);
        if (inced_nr_rotate_swap)
                atomic_dec(&nr_rotate_swap);
-       if (swap_file) {
-               if (inode) {
-                       inode_unlock(inode);
-                       inode = NULL;
-               }
+       if (swap_file)
                filp_close(swap_file, NULL);
-       }
 out:
        if (page && !IS_ERR(page)) {
                kunmap(page);
@@ -3476,7 +3475,7 @@ int swap_duplicate(swp_entry_t entry)
  *
  * Called when allocating swap cache for existing swap entry,
  * This can return error codes. Returns 0 at success.
- * -EBUSY means there is a swap cache.
+ * -EEXIST means there is a swap cache.
  * Note: return code is different from swap_duplicate().
  */
 int swapcache_prepare(swp_entry_t entry)