v2.4.13.4 -> v2.4.13.5

  - Andrew Morton: remove stale UnlockPage
  - me: swap cache page locking update

diff --git a/include/linux/mm.h b/include/linux/mm.h
index 6cbd7ed4c464bc648b55eb95c99ec87615c7b4f6..f865aafd14459ca3c9311f4314fe32a9baf533b5 100644 (file)
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -466,20 +466,7 @@ static inline int is_page_cache_freeable(struct page * page)
        return page_count(page) - !!page->buffers == 1;
 }
 
-/*
- * Work out if there are any other processes sharing this
- * swap cache page. Never mind the buffers.
- */
-static inline int exclusive_swap_page(struct page *page)
-{
-       if (!PageLocked(page))
-               BUG();
-       if (!PageSwapCache(page))
-               return 0;
-       if (page_count(page) - !!page->buffers != 2)    /* 2: us + cache */
-               return 0;
-       return swap_count(page) == 1;                   /* 1: just cache */
-}
+extern int remove_exclusive_swap_page(struct page *);
 
 extern void __free_pte(pte_t);
 

diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h
index 1fda6fa35b24e0c6118f2624d66ad891f0378767..5da8ca6af63b968925ce255a4f3ed61ae0dad047 100644 (file)
--- a/include/linux/pagemap.h
+++ b/include/linux/pagemap.h
@@ -29,7 +29,7 @@
 #define PAGE_CACHE_ALIGN(addr) (((addr)+PAGE_CACHE_SIZE-1)&PAGE_CACHE_MASK)
 
 #define page_cache_get(x)      get_page(x)
-#define page_cache_release(x)  __free_page(x)
+#define page_cache_release(x)  free_lru_page(x)
 
 static inline struct page *page_cache_alloc(struct address_space *x)
 {

diff --git a/mm/memory.c b/mm/memory.c
index df6ffe94f5ffce0e56931acb27c772e587ead1ad..43316f25358325a4e38b32b37fedc00f3da914e0 100644 (file)
--- a/mm/memory.c
+++ b/mm/memory.c
@@ -939,9 +939,7 @@ static int do_wp_page(struct mm_struct *mm, struct vm_area_struct * vma,
                if (TryLockPage(old_page))
                        break;
                /* Recheck swapcachedness once the page is locked */
-               can_reuse = exclusive_swap_page(old_page);
-               if (can_reuse)
-                       delete_from_swap_cache(old_page);
+               can_reuse = remove_exclusive_swap_page(old_page);
                UnlockPage(old_page);
                if (!can_reuse)
                        break;
@@ -965,7 +963,7 @@ static int do_wp_page(struct mm_struct *mm, struct vm_area_struct * vma,
        if (!new_page)
                goto no_mem;
        copy_cow_page(old_page,new_page,address);
-       free_lru_page(old_page);
+       page_cache_release(old_page);
 
        /*
         * Re-check the pte - we dropped the lock
@@ -981,7 +979,7 @@ static int do_wp_page(struct mm_struct *mm, struct vm_area_struct * vma,
                new_page = old_page;
        }
        spin_unlock(&mm->page_table_lock);
-       free_lru_page(new_page);
+       page_cache_release(new_page);
        return 1;       /* Minor fault */
 
 bad_wp_page:
@@ -989,7 +987,7 @@ bad_wp_page:
        printk("do_wp_page: bogus page at address %08lx (page 0x%lx)\n",address,(unsigned long)old_page);
        return -1;
 no_mem:
-       free_lru_page(old_page);
+       page_cache_release(old_page);
        return -1;
 }
 
@@ -1150,7 +1148,6 @@ static int do_swap_page(struct mm_struct * mm,
         */
        spin_lock(&mm->page_table_lock);
        if (!pte_same(*page_table, orig_pte)) {
-               UnlockPage(page);
                page_cache_release(page);
                spin_unlock(&mm->page_table_lock);
                return 1;
@@ -1283,7 +1280,7 @@ static int do_no_page(struct mm_struct * mm, struct vm_area_struct * vma,
                set_pte(page_table, entry);
        } else {
                /* One of our sibling threads was faster, back out. */
-               free_lru_page(new_page);
+               page_cache_release(new_page);
                spin_unlock(&mm->page_table_lock);
                return 1;
        }

diff --git a/mm/swap_state.c b/mm/swap_state.c
index 30d0c085cd6d538a0756ae12039feb687b6ba3be..4f7b9d6a17e2c2ee0a12457e00feb211fd872de1 100644 (file)
--- a/mm/swap_state.c
+++ b/mm/swap_state.c
@@ -137,11 +137,10 @@ void free_page_and_swap_cache(struct page *page)
         *                                      - Marcelo
         */
        if (PageSwapCache(page) && !TryLockPage(page)) {
-               if (exclusive_swap_page(page))
-                       delete_from_swap_cache(page);
+               remove_exclusive_swap_page(page);
                UnlockPage(page);
        }
-       free_lru_page(page);
+       page_cache_release(page);
 }
 
 /*

diff --git a/mm/swapfile.c b/mm/swapfile.c
index e1f34979e747900f9a709ead9a5f05c60042a3c2..002f9849a122d72f6080043110317e1f78572347 100644 (file)
--- a/mm/swapfile.c
+++ b/mm/swapfile.c
@@ -223,6 +223,50 @@ void swap_free(swp_entry_t entry)
        }
 }
 
+/*
+ * Work out if there are any other processes sharing this
+ * swap cache page. Free it if you can. Return success.
+ */
+int remove_exclusive_swap_page(struct page *page)
+{
+       int retval;
+       struct swap_info_struct * p;
+       swp_entry_t entry;
+
+       if (!PageLocked(page))
+               BUG();
+       if (!PageSwapCache(page))
+               return 0;
+       if (page_count(page) - !!page->buffers != 2)    /* 2: us + cache */
+               return 0;
+
+       entry.val = page->index;
+       p = swap_info_get(entry);
+       if (!p)
+               return 0;
+
+       /* Is the only swap cache user the cache itself? */
+       retval = 0;
+       if (p->swap_map[SWP_OFFSET(entry)] == 1) {
+               /* Recheck the page count with the pagecache lock held.. */
+               spin_lock(&pagecache_lock);
+               if (page_count(page) - !!page->buffers == 2) {
+                       __delete_from_swap_cache(page);
+                       retval = 1;
+               }
+               spin_unlock(&pagecache_lock);
+       }
+       swap_info_put(p);
+
+       if (retval) {
+               block_flushpage(page, 0);
+               swap_free(entry);
+               page_cache_release(page);
+       }
+
+       return retval;
+}
+
 /*
  * Free the swap entry like above, but also try to
  * free the page cache entry if it is the last user.
@@ -242,7 +286,7 @@ void free_swap_and_cache(swp_entry_t entry)
                page_cache_get(page);
                delete_from_swap_cache(page);
                UnlockPage(page);
-               free_lru_page(page);
+               page_cache_release(page);
        }
 }
 
@@ -582,7 +626,7 @@ static int try_to_unuse(unsigned int type)
                 */
                SetPageDirty(page);
                UnlockPage(page);
-               free_lru_page(page);
+               page_cache_release(page);
 
                /*
                 * Make sure that we aren't completely killing