File: /usr/src/linux/mm/page_io.c
1 /*
2 * linux/mm/page_io.c
3 *
4 * Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds
5 *
6 * Swap reorganised 29.12.95,
7 * Asynchronous swapping added 30.12.95. Stephen Tweedie
8 * Removed race in async swapping. 14.4.1996. Bruno Haible
9 * Add swap of shared pages through the page cache. 20.2.1998. Stephen Tweedie
10 * Always use brw_page, life becomes simpler. 12 May 1998 Eric Biederman
11 */
12
13 #include <linux/mm.h>
14 #include <linux/kernel_stat.h>
15 #include <linux/swap.h>
16 #include <linux/locks.h>
17 #include <linux/swapctl.h>
18
19 #include <asm/pgtable.h>
20
21 /*
22 * Reads or writes a swap page.
23 * wait=1: start I/O and wait for completion. wait=0: start asynchronous I/O.
24 *
25 * Important prevention of race condition: the caller *must* atomically
26 * create a unique swap cache entry for this swap page before calling
27 * rw_swap_page, and must lock that page. By ensuring that there is a
28 * single page of memory reserved for the swap entry, the normal VM page
29 * lock on that page also doubles as a lock on swap entries. Having only
30 * one lock to deal with per swap entry (rather than locking swap and memory
31 * independently) also makes it easier to make certain swapping operations
32 * atomic, which is particularly important when we are trying to ensure
33 * that shared pages stay shared while being swapped.
34 */
35
36 static int rw_swap_page_base(int rw, swp_entry_t entry, struct page *page)
37 {
38 unsigned long offset;
39 int zones[PAGE_SIZE/512];
40 int zones_used;
41 kdev_t dev = 0;
42 int block_size;
43 struct inode *swapf = 0;
44 int wait = 0;
45
46 /* Don't allow too many pending pages in flight.. */
47 if ((rw == WRITE) && atomic_read(&nr_async_pages) >
48 pager_daemon.swap_cluster * (1 << page_cluster))
49 wait = 1;
50
51 if (rw == READ) {
52 ClearPageUptodate(page);
53 kstat.pswpin++;
54 } else
55 kstat.pswpout++;
56
57 get_swaphandle_info(entry, &offset, &dev, &swapf);
58 if (dev) {
59 zones[0] = offset;
60 zones_used = 1;
61 block_size = PAGE_SIZE;
62 } else if (swapf) {
63 int i, j;
64 unsigned int block = offset
65 << (PAGE_SHIFT - swapf->i_sb->s_blocksize_bits);
66
67 block_size = swapf->i_sb->s_blocksize;
68 for (i=0, j=0; j< PAGE_SIZE ; i++, j += block_size)
69 if (!(zones[i] = bmap(swapf,block++))) {
70 printk("rw_swap_page: bad swap file\n");
71 return 0;
72 }
73 zones_used = i;
74 dev = swapf->i_dev;
75 } else {
76 return 0;
77 }
78 if (!wait) {
79 SetPageDecrAfter(page);
80 atomic_inc(&nr_async_pages);
81 }
82
83 /* block_size == PAGE_SIZE/zones_used */
84 brw_page(rw, page, dev, zones, block_size);
85
86 /* Note! For consistency we do all of the logic,
87 * decrementing the page count, and unlocking the page in the
88 * swap lock map - in the IO completion handler.
89 */
90 if (!wait)
91 return 1;
92
93 wait_on_page(page);
94 /* This shouldn't happen, but check to be sure. */
95 if (page_count(page) == 0)
96 printk(KERN_ERR "rw_swap_page: page unused while waiting!\n");
97
98 return 1;
99 }
100
101 /*
102 * A simple wrapper so the base function doesn't need to enforce
103 * that all swap pages go through the swap cache! We verify that:
104 * - the page is locked
105 * - it's marked as being swap-cache
106 * - it's associated with the swap inode
107 */
108 void rw_swap_page(int rw, struct page *page)
109 {
110 swp_entry_t entry;
111
112 entry.val = page->index;
113
114 if (!PageLocked(page))
115 PAGE_BUG(page);
116 if (!PageSwapCache(page))
117 PAGE_BUG(page);
118 if (page->mapping != &swapper_space)
119 PAGE_BUG(page);
120 if (!rw_swap_page_base(rw, entry, page))
121 UnlockPage(page);
122 }
123
124 /*
125 * The swap lock map insists that pages be in the page cache!
126 * Therefore we can't use it. Later when we can remove the need for the
127 * lock map and we can reduce the number of functions exported.
128 */
129 void rw_swap_page_nolock(int rw, swp_entry_t entry, char *buf)
130 {
131 struct page *page = virt_to_page(buf);
132
133 if (!PageLocked(page))
134 PAGE_BUG(page);
135 if (PageSwapCache(page))
136 PAGE_BUG(page);
137 if (page->mapping)
138 PAGE_BUG(page);
139 /* needs sync_page to wait I/O completation */
140 page->mapping = &swapper_space;
141 if (!rw_swap_page_base(rw, entry, page))
142 UnlockPage(page);
143 wait_on_page(page);
144 page->mapping = NULL;
145 }
146