ia64/linux-2.6.18-xen.hg

view drivers/block/z2ram.c @ 897:329ea0ccb344

balloon: try harder to balloon up under memory pressure.

Currently if the balloon driver is unable to increase the guest's
reservation it assumes the failure was due to reaching its full
allocation, gives up on the ballooning operation and records the limit
it reached as the "hard limit". The driver will not try again until
the target is set again (even to the same value).

However it is possible that ballooning has in fact failed due to
memory pressure in the host and therefore it is desirable to keep
attempting to reach the target in case memory becomes available. The
most likely scenario is that some guests are ballooning down while
others are ballooning up and therefore there is temporary memory
pressure while things stabilise. You would not expect a well behaved
toolstack to ask a domain to balloon to more than its allocation nor
would you expect it to deliberately over-commit memory by setting
balloon targets which exceed the total host memory.

This patch drops the concept of a hard limit and causes the balloon
driver to retry increasing the reservation on a timer in the same
manner as when decreasing the reservation.

Also if we partially succeed in increasing the reservation
(i.e. receive less pages than we asked for) then we may as well keep
those pages rather than returning them to Xen.

Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Fri Jun 05 14:01:20 2009 +0100 (2009-06-05)
parents 831230e53067
children
line source
1 /*
2 ** z2ram - Amiga pseudo-driver to access 16bit-RAM in ZorroII space
3 ** as a block device, to be used as a RAM disk or swap space
4 **
5 ** Copyright (C) 1994 by Ingo Wilken (Ingo.Wilken@informatik.uni-oldenburg.de)
6 **
7 ** ++Geert: support for zorro_unused_z2ram, better range checking
8 ** ++roman: translate accesses via an array
9 ** ++Milan: support for ChipRAM usage
10 ** ++yambo: converted to 2.0 kernel
11 ** ++yambo: modularized and support added for 3 minor devices including:
12 ** MAJOR MINOR DESCRIPTION
13 ** ----- ----- ----------------------------------------------
14 ** 37 0 Use Zorro II and Chip ram
15 ** 37 1 Use only Zorro II ram
16 ** 37 2 Use only Chip ram
17 ** 37 4-7 Use memory list entry 1-4 (first is 0)
18 ** ++jskov: support for 1-4th memory list entry.
19 **
20 ** Permission to use, copy, modify, and distribute this software and its
21 ** documentation for any purpose and without fee is hereby granted, provided
22 ** that the above copyright notice appear in all copies and that both that
23 ** copyright notice and this permission notice appear in supporting
24 ** documentation. This software is provided "as is" without express or
25 ** implied warranty.
26 */
28 #define DEVICE_NAME "Z2RAM"
30 #include <linux/major.h>
31 #include <linux/vmalloc.h>
32 #include <linux/init.h>
33 #include <linux/module.h>
34 #include <linux/blkdev.h>
35 #include <linux/bitops.h>
37 #include <asm/setup.h>
38 #include <asm/amigahw.h>
39 #include <asm/pgtable.h>
41 #include <linux/zorro.h>
44 extern int m68k_realnum_memory;
45 extern struct mem_info m68k_memory[NUM_MEMINFO];
47 #define TRUE (1)
48 #define FALSE (0)
50 #define Z2MINOR_COMBINED (0)
51 #define Z2MINOR_Z2ONLY (1)
52 #define Z2MINOR_CHIPONLY (2)
53 #define Z2MINOR_MEMLIST1 (4)
54 #define Z2MINOR_MEMLIST2 (5)
55 #define Z2MINOR_MEMLIST3 (6)
56 #define Z2MINOR_MEMLIST4 (7)
57 #define Z2MINOR_COUNT (8) /* Move this down when adding a new minor */
59 #define Z2RAM_CHUNK1024 ( Z2RAM_CHUNKSIZE >> 10 )
61 static u_long *z2ram_map = NULL;
62 static u_long z2ram_size = 0;
63 static int z2_count = 0;
64 static int chip_count = 0;
65 static int list_count = 0;
66 static int current_device = -1;
68 static DEFINE_SPINLOCK(z2ram_lock);
70 static struct block_device_operations z2_fops;
71 static struct gendisk *z2ram_gendisk;
73 static void do_z2_request(request_queue_t *q)
74 {
75 struct request *req;
76 while ((req = elv_next_request(q)) != NULL) {
77 unsigned long start = req->sector << 9;
78 unsigned long len = req->current_nr_sectors << 9;
80 if (start + len > z2ram_size) {
81 printk( KERN_ERR DEVICE_NAME ": bad access: block=%lu, count=%u\n",
82 req->sector, req->current_nr_sectors);
83 end_request(req, 0);
84 continue;
85 }
86 while (len) {
87 unsigned long addr = start & Z2RAM_CHUNKMASK;
88 unsigned long size = Z2RAM_CHUNKSIZE - addr;
89 if (len < size)
90 size = len;
91 addr += z2ram_map[ start >> Z2RAM_CHUNKSHIFT ];
92 if (rq_data_dir(req) == READ)
93 memcpy(req->buffer, (char *)addr, size);
94 else
95 memcpy((char *)addr, req->buffer, size);
96 start += size;
97 len -= size;
98 }
99 end_request(req, 1);
100 }
101 }
103 static void
104 get_z2ram( void )
105 {
106 int i;
108 for ( i = 0; i < Z2RAM_SIZE / Z2RAM_CHUNKSIZE; i++ )
109 {
110 if ( test_bit( i, zorro_unused_z2ram ) )
111 {
112 z2_count++;
113 z2ram_map[ z2ram_size++ ] =
114 ZTWO_VADDR( Z2RAM_START ) + ( i << Z2RAM_CHUNKSHIFT );
115 clear_bit( i, zorro_unused_z2ram );
116 }
117 }
119 return;
120 }
122 static void
123 get_chipram( void )
124 {
126 while ( amiga_chip_avail() > ( Z2RAM_CHUNKSIZE * 4 ) )
127 {
128 chip_count++;
129 z2ram_map[ z2ram_size ] =
130 (u_long)amiga_chip_alloc( Z2RAM_CHUNKSIZE, "z2ram" );
132 if ( z2ram_map[ z2ram_size ] == 0 )
133 {
134 break;
135 }
137 z2ram_size++;
138 }
140 return;
141 }
143 static int
144 z2_open( struct inode *inode, struct file *filp )
145 {
146 int device;
147 int max_z2_map = ( Z2RAM_SIZE / Z2RAM_CHUNKSIZE ) *
148 sizeof( z2ram_map[0] );
149 int max_chip_map = ( amiga_chip_size / Z2RAM_CHUNKSIZE ) *
150 sizeof( z2ram_map[0] );
151 int rc = -ENOMEM;
153 device = iminor(inode);
155 if ( current_device != -1 && current_device != device )
156 {
157 rc = -EBUSY;
158 goto err_out;
159 }
161 if ( current_device == -1 )
162 {
163 z2_count = 0;
164 chip_count = 0;
165 list_count = 0;
166 z2ram_size = 0;
168 /* Use a specific list entry. */
169 if (device >= Z2MINOR_MEMLIST1 && device <= Z2MINOR_MEMLIST4) {
170 int index = device - Z2MINOR_MEMLIST1 + 1;
171 unsigned long size, paddr, vaddr;
173 if (index >= m68k_realnum_memory) {
174 printk( KERN_ERR DEVICE_NAME
175 ": no such entry in z2ram_map\n" );
176 goto err_out;
177 }
179 paddr = m68k_memory[index].addr;
180 size = m68k_memory[index].size & ~(Z2RAM_CHUNKSIZE-1);
182 #ifdef __powerpc__
183 /* FIXME: ioremap doesn't build correct memory tables. */
184 {
185 vfree(vmalloc (size));
186 }
188 vaddr = (unsigned long) __ioremap (paddr, size,
189 _PAGE_WRITETHRU);
191 #else
192 vaddr = (unsigned long)z_remap_nocache_nonser(paddr, size);
193 #endif
194 z2ram_map =
195 kmalloc((size/Z2RAM_CHUNKSIZE)*sizeof(z2ram_map[0]),
196 GFP_KERNEL);
197 if ( z2ram_map == NULL )
198 {
199 printk( KERN_ERR DEVICE_NAME
200 ": cannot get mem for z2ram_map\n" );
201 goto err_out;
202 }
204 while (size) {
205 z2ram_map[ z2ram_size++ ] = vaddr;
206 size -= Z2RAM_CHUNKSIZE;
207 vaddr += Z2RAM_CHUNKSIZE;
208 list_count++;
209 }
211 if ( z2ram_size != 0 )
212 printk( KERN_INFO DEVICE_NAME
213 ": using %iK List Entry %d Memory\n",
214 list_count * Z2RAM_CHUNK1024, index );
215 } else
217 switch ( device )
218 {
219 case Z2MINOR_COMBINED:
221 z2ram_map = kmalloc( max_z2_map + max_chip_map, GFP_KERNEL );
222 if ( z2ram_map == NULL )
223 {
224 printk( KERN_ERR DEVICE_NAME
225 ": cannot get mem for z2ram_map\n" );
226 goto err_out;
227 }
229 get_z2ram();
230 get_chipram();
232 if ( z2ram_size != 0 )
233 printk( KERN_INFO DEVICE_NAME
234 ": using %iK Zorro II RAM and %iK Chip RAM (Total %dK)\n",
235 z2_count * Z2RAM_CHUNK1024,
236 chip_count * Z2RAM_CHUNK1024,
237 ( z2_count + chip_count ) * Z2RAM_CHUNK1024 );
239 break;
241 case Z2MINOR_Z2ONLY:
242 z2ram_map = kmalloc( max_z2_map, GFP_KERNEL );
243 if ( z2ram_map == NULL )
244 {
245 printk( KERN_ERR DEVICE_NAME
246 ": cannot get mem for z2ram_map\n" );
247 goto err_out;
248 }
250 get_z2ram();
252 if ( z2ram_size != 0 )
253 printk( KERN_INFO DEVICE_NAME
254 ": using %iK of Zorro II RAM\n",
255 z2_count * Z2RAM_CHUNK1024 );
257 break;
259 case Z2MINOR_CHIPONLY:
260 z2ram_map = kmalloc( max_chip_map, GFP_KERNEL );
261 if ( z2ram_map == NULL )
262 {
263 printk( KERN_ERR DEVICE_NAME
264 ": cannot get mem for z2ram_map\n" );
265 goto err_out;
266 }
268 get_chipram();
270 if ( z2ram_size != 0 )
271 printk( KERN_INFO DEVICE_NAME
272 ": using %iK Chip RAM\n",
273 chip_count * Z2RAM_CHUNK1024 );
275 break;
277 default:
278 rc = -ENODEV;
279 goto err_out;
281 break;
282 }
284 if ( z2ram_size == 0 )
285 {
286 printk( KERN_NOTICE DEVICE_NAME
287 ": no unused ZII/Chip RAM found\n" );
288 goto err_out_kfree;
289 }
291 current_device = device;
292 z2ram_size <<= Z2RAM_CHUNKSHIFT;
293 set_capacity(z2ram_gendisk, z2ram_size >> 9);
294 }
296 return 0;
298 err_out_kfree:
299 kfree(z2ram_map);
300 err_out:
301 return rc;
302 }
304 static int
305 z2_release( struct inode *inode, struct file *filp )
306 {
307 if ( current_device == -1 )
308 return 0;
310 /*
311 * FIXME: unmap memory
312 */
314 return 0;
315 }
317 static struct block_device_operations z2_fops =
318 {
319 .owner = THIS_MODULE,
320 .open = z2_open,
321 .release = z2_release,
322 };
324 static struct kobject *z2_find(dev_t dev, int *part, void *data)
325 {
326 *part = 0;
327 return get_disk(z2ram_gendisk);
328 }
330 static struct request_queue *z2_queue;
332 int __init
333 z2_init(void)
334 {
335 int ret;
337 if (!MACH_IS_AMIGA)
338 return -ENXIO;
340 ret = -EBUSY;
341 if (register_blkdev(Z2RAM_MAJOR, DEVICE_NAME))
342 goto err;
344 ret = -ENOMEM;
345 z2ram_gendisk = alloc_disk(1);
346 if (!z2ram_gendisk)
347 goto out_disk;
349 z2_queue = blk_init_queue(do_z2_request, &z2ram_lock);
350 if (!z2_queue)
351 goto out_queue;
353 z2ram_gendisk->major = Z2RAM_MAJOR;
354 z2ram_gendisk->first_minor = 0;
355 z2ram_gendisk->fops = &z2_fops;
356 sprintf(z2ram_gendisk->disk_name, "z2ram");
358 z2ram_gendisk->queue = z2_queue;
359 add_disk(z2ram_gendisk);
360 blk_register_region(MKDEV(Z2RAM_MAJOR, 0), Z2MINOR_COUNT, THIS_MODULE,
361 z2_find, NULL, NULL);
363 return 0;
365 out_queue:
366 put_disk(z2ram_gendisk);
367 out_disk:
368 unregister_blkdev(Z2RAM_MAJOR, DEVICE_NAME);
369 err:
370 return ret;
371 }
373 #if defined(MODULE)
375 MODULE_LICENSE("GPL");
377 int
378 init_module( void )
379 {
380 int error;
382 error = z2_init();
383 if ( error == 0 )
384 {
385 printk( KERN_INFO DEVICE_NAME ": loaded as module\n" );
386 }
388 return error;
389 }
391 void
392 cleanup_module( void )
393 {
394 int i, j;
395 blk_unregister_region(MKDEV(Z2RAM_MAJOR, 0), 256);
396 if ( unregister_blkdev( Z2RAM_MAJOR, DEVICE_NAME ) != 0 )
397 printk( KERN_ERR DEVICE_NAME ": unregister of device failed\n");
399 del_gendisk(z2ram_gendisk);
400 put_disk(z2ram_gendisk);
401 blk_cleanup_queue(z2_queue);
403 if ( current_device != -1 )
404 {
405 i = 0;
407 for ( j = 0 ; j < z2_count; j++ )
408 {
409 set_bit( i++, zorro_unused_z2ram );
410 }
412 for ( j = 0 ; j < chip_count; j++ )
413 {
414 if ( z2ram_map[ i ] )
415 {
416 amiga_chip_free( (void *) z2ram_map[ i++ ] );
417 }
418 }
420 if ( z2ram_map != NULL )
421 {
422 kfree( z2ram_map );
423 }
424 }
426 return;
427 }
428 #endif