ia64/linux-2.6.18-xen.hg

view drivers/serial/mux.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 ** mux.c:
3 ** serial driver for the Mux console found in some PA-RISC servers.
4 **
5 ** (c) Copyright 2002 Ryan Bradetich
6 ** (c) Copyright 2002 Hewlett-Packard Company
7 **
8 ** This program is free software; you can redistribute it and/or modify
9 ** it under the terms of the GNU General Public License as published by
10 ** the Free Software Foundation; either version 2 of the License, or
11 ** (at your option) any later version.
12 **
13 ** This Driver currently only supports the console (port 0) on the MUX.
14 ** Additional work will be needed on this driver to enable the full
15 ** functionality of the MUX.
16 **
17 */
19 #include <linux/module.h>
20 #include <linux/tty.h>
21 #include <linux/ioport.h>
22 #include <linux/init.h>
23 #include <linux/serial.h>
24 #include <linux/console.h>
25 #include <linux/slab.h>
26 #include <linux/delay.h> /* for udelay */
27 #include <linux/device.h>
28 #include <asm/io.h>
29 #include <asm/irq.h>
30 #include <asm/parisc-device.h>
32 #ifdef CONFIG_MAGIC_SYSRQ
33 #include <linux/sysrq.h>
34 #define SUPPORT_SYSRQ
35 #endif
37 #include <linux/serial_core.h>
39 #define MUX_OFFSET 0x800
40 #define MUX_LINE_OFFSET 0x80
42 #define MUX_FIFO_SIZE 255
43 #define MUX_POLL_DELAY (30 * HZ / 1000)
45 #define IO_DATA_REG_OFFSET 0x3c
46 #define IO_DCOUNT_REG_OFFSET 0x40
48 #define MUX_EOFIFO(status) ((status & 0xF000) == 0xF000)
49 #define MUX_STATUS(status) ((status & 0xF000) == 0x8000)
50 #define MUX_BREAK(status) ((status & 0xF000) == 0x2000)
52 #define MUX_NR 256
53 static unsigned int port_cnt __read_mostly;
54 static struct uart_port mux_ports[MUX_NR];
56 static struct uart_driver mux_driver = {
57 .owner = THIS_MODULE,
58 .driver_name = "ttyB",
59 .dev_name = "ttyB",
60 .major = MUX_MAJOR,
61 .minor = 0,
62 .nr = MUX_NR,
63 };
65 static struct timer_list mux_timer;
67 #define UART_PUT_CHAR(p, c) __raw_writel((c), (p)->membase + IO_DATA_REG_OFFSET)
68 #define UART_GET_FIFO_CNT(p) __raw_readl((p)->membase + IO_DCOUNT_REG_OFFSET)
69 #define GET_MUX_PORTS(iodc_data) ((((iodc_data)[4] & 0xf0) >> 4) * 8) + 8
71 /**
72 * mux_tx_empty - Check if the transmitter fifo is empty.
73 * @port: Ptr to the uart_port.
74 *
75 * This function test if the transmitter fifo for the port
76 * described by 'port' is empty. If it is empty, this function
77 * should return TIOCSER_TEMT, otherwise return 0.
78 */
79 static unsigned int mux_tx_empty(struct uart_port *port)
80 {
81 return UART_GET_FIFO_CNT(port) ? 0 : TIOCSER_TEMT;
82 }
84 /**
85 * mux_set_mctrl - Set the current state of the modem control inputs.
86 * @ports: Ptr to the uart_port.
87 * @mctrl: Modem control bits.
88 *
89 * The Serial MUX does not support CTS, DCD or DSR so this function
90 * is ignored.
91 */
92 static void mux_set_mctrl(struct uart_port *port, unsigned int mctrl)
93 {
94 }
96 /**
97 * mux_get_mctrl - Returns the current state of modem control inputs.
98 * @port: Ptr to the uart_port.
99 *
100 * The Serial MUX does not support CTS, DCD or DSR so these lines are
101 * treated as permanently active.
102 */
103 static unsigned int mux_get_mctrl(struct uart_port *port)
104 {
105 return TIOCM_CAR | TIOCM_DSR | TIOCM_CTS;
106 }
108 /**
109 * mux_stop_tx - Stop transmitting characters.
110 * @port: Ptr to the uart_port.
111 *
112 * The Serial MUX does not support this function.
113 */
114 static void mux_stop_tx(struct uart_port *port)
115 {
116 }
118 /**
119 * mux_start_tx - Start transmitting characters.
120 * @port: Ptr to the uart_port.
121 *
122 * The Serial Mux does not support this function.
123 */
124 static void mux_start_tx(struct uart_port *port)
125 {
126 }
128 /**
129 * mux_stop_rx - Stop receiving characters.
130 * @port: Ptr to the uart_port.
131 *
132 * The Serial Mux does not support this function.
133 */
134 static void mux_stop_rx(struct uart_port *port)
135 {
136 }
138 /**
139 * mux_enable_ms - Enable modum status interrupts.
140 * @port: Ptr to the uart_port.
141 *
142 * The Serial Mux does not support this function.
143 */
144 static void mux_enable_ms(struct uart_port *port)
145 {
146 }
148 /**
149 * mux_break_ctl - Control the transmitssion of a break signal.
150 * @port: Ptr to the uart_port.
151 * @break_state: Raise/Lower the break signal.
152 *
153 * The Serial Mux does not support this function.
154 */
155 static void mux_break_ctl(struct uart_port *port, int break_state)
156 {
157 }
159 /**
160 * mux_write - Write chars to the mux fifo.
161 * @port: Ptr to the uart_port.
162 *
163 * This function writes all the data from the uart buffer to
164 * the mux fifo.
165 */
166 static void mux_write(struct uart_port *port)
167 {
168 int count;
169 struct circ_buf *xmit = &port->info->xmit;
171 if(port->x_char) {
172 UART_PUT_CHAR(port, port->x_char);
173 port->icount.tx++;
174 port->x_char = 0;
175 return;
176 }
178 if(uart_circ_empty(xmit) || uart_tx_stopped(port)) {
179 mux_stop_tx(port);
180 return;
181 }
183 count = (port->fifosize) - UART_GET_FIFO_CNT(port);
184 do {
185 UART_PUT_CHAR(port, xmit->buf[xmit->tail]);
186 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
187 port->icount.tx++;
188 if(uart_circ_empty(xmit))
189 break;
191 } while(--count > 0);
193 while(UART_GET_FIFO_CNT(port))
194 udelay(1);
196 if(uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
197 uart_write_wakeup(port);
199 if (uart_circ_empty(xmit))
200 mux_stop_tx(port);
201 }
203 /**
204 * mux_read - Read chars from the mux fifo.
205 * @port: Ptr to the uart_port.
206 *
207 * This reads all available data from the mux's fifo and pushes
208 * the data to the tty layer.
209 */
210 static void mux_read(struct uart_port *port)
211 {
212 int data;
213 struct tty_struct *tty = port->info->tty;
214 __u32 start_count = port->icount.rx;
216 while(1) {
217 data = __raw_readl(port->membase + IO_DATA_REG_OFFSET);
219 if (MUX_STATUS(data))
220 continue;
222 if (MUX_EOFIFO(data))
223 break;
225 port->icount.rx++;
227 if (MUX_BREAK(data)) {
228 port->icount.brk++;
229 if(uart_handle_break(port))
230 continue;
231 }
233 if (uart_handle_sysrq_char(port, data & 0xffu, NULL))
234 continue;
236 tty_insert_flip_char(tty, data & 0xFF, TTY_NORMAL);
237 }
239 if (start_count != port->icount.rx) {
240 tty_flip_buffer_push(tty);
241 }
242 }
244 /**
245 * mux_startup - Initialize the port.
246 * @port: Ptr to the uart_port.
247 *
248 * Grab any resources needed for this port and start the
249 * mux timer.
250 */
251 static int mux_startup(struct uart_port *port)
252 {
253 mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);
254 return 0;
255 }
257 /**
258 * mux_shutdown - Disable the port.
259 * @port: Ptr to the uart_port.
260 *
261 * Release any resources needed for the port.
262 */
263 static void mux_shutdown(struct uart_port *port)
264 {
265 }
267 /**
268 * mux_set_termios - Chane port parameters.
269 * @port: Ptr to the uart_port.
270 * @termios: new termios settings.
271 * @old: old termios settings.
272 *
273 * The Serial Mux does not support this function.
274 */
275 static void
276 mux_set_termios(struct uart_port *port, struct termios *termios,
277 struct termios *old)
278 {
279 }
281 /**
282 * mux_type - Describe the port.
283 * @port: Ptr to the uart_port.
284 *
285 * Return a pointer to a string constant describing the
286 * specified port.
287 */
288 static const char *mux_type(struct uart_port *port)
289 {
290 return "Mux";
291 }
293 /**
294 * mux_release_port - Release memory and IO regions.
295 * @port: Ptr to the uart_port.
296 *
297 * Release any memory and IO region resources currently in use by
298 * the port.
299 */
300 static void mux_release_port(struct uart_port *port)
301 {
302 }
304 /**
305 * mux_request_port - Request memory and IO regions.
306 * @port: Ptr to the uart_port.
307 *
308 * Request any memory and IO region resources required by the port.
309 * If any fail, no resources should be registered when this function
310 * returns, and it should return -EBUSY on failure.
311 */
312 static int mux_request_port(struct uart_port *port)
313 {
314 return 0;
315 }
317 /**
318 * mux_config_port - Perform port autoconfiguration.
319 * @port: Ptr to the uart_port.
320 * @type: Bitmask of required configurations.
321 *
322 * Perform any autoconfiguration steps for the port. This functino is
323 * called if the UPF_BOOT_AUTOCONF flag is specified for the port.
324 * [Note: This is required for now because of a bug in the Serial core.
325 * rmk has already submitted a patch to linus, should be available for
326 * 2.5.47.]
327 */
328 static void mux_config_port(struct uart_port *port, int type)
329 {
330 port->type = PORT_MUX;
331 }
333 /**
334 * mux_verify_port - Verify the port information.
335 * @port: Ptr to the uart_port.
336 * @ser: Ptr to the serial information.
337 *
338 * Verify the new serial port information contained within serinfo is
339 * suitable for this port type.
340 */
341 static int mux_verify_port(struct uart_port *port, struct serial_struct *ser)
342 {
343 if(port->membase == NULL)
344 return -EINVAL;
346 return 0;
347 }
349 /**
350 * mux_drv_poll - Mux poll function.
351 * @unused: Unused variable
352 *
353 * This function periodically polls the Serial MUX to check for new data.
354 */
355 static void mux_poll(unsigned long unused)
356 {
357 int i;
359 for(i = 0; i < port_cnt; ++i) {
360 if(!mux_ports[i].info)
361 continue;
363 mux_read(&mux_ports[i]);
364 mux_write(&mux_ports[i]);
365 }
367 mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);
368 }
371 #ifdef CONFIG_SERIAL_MUX_CONSOLE
372 static void mux_console_write(struct console *co, const char *s, unsigned count)
373 {
374 while(count--)
375 pdc_iodc_putc(*s++);
376 }
378 static int mux_console_setup(struct console *co, char *options)
379 {
380 return 0;
381 }
383 struct tty_driver *mux_console_device(struct console *co, int *index)
384 {
385 *index = co->index;
386 return mux_driver.tty_driver;
387 }
389 static struct console mux_console = {
390 .name = "ttyB",
391 .write = mux_console_write,
392 .device = mux_console_device,
393 .setup = mux_console_setup,
394 .flags = CON_ENABLED | CON_PRINTBUFFER,
395 .index = 0,
396 };
398 #define MUX_CONSOLE &mux_console
399 #else
400 #define MUX_CONSOLE NULL
401 #endif
403 static struct uart_ops mux_pops = {
404 .tx_empty = mux_tx_empty,
405 .set_mctrl = mux_set_mctrl,
406 .get_mctrl = mux_get_mctrl,
407 .stop_tx = mux_stop_tx,
408 .start_tx = mux_start_tx,
409 .stop_rx = mux_stop_rx,
410 .enable_ms = mux_enable_ms,
411 .break_ctl = mux_break_ctl,
412 .startup = mux_startup,
413 .shutdown = mux_shutdown,
414 .set_termios = mux_set_termios,
415 .type = mux_type,
416 .release_port = mux_release_port,
417 .request_port = mux_request_port,
418 .config_port = mux_config_port,
419 .verify_port = mux_verify_port,
420 };
422 /**
423 * mux_probe - Determine if the Serial Mux should claim this device.
424 * @dev: The parisc device.
425 *
426 * Deterimine if the Serial Mux should claim this chip (return 0)
427 * or not (return 1).
428 */
429 static int __init mux_probe(struct parisc_device *dev)
430 {
431 int i, status, ports;
432 u8 iodc_data[32];
433 unsigned long bytecnt;
434 struct uart_port *port;
436 status = pdc_iodc_read(&bytecnt, dev->hpa.start, 0, iodc_data, 32);
437 if(status != PDC_OK) {
438 printk(KERN_ERR "Serial mux: Unable to read IODC.\n");
439 return 1;
440 }
442 ports = GET_MUX_PORTS(iodc_data);
443 printk(KERN_INFO "Serial mux driver (%d ports) Revision: 0.3\n", ports);
445 if(!port_cnt) {
446 mux_driver.cons = MUX_CONSOLE;
448 status = uart_register_driver(&mux_driver);
449 if(status) {
450 printk(KERN_ERR "Serial mux: Unable to register driver.\n");
451 return 1;
452 }
454 init_timer(&mux_timer);
455 mux_timer.function = mux_poll;
456 }
458 for(i = 0; i < ports; ++i, ++port_cnt) {
459 port = &mux_ports[port_cnt];
460 port->iobase = 0;
461 port->mapbase = dev->hpa.start + MUX_OFFSET +
462 (i * MUX_LINE_OFFSET);
463 port->membase = ioremap_nocache(port->mapbase, MUX_LINE_OFFSET);
464 port->iotype = UPIO_MEM;
465 port->type = PORT_MUX;
466 port->irq = NO_IRQ;
467 port->uartclk = 0;
468 port->fifosize = MUX_FIFO_SIZE;
469 port->ops = &mux_pops;
470 port->flags = UPF_BOOT_AUTOCONF;
471 port->line = port_cnt;
473 /* The port->timeout needs to match what is present in
474 * uart_wait_until_sent in serial_core.c. Otherwise
475 * the time spent in msleep_interruptable will be very
476 * long, causing the appearance of a console hang.
477 */
478 port->timeout = HZ / 50;
479 spin_lock_init(&port->lock);
480 status = uart_add_one_port(&mux_driver, port);
481 BUG_ON(status);
482 }
484 #ifdef CONFIG_SERIAL_MUX_CONSOLE
485 register_console(&mux_console);
486 #endif
487 return 0;
488 }
490 static struct parisc_device_id mux_tbl[] = {
491 { HPHW_A_DIRECT, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0000D },
492 { 0, }
493 };
495 MODULE_DEVICE_TABLE(parisc, mux_tbl);
497 static struct parisc_driver serial_mux_driver = {
498 .name = "serial_mux",
499 .id_table = mux_tbl,
500 .probe = mux_probe,
501 };
503 /**
504 * mux_init - Serial MUX initalization procedure.
505 *
506 * Register the Serial MUX driver.
507 */
508 static int __init mux_init(void)
509 {
510 return register_parisc_driver(&serial_mux_driver);
511 }
513 /**
514 * mux_exit - Serial MUX cleanup procedure.
515 *
516 * Unregister the Serial MUX driver from the tty layer.
517 */
518 static void __exit mux_exit(void)
519 {
520 int i;
522 for (i = 0; i < port_cnt; i++) {
523 uart_remove_one_port(&mux_driver, &mux_ports[i]);
524 }
526 uart_unregister_driver(&mux_driver);
527 }
529 module_init(mux_init);
530 module_exit(mux_exit);
532 MODULE_AUTHOR("Ryan Bradetich");
533 MODULE_DESCRIPTION("Serial MUX driver");
534 MODULE_LICENSE("GPL");
535 MODULE_ALIAS_CHARDEV_MAJOR(MUX_MAJOR);