swapfile: remove v0 SWAP-SPACE message

The kernel has not supported v0 SWAP-SPACE since 2.5.22: I think we can
now safely drop its "version 0 swap is no longer supported" message - just
say "Unable to find swap-space signature" as usual.  This removes one
level of indentation from a stretch of sys_swapon().

I'd have liked to be specific, saying "Unable to find SWAPSPACE2
signature", but it's just too confusing that the version 1 signature shows
the number 2.

Irrelevant nearby cleanup: kmap(page) already gives page_address(page).

Signed-off-by: Hugh Dickins <hugh@veritas.com>
Cc: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
Cc: Nick Piggin <nickpiggin@yahoo.com.au>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

diff --git a/mm/swapfile.c b/mm/swapfile.c
index c46c83d6aab028a24d69fa9bb7d9e2d8652b45b8..85ff603385c3122d30db3b5d3de0c78f38cc284b 100644 (file)
--- a/mm/swapfile.c
+++ b/mm/swapfile.c
@@ -1456,7 +1456,6 @@ asmlinkage long sys_swapon(const char __user * specialfile, int swap_flags)
        int i, prev;
        int error;
        union swap_header *swap_header = NULL;
-       int swap_header_version;
        unsigned int nr_good_pages = 0;
        int nr_extents = 0;
        sector_t span;
@@ -1553,101 +1552,86 @@ asmlinkage long sys_swapon(const char __user * specialfile, int swap_flags)
                error = PTR_ERR(page);
                goto bad_swap;
        }
-       kmap(page);
-       swap_header = page_address(page);
+       swap_header = kmap(page);
 
-       if (!memcmp("SWAP-SPACE",swap_header->magic.magic,10))
-               swap_header_version = 1;
-       else if (!memcmp("SWAPSPACE2",swap_header->magic.magic,10))
-               swap_header_version = 2;
-       else {
+       if (memcmp("SWAPSPACE2", swap_header->magic.magic, 10)) {
                printk(KERN_ERR "Unable to find swap-space signature\n");
                error = -EINVAL;
                goto bad_swap;
        }
 
-       switch (swap_header_version) {
-       case 1:
-               printk(KERN_ERR "version 0 swap is no longer supported. "
-                       "Use mkswap -v1 %s\n", name);
+       /* swap partition endianess hack... */
+       if (swab32(swap_header->info.version) == 1) {
+               swab32s(&swap_header->info.version);
+               swab32s(&swap_header->info.last_page);
+               swab32s(&swap_header->info.nr_badpages);
+               for (i = 0; i < swap_header->info.nr_badpages; i++)
+                       swab32s(&swap_header->info.badpages[i]);
+       }
+       /* Check the swap header's sub-version */
+       if (swap_header->info.version != 1) {
+               printk(KERN_WARNING
+                      "Unable to handle swap header version %d\n",
+                      swap_header->info.version);
                error = -EINVAL;
                goto bad_swap;
-       case 2:
-               /* swap partition endianess hack... */
-               if (swab32(swap_header->info.version) == 1) {
-                       swab32s(&swap_header->info.version);
-                       swab32s(&swap_header->info.last_page);
-                       swab32s(&swap_header->info.nr_badpages);
-                       for (i = 0; i < swap_header->info.nr_badpages; i++)
-                               swab32s(&swap_header->info.badpages[i]);
-               }
-               /* Check the swap header's sub-version and the size of
-                   the swap file and bad block lists */
-               if (swap_header->info.version != 1) {
-                       printk(KERN_WARNING
-                              "Unable to handle swap header version %d\n",
-                              swap_header->info.version);
-                       error = -EINVAL;
-                       goto bad_swap;
-               }
+       }
 
-               p->lowest_bit  = 1;
-               p->cluster_next = 1;
+       p->lowest_bit  = 1;
+       p->cluster_next = 1;
 
-               /*
-                * Find out how many pages are allowed for a single swap
-                * device. There are two limiting factors: 1) the number of
-                * bits for the swap offset in the swp_entry_t type and
-                * 2) the number of bits in the a swap pte as defined by
-                * the different architectures. In order to find the
-                * largest possible bit mask a swap entry with swap type 0
-                * and swap offset ~0UL is created, encoded to a swap pte,
-                * decoded to a swp_entry_t again and finally the swap
-                * offset is extracted. This will mask all the bits from
-                * the initial ~0UL mask that can't be encoded in either
-                * the swp_entry_t or the architecture definition of a
-                * swap pte.
-                */
-               maxpages = swp_offset(pte_to_swp_entry(swp_entry_to_pte(swp_entry(0,~0UL)))) - 1;
-               if (maxpages > swap_header->info.last_page)
-                       maxpages = swap_header->info.last_page;
-               p->highest_bit = maxpages - 1;
+       /*
+        * Find out how many pages are allowed for a single swap
+        * device. There are two limiting factors: 1) the number of
+        * bits for the swap offset in the swp_entry_t type and
+        * 2) the number of bits in the a swap pte as defined by
+        * the different architectures. In order to find the
+        * largest possible bit mask a swap entry with swap type 0
+        * and swap offset ~0UL is created, encoded to a swap pte,
+        * decoded to a swp_entry_t again and finally the swap
+        * offset is extracted. This will mask all the bits from
+        * the initial ~0UL mask that can't be encoded in either
+        * the swp_entry_t or the architecture definition of a
+        * swap pte.
+        */
+       maxpages = swp_offset(pte_to_swp_entry(
+                       swp_entry_to_pte(swp_entry(0, ~0UL)))) - 1;
+       if (maxpages > swap_header->info.last_page)
+               maxpages = swap_header->info.last_page;
+       p->highest_bit = maxpages - 1;
 
-               error = -EINVAL;
-               if (!maxpages)
-                       goto bad_swap;
-               if (swapfilepages && maxpages > swapfilepages) {
-                       printk(KERN_WARNING
-                              "Swap area shorter than signature indicates\n");
-                       goto bad_swap;
-               }
-               if (swap_header->info.nr_badpages && S_ISREG(inode->i_mode))
-                       goto bad_swap;
-               if (swap_header->info.nr_badpages > MAX_SWAP_BADPAGES)
-                       goto bad_swap;
+       error = -EINVAL;
+       if (!maxpages)
+               goto bad_swap;
+       if (swapfilepages && maxpages > swapfilepages) {
+               printk(KERN_WARNING
+                      "Swap area shorter than signature indicates\n");
+               goto bad_swap;
+       }
+       if (swap_header->info.nr_badpages && S_ISREG(inode->i_mode))
+               goto bad_swap;
+       if (swap_header->info.nr_badpages > MAX_SWAP_BADPAGES)
+               goto bad_swap;
 
-               /* OK, set up the swap map and apply the bad block list */
-               swap_map = vmalloc(maxpages * sizeof(short));
-               if (!swap_map) {
-                       error = -ENOMEM;
-                       goto bad_swap;
-               }
+       /* OK, set up the swap map and apply the bad block list */
+       swap_map = vmalloc(maxpages * sizeof(short));
+       if (!swap_map) {
+               error = -ENOMEM;
+               goto bad_swap;
+       }
 
-               error = 0;
-               memset(swap_map, 0, maxpages * sizeof(short));
-               for (i = 0; i < swap_header->info.nr_badpages; i++) {
-                       int page_nr = swap_header->info.badpages[i];
-                       if (page_nr <= 0 || page_nr >= swap_header->info.last_page)
-                               error = -EINVAL;
-                       else
-                               swap_map[page_nr] = SWAP_MAP_BAD;
-               }
-               nr_good_pages = swap_header->info.last_page -
-                               swap_header->info.nr_badpages -
-                               1 /* header page */;
-               if (error)
+       memset(swap_map, 0, maxpages * sizeof(short));
+       for (i = 0; i < swap_header->info.nr_badpages; i++) {
+               int page_nr = swap_header->info.badpages[i];
+               if (page_nr <= 0 || page_nr >= swap_header->info.last_page) {
+                       error = -EINVAL;
                        goto bad_swap;
+               }
+               swap_map[page_nr] = SWAP_MAP_BAD;
        }
+       nr_good_pages = swap_header->info.last_page -
+                       swap_header->info.nr_badpages -
+                       1 /* header page */;
 
        if (nr_good_pages) {
                swap_map[0] = SWAP_MAP_BAD;