From: Andrew Morton <akpm@osdl.org>

- Use SLAB_PANIC

- Nuke a spin_lock_init()

- Those enum names are asking for it.

- laptop_mode can be set to any value

Cc: Con Kolivas <kernel@kolivas.org>
Signed-off-by: Andrew Morton <akpm@osdl.org>
---

 mm/swap_prefetch.c |   52 ++++++++++++++++++++++++++--------------------------
 1 files changed, 26 insertions(+), 26 deletions(-)

diff -puN mm/swap_prefetch.c~mm-implement-swap-prefetching-tweaks mm/swap_prefetch.c
--- devel/mm/swap_prefetch.c~mm-implement-swap-prefetching-tweaks	2005-10-11 22:35:31.000000000 -0700
+++ devel-akpm/mm/swap_prefetch.c	2005-10-11 22:35:31.000000000 -0700
@@ -42,6 +42,7 @@ struct swapped_entry {
 
 static struct swapped_root swapped = {
 	.busy 		= 0,
+	.lock		= SPIN_LOCK_UNLOCKED,
 	.list  		= LIST_HEAD_INIT(swapped.list),
 	.swap_tree	= RADIX_TREE_INIT(GFP_ATOMIC),
 	.count 		= 0,
@@ -63,9 +64,7 @@ void __init prepare_prefetch(void)
 	long mem = nr_free_pagecache_pages();
 
 	swapped.cache = kmem_cache_create("swapped_entry",
-		sizeof(struct swapped_entry), 0, 0, NULL, NULL);
-	if (unlikely(!swapped.cache))
-		panic("prepare_prefetch(): cannot create swapped_entry SLAB cache");
+		sizeof(struct swapped_entry), 0, SLAB_PANIC, NULL, NULL);
 
 	/* Set max number of entries to size of physical ram */
 	swapped.maxcount = mem;
@@ -76,8 +75,6 @@ void __init prepare_prefetch(void)
 	mem /= SWAP_CLUSTER_MAX * 1000;
 	while ((mem >>= 1))
 		swap_prefetch++;
-
-	spin_lock_init(&swapped.lock);
 }
 
 static inline void delay_prefetch_timer(void)
@@ -209,7 +206,7 @@ static struct page *prefetch_get_page(vo
 		struct zonelist *zonelist;
 
 		zonelist = NODE_DATA(numa_node_id())->node_zonelists +
-		(GFP_HIGHUSER & GFP_ZONEMASK);
+			(GFP_HIGHUSER & GFP_ZONEMASK);
 
 		zone_statistics(zonelist, zone);
 	}
@@ -218,22 +215,22 @@ out:
 }
 
 enum trickle_return {
-	SUCCESS,
-	FAILED,
-	DELAY,
+	TRICKLE_SUCCESS,
+	TRICKLE_FAILED,
+	TRICKLE_DELAY,
 };
 
 /*
  * This tries to read a swp_entry_t into swap cache for swap prefetching.
- * If it returns DELAY we should delay further prefetching.
+ * If it returns TRICKLE_DELAY we should delay further prefetching.
  */
 static enum trickle_return trickle_swap_cache_async(swp_entry_t entry)
 {
-	enum trickle_return ret = FAILED;
+	enum trickle_return ret = TRICKLE_FAILED;
 	struct page *page = NULL;
 
 	if (unlikely(!read_trylock(&swapper_space.tree_lock))) {
-		ret = DELAY;
+		ret = TRICKLE_DELAY;
 		goto out;
 	}
 	/* Entry may already exist */
@@ -247,7 +244,7 @@ static enum trickle_return trickle_swap_
 	/* Get a new page to read from swap */
 	page = prefetch_get_page();
 	if (unlikely(!page)) {
-		ret = DELAY;
+		ret = TRICKLE_DELAY;
 		goto out;
 	}
 
@@ -257,11 +254,11 @@ static enum trickle_return trickle_swap_
 
 	lru_cache_add(page);
 	if (unlikely(swap_readpage(NULL, page))) {
-		ret = DELAY;
+		ret = TRICKLE_DELAY;
 		goto out_release;
 	}
 
-	ret = SUCCESS;
+	ret = TRICKLE_SUCCESS;
 out_release:
 	page_cache_release(page);
 out:
@@ -275,7 +272,7 @@ out:
  */
 static inline unsigned long prefetch_pages(void)
 {
-	return (SWAP_CLUSTER_MAX * swap_prefetch * (1 + 9 * laptop_mode));
+	return (SWAP_CLUSTER_MAX * swap_prefetch * (1 + 9 * !!laptop_mode));
 }
 
 /*
@@ -363,7 +360,7 @@ out:
  */
 static enum trickle_return trickle_swap(void)
 {
-	enum trickle_return ret = DELAY;
+	enum trickle_return ret = TRICKLE_DELAY;
 	struct swapped_entry *entry;
 	int pages = 0;
 
@@ -377,7 +374,7 @@ static enum trickle_return trickle_swap(
 			goto out;
 		if (list_empty(&swapped.list)) {
 			spin_unlock(&swapped.lock);
-			ret = FAILED;
+			ret = TRICKLE_FAILED;
 			goto out;
 		}
 		entry = list_entry(swapped.list.next,
@@ -386,16 +383,16 @@ static enum trickle_return trickle_swap(
 
 		got_page = trickle_swap_cache_async(entry->swp_entry);
 		switch (got_page) {
-		case FAILED:
+		case TRICKLE_FAILED:
 			break;
-		case SUCCESS:
+		case TRICKLE_SUCCESS:
 			pages++;
 			break;
-		case DELAY:
+		case TRICKLE_DELAY:
 			goto out;
 		}
 	}
-	ret = SUCCESS;
+	ret = TRICKLE_SUCCESS;
 
 out:
 	if (pages)
@@ -420,18 +417,21 @@ static int kprefetchd(void *data)
 		schedule();
 		finish_wait(&kprefetchd_wait, &wait);
 
-		/* FAILED implies no entries left - the timer is not reset */
+		/*
+		 * TRICKLE_FAILED implies no entries left - the timer is not
+		 * reset
+		 */
 		prefetched = trickle_swap();
 		switch (prefetched) {
-		case SUCCESS:
+		case TRICKLE_SUCCESS:
 			last_free = temp_free;
 			reset_prefetch_timer();
 			break;
-		case DELAY:
+		case TRICKLE_DELAY:
 			last_free = 0;
 			delay_prefetch_timer();
 			break;
-		case FAILED:
+		case TRICKLE_FAILED:
 			last_free = 0;
 			break;
 		}
_