Fix potential endless loop in kswapd when compaction is not enabled
[~shefty/rdma-dev.git] / drivers / xen / tmem.c
1 /*
2  * Xen implementation for transcendent memory (tmem)
3  *
4  * Copyright (C) 2009-2011 Oracle Corp.  All rights reserved.
5  * Author: Dan Magenheimer
6  */
7
8 #include <linux/kernel.h>
9 #include <linux/types.h>
10 #include <linux/init.h>
11 #include <linux/pagemap.h>
12 #include <linux/module.h>
13 #include <linux/cleancache.h>
14
15 /* temporary ifdef until include/linux/frontswap.h is upstream */
16 #ifdef CONFIG_FRONTSWAP
17 #include <linux/frontswap.h>
18 #endif
19
20 #include <xen/xen.h>
21 #include <xen/interface/xen.h>
22 #include <asm/xen/hypercall.h>
23 #include <asm/xen/page.h>
24 #include <asm/xen/hypervisor.h>
25
26 #define TMEM_CONTROL               0
27 #define TMEM_NEW_POOL              1
28 #define TMEM_DESTROY_POOL          2
29 #define TMEM_NEW_PAGE              3
30 #define TMEM_PUT_PAGE              4
31 #define TMEM_GET_PAGE              5
32 #define TMEM_FLUSH_PAGE            6
33 #define TMEM_FLUSH_OBJECT          7
34 #define TMEM_READ                  8
35 #define TMEM_WRITE                 9
36 #define TMEM_XCHG                 10
37
38 /* Bits for HYPERVISOR_tmem_op(TMEM_NEW_POOL) */
39 #define TMEM_POOL_PERSIST          1
40 #define TMEM_POOL_SHARED           2
41 #define TMEM_POOL_PAGESIZE_SHIFT   4
42 #define TMEM_VERSION_SHIFT        24
43
44
45 struct tmem_pool_uuid {
46         u64 uuid_lo;
47         u64 uuid_hi;
48 };
49
50 struct tmem_oid {
51         u64 oid[3];
52 };
53
54 #define TMEM_POOL_PRIVATE_UUID  { 0, 0 }
55
56 /* flags for tmem_ops.new_pool */
57 #define TMEM_POOL_PERSIST          1
58 #define TMEM_POOL_SHARED           2
59
60 /* xen tmem foundation ops/hypercalls */
61
62 static inline int xen_tmem_op(u32 tmem_cmd, u32 tmem_pool, struct tmem_oid oid,
63         u32 index, unsigned long gmfn, u32 tmem_offset, u32 pfn_offset, u32 len)
64 {
65         struct tmem_op op;
66         int rc = 0;
67
68         op.cmd = tmem_cmd;
69         op.pool_id = tmem_pool;
70         op.u.gen.oid[0] = oid.oid[0];
71         op.u.gen.oid[1] = oid.oid[1];
72         op.u.gen.oid[2] = oid.oid[2];
73         op.u.gen.index = index;
74         op.u.gen.tmem_offset = tmem_offset;
75         op.u.gen.pfn_offset = pfn_offset;
76         op.u.gen.len = len;
77         set_xen_guest_handle(op.u.gen.gmfn, (void *)gmfn);
78         rc = HYPERVISOR_tmem_op(&op);
79         return rc;
80 }
81
82 static int xen_tmem_new_pool(struct tmem_pool_uuid uuid,
83                                 u32 flags, unsigned long pagesize)
84 {
85         struct tmem_op op;
86         int rc = 0, pageshift;
87
88         for (pageshift = 0; pagesize != 1; pageshift++)
89                 pagesize >>= 1;
90         flags |= (pageshift - 12) << TMEM_POOL_PAGESIZE_SHIFT;
91         flags |= TMEM_SPEC_VERSION << TMEM_VERSION_SHIFT;
92         op.cmd = TMEM_NEW_POOL;
93         op.u.new.uuid[0] = uuid.uuid_lo;
94         op.u.new.uuid[1] = uuid.uuid_hi;
95         op.u.new.flags = flags;
96         rc = HYPERVISOR_tmem_op(&op);
97         return rc;
98 }
99
100 /* xen generic tmem ops */
101
102 static int xen_tmem_put_page(u32 pool_id, struct tmem_oid oid,
103                              u32 index, unsigned long pfn)
104 {
105         unsigned long gmfn = xen_pv_domain() ? pfn_to_mfn(pfn) : pfn;
106
107         return xen_tmem_op(TMEM_PUT_PAGE, pool_id, oid, index,
108                 gmfn, 0, 0, 0);
109 }
110
111 static int xen_tmem_get_page(u32 pool_id, struct tmem_oid oid,
112                              u32 index, unsigned long pfn)
113 {
114         unsigned long gmfn = xen_pv_domain() ? pfn_to_mfn(pfn) : pfn;
115
116         return xen_tmem_op(TMEM_GET_PAGE, pool_id, oid, index,
117                 gmfn, 0, 0, 0);
118 }
119
120 static int xen_tmem_flush_page(u32 pool_id, struct tmem_oid oid, u32 index)
121 {
122         return xen_tmem_op(TMEM_FLUSH_PAGE, pool_id, oid, index,
123                 0, 0, 0, 0);
124 }
125
126 static int xen_tmem_flush_object(u32 pool_id, struct tmem_oid oid)
127 {
128         return xen_tmem_op(TMEM_FLUSH_OBJECT, pool_id, oid, 0, 0, 0, 0, 0);
129 }
130
131 int tmem_enabled __read_mostly;
132 EXPORT_SYMBOL(tmem_enabled);
133
134 static int __init enable_tmem(char *s)
135 {
136         tmem_enabled = 1;
137         return 1;
138 }
139
140 __setup("tmem", enable_tmem);
141
142 #ifdef CONFIG_CLEANCACHE
143 static int xen_tmem_destroy_pool(u32 pool_id)
144 {
145         struct tmem_oid oid = { { 0 } };
146
147         return xen_tmem_op(TMEM_DESTROY_POOL, pool_id, oid, 0, 0, 0, 0, 0);
148 }
149
150 /* cleancache ops */
151
152 static void tmem_cleancache_put_page(int pool, struct cleancache_filekey key,
153                                      pgoff_t index, struct page *page)
154 {
155         u32 ind = (u32) index;
156         struct tmem_oid oid = *(struct tmem_oid *)&key;
157         unsigned long pfn = page_to_pfn(page);
158
159         if (pool < 0)
160                 return;
161         if (ind != index)
162                 return;
163         mb(); /* ensure page is quiescent; tmem may address it with an alias */
164         (void)xen_tmem_put_page((u32)pool, oid, ind, pfn);
165 }
166
167 static int tmem_cleancache_get_page(int pool, struct cleancache_filekey key,
168                                     pgoff_t index, struct page *page)
169 {
170         u32 ind = (u32) index;
171         struct tmem_oid oid = *(struct tmem_oid *)&key;
172         unsigned long pfn = page_to_pfn(page);
173         int ret;
174
175         /* translate return values to linux semantics */
176         if (pool < 0)
177                 return -1;
178         if (ind != index)
179                 return -1;
180         ret = xen_tmem_get_page((u32)pool, oid, ind, pfn);
181         if (ret == 1)
182                 return 0;
183         else
184                 return -1;
185 }
186
187 static void tmem_cleancache_flush_page(int pool, struct cleancache_filekey key,
188                                        pgoff_t index)
189 {
190         u32 ind = (u32) index;
191         struct tmem_oid oid = *(struct tmem_oid *)&key;
192
193         if (pool < 0)
194                 return;
195         if (ind != index)
196                 return;
197         (void)xen_tmem_flush_page((u32)pool, oid, ind);
198 }
199
200 static void tmem_cleancache_flush_inode(int pool, struct cleancache_filekey key)
201 {
202         struct tmem_oid oid = *(struct tmem_oid *)&key;
203
204         if (pool < 0)
205                 return;
206         (void)xen_tmem_flush_object((u32)pool, oid);
207 }
208
209 static void tmem_cleancache_flush_fs(int pool)
210 {
211         if (pool < 0)
212                 return;
213         (void)xen_tmem_destroy_pool((u32)pool);
214 }
215
216 static int tmem_cleancache_init_fs(size_t pagesize)
217 {
218         struct tmem_pool_uuid uuid_private = TMEM_POOL_PRIVATE_UUID;
219
220         return xen_tmem_new_pool(uuid_private, 0, pagesize);
221 }
222
223 static int tmem_cleancache_init_shared_fs(char *uuid, size_t pagesize)
224 {
225         struct tmem_pool_uuid shared_uuid;
226
227         shared_uuid.uuid_lo = *(u64 *)uuid;
228         shared_uuid.uuid_hi = *(u64 *)(&uuid[8]);
229         return xen_tmem_new_pool(shared_uuid, TMEM_POOL_SHARED, pagesize);
230 }
231
232 static int use_cleancache = 1;
233
234 static int __init no_cleancache(char *s)
235 {
236         use_cleancache = 0;
237         return 1;
238 }
239
240 __setup("nocleancache", no_cleancache);
241
242 static struct cleancache_ops tmem_cleancache_ops = {
243         .put_page = tmem_cleancache_put_page,
244         .get_page = tmem_cleancache_get_page,
245         .invalidate_page = tmem_cleancache_flush_page,
246         .invalidate_inode = tmem_cleancache_flush_inode,
247         .invalidate_fs = tmem_cleancache_flush_fs,
248         .init_shared_fs = tmem_cleancache_init_shared_fs,
249         .init_fs = tmem_cleancache_init_fs
250 };
251 #endif
252
253 #ifdef CONFIG_FRONTSWAP
254 /* frontswap tmem operations */
255
256 /* a single tmem poolid is used for all frontswap "types" (swapfiles) */
257 static int tmem_frontswap_poolid;
258
259 /*
260  * Swizzling increases objects per swaptype, increasing tmem concurrency
261  * for heavy swaploads.  Later, larger nr_cpus -> larger SWIZ_BITS
262  */
263 #define SWIZ_BITS               4
264 #define SWIZ_MASK               ((1 << SWIZ_BITS) - 1)
265 #define _oswiz(_type, _ind)     ((_type << SWIZ_BITS) | (_ind & SWIZ_MASK))
266 #define iswiz(_ind)             (_ind >> SWIZ_BITS)
267
268 static inline struct tmem_oid oswiz(unsigned type, u32 ind)
269 {
270         struct tmem_oid oid = { .oid = { 0 } };
271         oid.oid[0] = _oswiz(type, ind);
272         return oid;
273 }
274
275 /* returns 0 if the page was successfully put into frontswap, -1 if not */
276 static int tmem_frontswap_put_page(unsigned type, pgoff_t offset,
277                                    struct page *page)
278 {
279         u64 ind64 = (u64)offset;
280         u32 ind = (u32)offset;
281         unsigned long pfn = page_to_pfn(page);
282         int pool = tmem_frontswap_poolid;
283         int ret;
284
285         if (pool < 0)
286                 return -1;
287         if (ind64 != ind)
288                 return -1;
289         mb(); /* ensure page is quiescent; tmem may address it with an alias */
290         ret = xen_tmem_put_page(pool, oswiz(type, ind), iswiz(ind), pfn);
291         /* translate Xen tmem return values to linux semantics */
292         if (ret == 1)
293                 return 0;
294         else
295                 return -1;
296 }
297
298 /*
299  * returns 0 if the page was successfully gotten from frontswap, -1 if
300  * was not present (should never happen!)
301  */
302 static int tmem_frontswap_get_page(unsigned type, pgoff_t offset,
303                                    struct page *page)
304 {
305         u64 ind64 = (u64)offset;
306         u32 ind = (u32)offset;
307         unsigned long pfn = page_to_pfn(page);
308         int pool = tmem_frontswap_poolid;
309         int ret;
310
311         if (pool < 0)
312                 return -1;
313         if (ind64 != ind)
314                 return -1;
315         ret = xen_tmem_get_page(pool, oswiz(type, ind), iswiz(ind), pfn);
316         /* translate Xen tmem return values to linux semantics */
317         if (ret == 1)
318                 return 0;
319         else
320                 return -1;
321 }
322
323 /* flush a single page from frontswap */
324 static void tmem_frontswap_flush_page(unsigned type, pgoff_t offset)
325 {
326         u64 ind64 = (u64)offset;
327         u32 ind = (u32)offset;
328         int pool = tmem_frontswap_poolid;
329
330         if (pool < 0)
331                 return;
332         if (ind64 != ind)
333                 return;
334         (void) xen_tmem_flush_page(pool, oswiz(type, ind), iswiz(ind));
335 }
336
337 /* flush all pages from the passed swaptype */
338 static void tmem_frontswap_flush_area(unsigned type)
339 {
340         int pool = tmem_frontswap_poolid;
341         int ind;
342
343         if (pool < 0)
344                 return;
345         for (ind = SWIZ_MASK; ind >= 0; ind--)
346                 (void)xen_tmem_flush_object(pool, oswiz(type, ind));
347 }
348
349 static void tmem_frontswap_init(unsigned ignored)
350 {
351         struct tmem_pool_uuid private = TMEM_POOL_PRIVATE_UUID;
352
353         /* a single tmem poolid is used for all frontswap "types" (swapfiles) */
354         if (tmem_frontswap_poolid < 0)
355                 tmem_frontswap_poolid =
356                     xen_tmem_new_pool(private, TMEM_POOL_PERSIST, PAGE_SIZE);
357 }
358
359 static int __initdata use_frontswap = 1;
360
361 static int __init no_frontswap(char *s)
362 {
363         use_frontswap = 0;
364         return 1;
365 }
366
367 __setup("nofrontswap", no_frontswap);
368
369 static struct frontswap_ops tmem_frontswap_ops = {
370         .put_page = tmem_frontswap_put_page,
371         .get_page = tmem_frontswap_get_page,
372         .invalidate_page = tmem_frontswap_flush_page,
373         .invalidate_area = tmem_frontswap_flush_area,
374         .init = tmem_frontswap_init
375 };
376 #endif
377
378 static int __init xen_tmem_init(void)
379 {
380         if (!xen_domain())
381                 return 0;
382 #ifdef CONFIG_FRONTSWAP
383         if (tmem_enabled && use_frontswap) {
384                 char *s = "";
385                 struct frontswap_ops old_ops =
386                         frontswap_register_ops(&tmem_frontswap_ops);
387
388                 tmem_frontswap_poolid = -1;
389                 if (old_ops.init != NULL)
390                         s = " (WARNING: frontswap_ops overridden)";
391                 printk(KERN_INFO "frontswap enabled, RAM provided by "
392                                  "Xen Transcendent Memory\n");
393         }
394 #endif
395 #ifdef CONFIG_CLEANCACHE
396         BUG_ON(sizeof(struct cleancache_filekey) != sizeof(struct tmem_oid));
397         if (tmem_enabled && use_cleancache) {
398                 char *s = "";
399                 struct cleancache_ops old_ops =
400                         cleancache_register_ops(&tmem_cleancache_ops);
401                 if (old_ops.init_fs != NULL)
402                         s = " (WARNING: cleancache_ops overridden)";
403                 printk(KERN_INFO "cleancache enabled, RAM provided by "
404                                  "Xen Transcendent Memory%s\n", s);
405         }
406 #endif
407         return 0;
408 }
409
410 module_init(xen_tmem_init)