Merge branch 'mpi-master' into wip-k-fmlpwip-k-fmlp

Conflicts:
	litmus/sched_cedf.c

1 files changed, 267 insertions, 212 deletions

diff --git a/mm/swapfile.c b/mm/swapfile.c
index 7c703ff2f36f..ff8dc1a18cb4 100644
--- a/mm/swapfile.c
+++ b/mm/swapfile.c
@@ -14,7 +14,7 @@
 #include <linux/vmalloc.h>
 #include <linux/pagemap.h>
 #include <linux/namei.h>
-#include <linux/shm.h>
+#include <linux/shmem_fs.h>
 #include <linux/blkdev.h>
 #include <linux/random.h>
 #include <linux/writeback.h>
@@ -30,6 +30,8 @@
 #include <linux/capability.h>
 #include <linux/syscalls.h>
 #include <linux/memcontrol.h>
+#include <linux/poll.h>
+#include <linux/oom.h>
 
 #include <asm/pgtable.h>
 #include <asm/tlbflush.h>
@@ -58,6 +60,10 @@ static struct swap_info_struct *swap_info[MAX_SWAPFILES];
 
 static DEFINE_MUTEX(swapon_mutex);
 
+static DECLARE_WAIT_QUEUE_HEAD(proc_poll_wait);
+/* Activity counter to indicate that a swapon or swapoff has occurred */
+static atomic_t proc_poll_event = ATOMIC_INIT(0);
+
 static inline unsigned char swap_count(unsigned char ent)
 {
         return ent & ~SWAP_HAS_CACHE;   /* may include SWAP_HAS_CONT flag */
@@ -90,39 +96,6 @@ __try_to_reclaim_swap(struct swap_info_struct *si, unsigned long offset)
 }
 
 /*
- * We need this because the bdev->unplug_fn can sleep and we cannot
- * hold swap_lock while calling the unplug_fn. And swap_lock
- * cannot be turned into a mutex.
- */
-static DECLARE_RWSEM(swap_unplug_sem);
-
-void swap_unplug_io_fn(struct backing_dev_info *unused_bdi, struct page *page)
-{
-        swp_entry_t entry;
-
-        down_read(&swap_unplug_sem);
-        entry.val = page_private(page);
-        if (PageSwapCache(page)) {
-                struct block_device *bdev = swap_info[swp_type(entry)]->bdev;
-                struct backing_dev_info *bdi;
-
-                /*
-                 * If the page is removed from swapcache from under us (with a
-                 * racy try_to_unuse/swapoff) we need an additional reference
-                 * count to avoid reading garbage from page_private(page) above.
-                 * If the WARN_ON triggers during a swapoff it maybe the race
-                 * condition and it's harmless. However if it triggers without
-                 * swapoff it signals a problem.
-                 */
-                WARN_ON(page_count(page) <= 1);
-
-                bdi = bdev->bd_inode->i_mapping->backing_dev_info;
-                blk_run_backing_dev(bdi, page);
-        }
-        up_read(&swap_unplug_sem);
-}
-
-/*
  * swapon tell device that all the old swap contents can be discarded,
  * to allow the swap device to optimize its wear-levelling.
  */
@@ -139,7 +112,7 @@ static int discard_swap(struct swap_info_struct *si)
         nr_blocks = ((sector_t)se->nr_pages - 1) << (PAGE_SHIFT - 9);
         if (nr_blocks) {
                 err = blkdev_issue_discard(si->bdev, start_block,
-                                nr_blocks, GFP_KERNEL, BLKDEV_IFL_WAIT);
+                                nr_blocks, GFP_KERNEL, 0);
                 if (err)
                         return err;
                 cond_resched();
@@ -150,7 +123,7 @@ static int discard_swap(struct swap_info_struct *si)
                 nr_blocks = (sector_t)se->nr_pages << (PAGE_SHIFT - 9);
 
                 err = blkdev_issue_discard(si->bdev, start_block,
-                                nr_blocks, GFP_KERNEL, BLKDEV_IFL_WAIT);
+                                nr_blocks, GFP_KERNEL, 0);
                 if (err)
                         break;
 
@@ -189,7 +162,7 @@ static void discard_swap_cluster(struct swap_info_struct *si,
                         start_block <<= PAGE_SHIFT - 9;
                         nr_blocks <<= PAGE_SHIFT - 9;
                         if (blkdev_issue_discard(si->bdev, start_block,
-                                    nr_blocks, GFP_NOIO, BLKDEV_IFL_WAIT))
+                                    nr_blocks, GFP_NOIO, 0))
                                 break;
                 }
 
@@ -207,8 +180,8 @@ static int wait_for_discard(void *word)
 #define SWAPFILE_CLUSTER        256
 #define LATENCY_LIMIT           256
 
-static inline unsigned long scan_swap_map(struct swap_info_struct *si,
-                                          unsigned char usage)
+static unsigned long scan_swap_map(struct swap_info_struct *si,
+                                   unsigned char usage)
 {
         unsigned long offset;
         unsigned long scan_base;
@@ -875,7 +848,7 @@ unsigned int count_swap_pages(int type, int free)
 static int unuse_pte(struct vm_area_struct *vma, pmd_t *pmd,
                 unsigned long addr, swp_entry_t entry, struct page *page)
 {
-        struct mem_cgroup *ptr = NULL;
+        struct mem_cgroup *ptr;
         spinlock_t *ptl;
         pte_t *pte;
         int ret = 1;
@@ -959,6 +932,8 @@ static inline int unuse_pmd_range(struct vm_area_struct *vma, pud_t *pud,
         pmd = pmd_offset(pud, addr);
         do {
                 next = pmd_addr_end(addr, end);
+                if (unlikely(pmd_trans_huge(*pmd)))
+                        continue;
                 if (pmd_none_or_clear_bad(pmd))
                         continue;
                 ret = unuse_pte_range(vma, pmd, addr, next, entry, page);
@@ -1543,6 +1518,36 @@ bad_bmap:
         goto out;
 }
 
+static void enable_swap_info(struct swap_info_struct *p, int prio,
+                                unsigned char *swap_map)
+{
+        int i, prev;
+
+        spin_lock(&swap_lock);
+        if (prio >= 0)
+                p->prio = prio;
+        else
+                p->prio = --least_priority;
+        p->swap_map = swap_map;
+        p->flags |= SWP_WRITEOK;
+        nr_swap_pages += p->pages;
+        total_swap_pages += p->pages;
+
+        /* insert swap space into swap_list: */
+        prev = -1;
+        for (i = swap_list.head; i >= 0; i = swap_info[i]->next) {
+                if (p->prio >= swap_info[i]->prio)
+                        break;
+                prev = i;
+        }
+        p->next = i;
+        if (prev < 0)
+                swap_list.head = swap_list.next = p->type;
+        else
+                swap_info[prev]->next = p->type;
+        spin_unlock(&swap_lock);
+}
+
 SYSCALL_DEFINE1(swapoff, const char __user *, specialfile)
 {
         struct swap_info_struct *p = NULL;
@@ -1551,6 +1556,7 @@ SYSCALL_DEFINE1(swapoff, const char __user *, specialfile)
         struct address_space *mapping;
         struct inode *inode;
         char *pathname;
+        int oom_score_adj;
         int i, type, prev;
         int err;
 
@@ -1609,37 +1615,22 @@ SYSCALL_DEFINE1(swapoff, const char __user *, specialfile)
         p->flags &= ~SWP_WRITEOK;
         spin_unlock(&swap_lock);
 
-        current->flags |= PF_OOM_ORIGIN;
+        oom_score_adj = test_set_oom_score_adj(OOM_SCORE_ADJ_MAX);
         err = try_to_unuse(type);
-        current->flags &= ~PF_OOM_ORIGIN;
+        test_set_oom_score_adj(oom_score_adj);
 
         if (err) {
+                /*
+                 * reading p->prio and p->swap_map outside the lock is
+                 * safe here because only sys_swapon and sys_swapoff
+                 * change them, and there can be no other sys_swapon or
+                 * sys_swapoff for this swap_info_struct at this point.
+                 */
                 /* re-insert swap space back into swap_list */
-                spin_lock(&swap_lock);
-                if (p->prio < 0)
-                        p->prio = --least_priority;
-                prev = -1;
-                for (i = swap_list.head; i >= 0; i = swap_info[i]->next) {
-                        if (p->prio >= swap_info[i]->prio)
-                                break;
-                        prev = i;
-                }
-                p->next = i;
-                if (prev < 0)
-                        swap_list.head = swap_list.next = type;
-                else
-                        swap_info[prev]->next = type;
-                nr_swap_pages += p->pages;
-                total_swap_pages += p->pages;
-                p->flags |= SWP_WRITEOK;
-                spin_unlock(&swap_lock);
+                enable_swap_info(p, p->prio, p->swap_map);
                 goto out_dput;
         }
 
-        /* wait for any unplug function to finish */
-        down_write(&swap_unplug_sem);
-        up_write(&swap_unplug_sem);
-
         destroy_swap_extents(p);
         if (p->flags & SWP_CONTINUED)
                 free_swap_count_continuations(p);
@@ -1672,7 +1663,7 @@ SYSCALL_DEFINE1(swapoff, const char __user *, specialfile)
         if (S_ISBLK(inode->i_mode)) {
                 struct block_device *bdev = I_BDEV(inode);
                 set_blocksize(bdev, p->old_block_size);
-                bd_release(bdev);
+                blkdev_put(bdev, FMODE_READ | FMODE_WRITE | FMODE_EXCL);
         } else {
                 mutex_lock(&inode->i_mutex);
                 inode->i_flags &= ~S_SWAPFILE;
@@ -1680,6 +1671,8 @@ SYSCALL_DEFINE1(swapoff, const char __user *, specialfile)
         }
         filp_close(swap_file, NULL);
         err = 0;
+        atomic_inc(&proc_poll_event);
+        wake_up_interruptible(&proc_poll_wait);
 
 out_dput:
         filp_close(victim, NULL);
@@ -1688,6 +1681,25 @@ out:
 }
 
 #ifdef CONFIG_PROC_FS
+struct proc_swaps {
+        struct seq_file seq;
+        int event;
+};
+
+static unsigned swaps_poll(struct file *file, poll_table *wait)
+{
+        struct proc_swaps *s = file->private_data;
+
+        poll_wait(file, &proc_poll_wait, wait);
+
+        if (s->event != atomic_read(&proc_poll_event)) {
+                s->event = atomic_read(&proc_poll_event);
+                return POLLIN | POLLRDNORM | POLLERR | POLLPRI;
+        }
+
+        return POLLIN | POLLRDNORM;
+}
+
 /* iterator */
 static void *swap_start(struct seq_file *swap, loff_t *pos)
 {
@@ -1771,7 +1783,24 @@ static const struct seq_operations swaps_op = {
 
 static int swaps_open(struct inode *inode, struct file *file)
 {
-        return seq_open(file, &swaps_op);
+        struct proc_swaps *s;
+        int ret;
+
+        s = kmalloc(sizeof(struct proc_swaps), GFP_KERNEL);
+        if (!s)
+                return -ENOMEM;
+
+        file->private_data = s;
+
+        ret = seq_open(file, &swaps_op);
+        if (ret) {
+                kfree(s);
+                return ret;
+        }
+
+        s->seq.private = s;
+        s->event = atomic_read(&proc_poll_event);
+        return ret;
 }
 
 static const struct file_operations proc_swaps_operations = {
@@ -1779,6 +1808,7 @@ static const struct file_operations proc_swaps_operations = {
         .read           = seq_read,
         .llseek         = seq_lseek,
         .release        = seq_release,
+        .poll           = swaps_poll,
 };
 
 static int __init procswaps_init(void)
@@ -1798,49 +1828,24 @@ static int __init max_swapfiles_check(void)
 late_initcall(max_swapfiles_check);
 #endif
 
-/*
- * Written 01/25/92 by Simmule Turner, heavily changed by Linus.
- *
- * The swapon system call
- */
-SYSCALL_DEFINE2(swapon, const char __user *, specialfile, int, swap_flags)
+static struct swap_info_struct *alloc_swap_info(void)
 {
         struct swap_info_struct *p;
-        char *name = NULL;
-        struct block_device *bdev = NULL;
-        struct file *swap_file = NULL;
-        struct address_space *mapping;
         unsigned int type;
-        int i, prev;
-        int error;
-        union swap_header *swap_header;
-        unsigned int nr_good_pages;
-        int nr_extents = 0;
-        sector_t span;
-        unsigned long maxpages;
-        unsigned long swapfilepages;
-        unsigned char *swap_map = NULL;
-        struct page *page = NULL;
-        struct inode *inode = NULL;
-        int did_down = 0;
-
-        if (!capable(CAP_SYS_ADMIN))
-                return -EPERM;
 
         p = kzalloc(sizeof(*p), GFP_KERNEL);
         if (!p)
-                return -ENOMEM;
+                return ERR_PTR(-ENOMEM);
 
         spin_lock(&swap_lock);
         for (type = 0; type < nr_swapfiles; type++) {
                 if (!(swap_info[type]->flags & SWP_USED))
                         break;
         }
-        error = -EPERM;
         if (type >= MAX_SWAPFILES) {
                 spin_unlock(&swap_lock);
                 kfree(p);
-                goto out;
+                return ERR_PTR(-EPERM);
         }
         if (type >= nr_swapfiles) {
                 p->type = type;
@@ -1865,80 +1870,49 @@ SYSCALL_DEFINE2(swapon, const char __user *, specialfile, int, swap_flags)
         p->next = -1;
         spin_unlock(&swap_lock);
 
-        name = getname(specialfile);
-        error = PTR_ERR(name);
-        if (IS_ERR(name)) {
-                name = NULL;
-                goto bad_swap_2;
-        }
-        swap_file = filp_open(name, O_RDWR|O_LARGEFILE, 0);
-        error = PTR_ERR(swap_file);
-        if (IS_ERR(swap_file)) {
-                swap_file = NULL;
-                goto bad_swap_2;
-        }
-
-        p->swap_file = swap_file;
-        mapping = swap_file->f_mapping;
-        inode = mapping->host;
-
-        error = -EBUSY;
-        for (i = 0; i < nr_swapfiles; i++) {
-                struct swap_info_struct *q = swap_info[i];
+        return p;
+}
 
-                if (i == type || !q->swap_file)
-                        continue;
-                if (mapping == q->swap_file->f_mapping)
-                        goto bad_swap;
-        }
+static int claim_swapfile(struct swap_info_struct *p, struct inode *inode)
+{
+        int error;
 
-        error = -EINVAL;
         if (S_ISBLK(inode->i_mode)) {
-                bdev = I_BDEV(inode);
-                error = bd_claim(bdev, sys_swapon);
+                p->bdev = bdgrab(I_BDEV(inode));
+                error = blkdev_get(p->bdev,
+                                   FMODE_READ | FMODE_WRITE | FMODE_EXCL,
+                                   sys_swapon);
                 if (error < 0) {
-                        bdev = NULL;
-                        error = -EINVAL;
-                        goto bad_swap;
+                        p->bdev = NULL;
+                        return -EINVAL;
                 }
-                p->old_block_size = block_size(bdev);
-                error = set_blocksize(bdev, PAGE_SIZE);
+                p->old_block_size = block_size(p->bdev);
+                error = set_blocksize(p->bdev, PAGE_SIZE);
                 if (error < 0)
-                        goto bad_swap;
-                p->bdev = bdev;
+                        return error;
                 p->flags |= SWP_BLKDEV;
         } else if (S_ISREG(inode->i_mode)) {
                 p->bdev = inode->i_sb->s_bdev;
                 mutex_lock(&inode->i_mutex);
-                did_down = 1;
-                if (IS_SWAPFILE(inode)) {
-                        error = -EBUSY;
-                        goto bad_swap;
-                }
-        } else {
-                goto bad_swap;
-        }
+                if (IS_SWAPFILE(inode))
+                        return -EBUSY;
+        } else
+                return -EINVAL;
 
-        swapfilepages = i_size_read(inode) >> PAGE_SHIFT;
+        return 0;
+}
 
-        /*
-         * Read the swap header.
-         */
-        if (!mapping->a_ops->readpage) {
-                error = -EINVAL;
-                goto bad_swap;
-        }
-        page = read_mapping_page(mapping, 0, swap_file);
-        if (IS_ERR(page)) {
-                error = PTR_ERR(page);
-                goto bad_swap;
-        }
-        swap_header = kmap(page);
+static unsigned long read_swap_header(struct swap_info_struct *p,
+                                        union swap_header *swap_header,
+                                        struct inode *inode)
+{
+        int i;
+        unsigned long maxpages;
+        unsigned long swapfilepages;
 
         if (memcmp("SWAPSPACE2", swap_header->magic.magic, 10)) {
                 printk(KERN_ERR "Unable to find swap-space signature\n");
-                error = -EINVAL;
-                goto bad_swap;
+                return 0;
         }
 
         /* swap partition endianess hack... */
@@ -1954,8 +1928,7 @@ SYSCALL_DEFINE2(swapon, const char __user *, specialfile, int, swap_flags)
                 printk(KERN_WARNING
                        "Unable to handle swap header version %d\n",
                        swap_header->info.version);
-                error = -EINVAL;
-                goto bad_swap;
+                return 0;
         }
 
         p->lowest_bit  = 1;
@@ -1986,62 +1959,156 @@ SYSCALL_DEFINE2(swapon, const char __user *, specialfile, int, swap_flags)
         }
         p->highest_bit = maxpages - 1;
 
-        error = -EINVAL;
         if (!maxpages)
-                goto bad_swap;
+                return 0;
+        swapfilepages = i_size_read(inode) >> PAGE_SHIFT;
         if (swapfilepages && maxpages > swapfilepages) {
                 printk(KERN_WARNING
                        "Swap area shorter than signature indicates\n");
-                goto bad_swap;
+                return 0;
         }
         if (swap_header->info.nr_badpages && S_ISREG(inode->i_mode))
-                goto bad_swap;
+                return 0;
         if (swap_header->info.nr_badpages > MAX_SWAP_BADPAGES)
-                goto bad_swap;
+                return 0;
 
-        /* OK, set up the swap map and apply the bad block list */
-        swap_map = vmalloc(maxpages);
-        if (!swap_map) {
-                error = -ENOMEM;
-                goto bad_swap;
-        }
+        return maxpages;
+}
+
+static int setup_swap_map_and_extents(struct swap_info_struct *p,
+                                        union swap_header *swap_header,
+                                        unsigned char *swap_map,
+                                        unsigned long maxpages,
+                                        sector_t *span)
+{
+        int i;
+        unsigned int nr_good_pages;
+        int nr_extents;
 
-        memset(swap_map, 0, maxpages);
         nr_good_pages = maxpages - 1;   /* omit header page */
 
         for (i = 0; i < swap_header->info.nr_badpages; i++) {
                 unsigned int page_nr = swap_header->info.badpages[i];
-                if (page_nr == 0 || page_nr > swap_header->info.last_page) {
-                        error = -EINVAL;
-                        goto bad_swap;
-                }
+                if (page_nr == 0 || page_nr > swap_header->info.last_page)
+                        return -EINVAL;
                 if (page_nr < maxpages) {
                         swap_map[page_nr] = SWAP_MAP_BAD;
                         nr_good_pages--;
                 }
         }
 
-        error = swap_cgroup_swapon(type, maxpages);
-        if (error)
-                goto bad_swap;
-
         if (nr_good_pages) {
                 swap_map[0] = SWAP_MAP_BAD;
                 p->max = maxpages;
                 p->pages = nr_good_pages;
-                nr_extents = setup_swap_extents(p, &span);
-                if (nr_extents < 0) {
-                        error = nr_extents;
-                        goto bad_swap;
-                }
+                nr_extents = setup_swap_extents(p, span);
+                if (nr_extents < 0)
+                        return nr_extents;
                 nr_good_pages = p->pages;
         }
         if (!nr_good_pages) {
                 printk(KERN_WARNING "Empty swap-file\n");
+                return -EINVAL;
+        }
+
+        return nr_extents;
+}
+
+SYSCALL_DEFINE2(swapon, const char __user *, specialfile, int, swap_flags)
+{
+        struct swap_info_struct *p;
+        char *name;
+        struct file *swap_file = NULL;
+        struct address_space *mapping;
+        int i;
+        int prio;
+        int error;
+        union swap_header *swap_header;
+        int nr_extents;
+        sector_t span;
+        unsigned long maxpages;
+        unsigned char *swap_map = NULL;
+        struct page *page = NULL;
+        struct inode *inode = NULL;
+
+        if (!capable(CAP_SYS_ADMIN))
+                return -EPERM;
+
+        p = alloc_swap_info();
+        if (IS_ERR(p))
+                return PTR_ERR(p);
+
+        name = getname(specialfile);
+        if (IS_ERR(name)) {
+                error = PTR_ERR(name);
+                name = NULL;
+                goto bad_swap;
+        }
+        swap_file = filp_open(name, O_RDWR|O_LARGEFILE, 0);
+        if (IS_ERR(swap_file)) {
+                error = PTR_ERR(swap_file);
+                swap_file = NULL;
+                goto bad_swap;
+        }
+
+        p->swap_file = swap_file;
+        mapping = swap_file->f_mapping;
+
+        for (i = 0; i < nr_swapfiles; i++) {
+                struct swap_info_struct *q = swap_info[i];
+
+                if (q == p || !q->swap_file)
+                        continue;
+                if (mapping == q->swap_file->f_mapping) {
+                        error = -EBUSY;
+                        goto bad_swap;
+                }
+        }
+
+        inode = mapping->host;
+        /* If S_ISREG(inode->i_mode) will do mutex_lock(&inode->i_mutex); */
+        error = claim_swapfile(p, inode);
+        if (unlikely(error))
+                goto bad_swap;
+
+        /*
+         * Read the swap header.
+         */
+        if (!mapping->a_ops->readpage) {
+                error = -EINVAL;
+                goto bad_swap;
+        }
+        page = read_mapping_page(mapping, 0, swap_file);
+        if (IS_ERR(page)) {
+                error = PTR_ERR(page);
+                goto bad_swap;
+        }
+        swap_header = kmap(page);
+
+        maxpages = read_swap_header(p, swap_header, inode);
+        if (unlikely(!maxpages)) {
                 error = -EINVAL;
                 goto bad_swap;
         }
 
+        /* OK, set up the swap map and apply the bad block list */
+        swap_map = vzalloc(maxpages);
+        if (!swap_map) {
+                error = -ENOMEM;
+                goto bad_swap;
+        }
+
+        error = swap_cgroup_swapon(p->type, maxpages);
+        if (error)
+                goto bad_swap;
+
+        nr_extents = setup_swap_map_and_extents(p, swap_header, swap_map,
+                maxpages, &span);
+        if (unlikely(nr_extents < 0)) {
+                error = nr_extents;
+                goto bad_swap;
+        }
+
         if (p->bdev) {
                 if (blk_queue_nonrot(bdev_get_queue(p->bdev))) {
                         p->flags |= SWP_SOLIDSTATE;
@@ -2052,55 +2119,46 @@ SYSCALL_DEFINE2(swapon, const char __user *, specialfile, int, swap_flags)
         }
 
         mutex_lock(&swapon_mutex);
-        spin_lock(&swap_lock);
+        prio = -1;
         if (swap_flags & SWAP_FLAG_PREFER)
-                p->prio =
+                prio =
                   (swap_flags & SWAP_FLAG_PRIO_MASK) >> SWAP_FLAG_PRIO_SHIFT;
-        else
-                p->prio = --least_priority;
-        p->swap_map = swap_map;
-        p->flags |= SWP_WRITEOK;
-        nr_swap_pages += nr_good_pages;
-        total_swap_pages += nr_good_pages;
+        enable_swap_info(p, prio, swap_map);
 
         printk(KERN_INFO "Adding %uk swap on %s.  "
                         "Priority:%d extents:%d across:%lluk %s%s\n",
-                nr_good_pages<<(PAGE_SHIFT-10), name, p->prio,
+                p->pages<<(PAGE_SHIFT-10), name, p->prio,
                 nr_extents, (unsigned long long)span<<(PAGE_SHIFT-10),
                 (p->flags & SWP_SOLIDSTATE) ? "SS" : "",
                 (p->flags & SWP_DISCARDABLE) ? "D" : "");
 
-        /* insert swap space into swap_list: */
-        prev = -1;
-        for (i = swap_list.head; i >= 0; i = swap_info[i]->next) {
-                if (p->prio >= swap_info[i]->prio)
-                        break;
-                prev = i;
-        }
-        p->next = i;
-        if (prev < 0)
-                swap_list.head = swap_list.next = type;
-        else
-                swap_info[prev]->next = type;
-        spin_unlock(&swap_lock);
         mutex_unlock(&swapon_mutex);
+        atomic_inc(&proc_poll_event);
+        wake_up_interruptible(&proc_poll_wait);
+
+        if (S_ISREG(inode->i_mode))
+                inode->i_flags |= S_SWAPFILE;
         error = 0;
         goto out;
 bad_swap:
-        if (bdev) {
-                set_blocksize(bdev, p->old_block_size);
-                bd_release(bdev);
+        if (inode && S_ISBLK(inode->i_mode) && p->bdev) {
+                set_blocksize(p->bdev, p->old_block_size);
+                blkdev_put(p->bdev, FMODE_READ | FMODE_WRITE | FMODE_EXCL);
         }
         destroy_swap_extents(p);
-        swap_cgroup_swapoff(type);
-bad_swap_2:
+        swap_cgroup_swapoff(p->type);
         spin_lock(&swap_lock);
         p->swap_file = NULL;
         p->flags = 0;
         spin_unlock(&swap_lock);
         vfree(swap_map);
-        if (swap_file)
+        if (swap_file) {
+                if (inode && S_ISREG(inode->i_mode)) {
+                        mutex_unlock(&inode->i_mutex);
+                        inode = NULL;
+                }
                 filp_close(swap_file, NULL);
+        }
 out:
         if (page && !IS_ERR(page)) {
                 kunmap(page);
@@ -2108,11 +2166,8 @@ out:
         }
         if (name)
                 putname(name);
-        if (did_down) {
-                if (!error)
-                        inode->i_flags |= S_SWAPFILE;
+        if (inode && S_ISREG(inode->i_mode))
                 mutex_unlock(&inode->i_mutex);
-        }
         return error;
 }