ia64/linux-2.6.18-xen.hg

view drivers/bluetooth/hci_ldisc.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 *
3 * Bluetooth HCI UART driver
4 *
5 * Copyright (C) 2000-2001 Qualcomm Incorporated
6 * Copyright (C) 2002-2003 Maxim Krasnyansky <maxk@qualcomm.com>
7 * Copyright (C) 2004-2005 Marcel Holtmann <marcel@holtmann.org>
8 *
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 *
24 */
26 #include <linux/module.h>
28 #include <linux/kernel.h>
29 #include <linux/init.h>
30 #include <linux/sched.h>
31 #include <linux/types.h>
32 #include <linux/fcntl.h>
33 #include <linux/interrupt.h>
34 #include <linux/ptrace.h>
35 #include <linux/poll.h>
37 #include <linux/slab.h>
38 #include <linux/tty.h>
39 #include <linux/errno.h>
40 #include <linux/string.h>
41 #include <linux/signal.h>
42 #include <linux/ioctl.h>
43 #include <linux/skbuff.h>
45 #include <net/bluetooth/bluetooth.h>
46 #include <net/bluetooth/hci_core.h>
48 #include "hci_uart.h"
50 #ifndef CONFIG_BT_HCIUART_DEBUG
51 #undef BT_DBG
52 #define BT_DBG( A... )
53 #endif
55 #define VERSION "2.2"
57 static int reset = 0;
59 static struct hci_uart_proto *hup[HCI_UART_MAX_PROTO];
61 int hci_uart_register_proto(struct hci_uart_proto *p)
62 {
63 if (p->id >= HCI_UART_MAX_PROTO)
64 return -EINVAL;
66 if (hup[p->id])
67 return -EEXIST;
69 hup[p->id] = p;
71 return 0;
72 }
74 int hci_uart_unregister_proto(struct hci_uart_proto *p)
75 {
76 if (p->id >= HCI_UART_MAX_PROTO)
77 return -EINVAL;
79 if (!hup[p->id])
80 return -EINVAL;
82 hup[p->id] = NULL;
84 return 0;
85 }
87 static struct hci_uart_proto *hci_uart_get_proto(unsigned int id)
88 {
89 if (id >= HCI_UART_MAX_PROTO)
90 return NULL;
92 return hup[id];
93 }
95 static inline void hci_uart_tx_complete(struct hci_uart *hu, int pkt_type)
96 {
97 struct hci_dev *hdev = hu->hdev;
99 /* Update HCI stat counters */
100 switch (pkt_type) {
101 case HCI_COMMAND_PKT:
102 hdev->stat.cmd_tx++;
103 break;
105 case HCI_ACLDATA_PKT:
106 hdev->stat.acl_tx++;
107 break;
109 case HCI_SCODATA_PKT:
110 hdev->stat.cmd_tx++;
111 break;
112 }
113 }
115 static inline struct sk_buff *hci_uart_dequeue(struct hci_uart *hu)
116 {
117 struct sk_buff *skb = hu->tx_skb;
119 if (!skb)
120 skb = hu->proto->dequeue(hu);
121 else
122 hu->tx_skb = NULL;
124 return skb;
125 }
127 int hci_uart_tx_wakeup(struct hci_uart *hu)
128 {
129 struct tty_struct *tty = hu->tty;
130 struct hci_dev *hdev = hu->hdev;
131 struct sk_buff *skb;
133 if (test_and_set_bit(HCI_UART_SENDING, &hu->tx_state)) {
134 set_bit(HCI_UART_TX_WAKEUP, &hu->tx_state);
135 return 0;
136 }
138 BT_DBG("");
140 restart:
141 clear_bit(HCI_UART_TX_WAKEUP, &hu->tx_state);
143 while ((skb = hci_uart_dequeue(hu))) {
144 int len;
146 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
147 len = tty->driver->write(tty, skb->data, skb->len);
148 hdev->stat.byte_tx += len;
150 skb_pull(skb, len);
151 if (skb->len) {
152 hu->tx_skb = skb;
153 break;
154 }
156 hci_uart_tx_complete(hu, bt_cb(skb)->pkt_type);
157 kfree_skb(skb);
158 }
160 if (test_bit(HCI_UART_TX_WAKEUP, &hu->tx_state))
161 goto restart;
163 clear_bit(HCI_UART_SENDING, &hu->tx_state);
164 return 0;
165 }
167 /* ------- Interface to HCI layer ------ */
168 /* Initialize device */
169 static int hci_uart_open(struct hci_dev *hdev)
170 {
171 BT_DBG("%s %p", hdev->name, hdev);
173 /* Nothing to do for UART driver */
175 set_bit(HCI_RUNNING, &hdev->flags);
177 return 0;
178 }
180 /* Reset device */
181 static int hci_uart_flush(struct hci_dev *hdev)
182 {
183 struct hci_uart *hu = (struct hci_uart *) hdev->driver_data;
184 struct tty_struct *tty = hu->tty;
186 BT_DBG("hdev %p tty %p", hdev, tty);
188 if (hu->tx_skb) {
189 kfree_skb(hu->tx_skb); hu->tx_skb = NULL;
190 }
192 /* Flush any pending characters in the driver and discipline. */
193 tty_ldisc_flush(tty);
194 if (tty->driver && tty->driver->flush_buffer)
195 tty->driver->flush_buffer(tty);
197 if (test_bit(HCI_UART_PROTO_SET, &hu->flags))
198 hu->proto->flush(hu);
200 return 0;
201 }
203 /* Close device */
204 static int hci_uart_close(struct hci_dev *hdev)
205 {
206 BT_DBG("hdev %p", hdev);
208 if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
209 return 0;
211 hci_uart_flush(hdev);
212 return 0;
213 }
215 /* Send frames from HCI layer */
216 static int hci_uart_send_frame(struct sk_buff *skb)
217 {
218 struct hci_dev* hdev = (struct hci_dev *) skb->dev;
219 struct tty_struct *tty;
220 struct hci_uart *hu;
222 if (!hdev) {
223 BT_ERR("Frame for uknown device (hdev=NULL)");
224 return -ENODEV;
225 }
227 if (!test_bit(HCI_RUNNING, &hdev->flags))
228 return -EBUSY;
230 hu = (struct hci_uart *) hdev->driver_data;
231 tty = hu->tty;
233 BT_DBG("%s: type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len);
235 hu->proto->enqueue(hu, skb);
237 hci_uart_tx_wakeup(hu);
239 return 0;
240 }
242 static void hci_uart_destruct(struct hci_dev *hdev)
243 {
244 struct hci_uart *hu;
246 if (!hdev)
247 return;
249 BT_DBG("%s", hdev->name);
251 hu = (struct hci_uart *) hdev->driver_data;
252 kfree(hu);
253 }
255 /* ------ LDISC part ------ */
256 /* hci_uart_tty_open
257 *
258 * Called when line discipline changed to HCI_UART.
259 *
260 * Arguments:
261 * tty pointer to tty info structure
262 * Return Value:
263 * 0 if success, otherwise error code
264 */
265 static int hci_uart_tty_open(struct tty_struct *tty)
266 {
267 struct hci_uart *hu = (void *) tty->disc_data;
269 BT_DBG("tty %p", tty);
271 if (hu)
272 return -EEXIST;
274 if (!(hu = kzalloc(sizeof(struct hci_uart), GFP_KERNEL))) {
275 BT_ERR("Can't allocate controll structure");
276 return -ENFILE;
277 }
279 tty->disc_data = hu;
280 hu->tty = tty;
281 tty->receive_room = 65536;
283 spin_lock_init(&hu->rx_lock);
285 /* Flush any pending characters in the driver and line discipline. */
287 /* FIXME: why is this needed. Note don't use ldisc_ref here as the
288 open path is before the ldisc is referencable */
290 if (tty->ldisc.flush_buffer)
291 tty->ldisc.flush_buffer(tty);
293 if (tty->driver && tty->driver->flush_buffer)
294 tty->driver->flush_buffer(tty);
296 return 0;
297 }
299 /* hci_uart_tty_close()
300 *
301 * Called when the line discipline is changed to something
302 * else, the tty is closed, or the tty detects a hangup.
303 */
304 static void hci_uart_tty_close(struct tty_struct *tty)
305 {
306 struct hci_uart *hu = (void *)tty->disc_data;
308 BT_DBG("tty %p", tty);
310 /* Detach from the tty */
311 tty->disc_data = NULL;
313 if (hu) {
314 struct hci_dev *hdev = hu->hdev;
315 hci_uart_close(hdev);
317 if (test_and_clear_bit(HCI_UART_PROTO_SET, &hu->flags)) {
318 hu->proto->close(hu);
319 hci_unregister_dev(hdev);
320 hci_free_dev(hdev);
321 }
322 }
323 }
325 /* hci_uart_tty_wakeup()
326 *
327 * Callback for transmit wakeup. Called when low level
328 * device driver can accept more send data.
329 *
330 * Arguments: tty pointer to associated tty instance data
331 * Return Value: None
332 */
333 static void hci_uart_tty_wakeup(struct tty_struct *tty)
334 {
335 struct hci_uart *hu = (void *)tty->disc_data;
337 BT_DBG("");
339 if (!hu)
340 return;
342 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
344 if (tty != hu->tty)
345 return;
347 if (test_bit(HCI_UART_PROTO_SET, &hu->flags))
348 hci_uart_tx_wakeup(hu);
349 }
351 /* hci_uart_tty_receive()
352 *
353 * Called by tty low level driver when receive data is
354 * available.
355 *
356 * Arguments: tty pointer to tty isntance data
357 * data pointer to received data
358 * flags pointer to flags for data
359 * count count of received data in bytes
360 *
361 * Return Value: None
362 */
363 static void hci_uart_tty_receive(struct tty_struct *tty, const __u8 *data, char *flags, int count)
364 {
365 struct hci_uart *hu = (void *)tty->disc_data;
367 if (!hu || tty != hu->tty)
368 return;
370 if (!test_bit(HCI_UART_PROTO_SET, &hu->flags))
371 return;
373 spin_lock(&hu->rx_lock);
374 hu->proto->recv(hu, (void *) data, count);
375 hu->hdev->stat.byte_rx += count;
376 spin_unlock(&hu->rx_lock);
378 if (test_and_clear_bit(TTY_THROTTLED,&tty->flags) && tty->driver->unthrottle)
379 tty->driver->unthrottle(tty);
380 }
382 static int hci_uart_register_dev(struct hci_uart *hu)
383 {
384 struct hci_dev *hdev;
386 BT_DBG("");
388 /* Initialize and register HCI device */
389 hdev = hci_alloc_dev();
390 if (!hdev) {
391 BT_ERR("Can't allocate HCI device");
392 return -ENOMEM;
393 }
395 hu->hdev = hdev;
397 hdev->type = HCI_UART;
398 hdev->driver_data = hu;
400 hdev->open = hci_uart_open;
401 hdev->close = hci_uart_close;
402 hdev->flush = hci_uart_flush;
403 hdev->send = hci_uart_send_frame;
404 hdev->destruct = hci_uart_destruct;
406 hdev->owner = THIS_MODULE;
408 if (reset)
409 set_bit(HCI_QUIRK_RESET_ON_INIT, &hdev->quirks);
411 if (hci_register_dev(hdev) < 0) {
412 BT_ERR("Can't register HCI device");
413 hci_free_dev(hdev);
414 return -ENODEV;
415 }
417 return 0;
418 }
420 static int hci_uart_set_proto(struct hci_uart *hu, int id)
421 {
422 struct hci_uart_proto *p;
423 int err;
425 p = hci_uart_get_proto(id);
426 if (!p)
427 return -EPROTONOSUPPORT;
429 err = p->open(hu);
430 if (err)
431 return err;
433 hu->proto = p;
435 err = hci_uart_register_dev(hu);
436 if (err) {
437 p->close(hu);
438 return err;
439 }
441 return 0;
442 }
444 /* hci_uart_tty_ioctl()
445 *
446 * Process IOCTL system call for the tty device.
447 *
448 * Arguments:
449 *
450 * tty pointer to tty instance data
451 * file pointer to open file object for device
452 * cmd IOCTL command code
453 * arg argument for IOCTL call (cmd dependent)
454 *
455 * Return Value: Command dependent
456 */
457 static int hci_uart_tty_ioctl(struct tty_struct *tty, struct file * file,
458 unsigned int cmd, unsigned long arg)
459 {
460 struct hci_uart *hu = (void *)tty->disc_data;
461 int err = 0;
463 BT_DBG("");
465 /* Verify the status of the device */
466 if (!hu)
467 return -EBADF;
469 switch (cmd) {
470 case HCIUARTSETPROTO:
471 if (!test_and_set_bit(HCI_UART_PROTO_SET, &hu->flags)) {
472 err = hci_uart_set_proto(hu, arg);
473 if (err) {
474 clear_bit(HCI_UART_PROTO_SET, &hu->flags);
475 return err;
476 }
477 tty->low_latency = 1;
478 } else
479 return -EBUSY;
481 case HCIUARTGETPROTO:
482 if (test_bit(HCI_UART_PROTO_SET, &hu->flags))
483 return hu->proto->id;
484 return -EUNATCH;
486 default:
487 err = n_tty_ioctl(tty, file, cmd, arg);
488 break;
489 };
491 return err;
492 }
494 /*
495 * We don't provide read/write/poll interface for user space.
496 */
497 static ssize_t hci_uart_tty_read(struct tty_struct *tty, struct file *file,
498 unsigned char __user *buf, size_t nr)
499 {
500 return 0;
501 }
503 static ssize_t hci_uart_tty_write(struct tty_struct *tty, struct file *file,
504 const unsigned char *data, size_t count)
505 {
506 return 0;
507 }
509 static unsigned int hci_uart_tty_poll(struct tty_struct *tty,
510 struct file *filp, poll_table *wait)
511 {
512 return 0;
513 }
515 static int __init hci_uart_init(void)
516 {
517 static struct tty_ldisc hci_uart_ldisc;
518 int err;
520 BT_INFO("HCI UART driver ver %s", VERSION);
522 /* Register the tty discipline */
524 memset(&hci_uart_ldisc, 0, sizeof (hci_uart_ldisc));
525 hci_uart_ldisc.magic = TTY_LDISC_MAGIC;
526 hci_uart_ldisc.name = "n_hci";
527 hci_uart_ldisc.open = hci_uart_tty_open;
528 hci_uart_ldisc.close = hci_uart_tty_close;
529 hci_uart_ldisc.read = hci_uart_tty_read;
530 hci_uart_ldisc.write = hci_uart_tty_write;
531 hci_uart_ldisc.ioctl = hci_uart_tty_ioctl;
532 hci_uart_ldisc.poll = hci_uart_tty_poll;
533 hci_uart_ldisc.receive_buf = hci_uart_tty_receive;
534 hci_uart_ldisc.write_wakeup = hci_uart_tty_wakeup;
535 hci_uart_ldisc.owner = THIS_MODULE;
537 if ((err = tty_register_ldisc(N_HCI, &hci_uart_ldisc))) {
538 BT_ERR("HCI line discipline registration failed. (%d)", err);
539 return err;
540 }
542 #ifdef CONFIG_BT_HCIUART_H4
543 h4_init();
544 #endif
545 #ifdef CONFIG_BT_HCIUART_BCSP
546 bcsp_init();
547 #endif
549 return 0;
550 }
552 static void __exit hci_uart_exit(void)
553 {
554 int err;
556 #ifdef CONFIG_BT_HCIUART_H4
557 h4_deinit();
558 #endif
559 #ifdef CONFIG_BT_HCIUART_BCSP
560 bcsp_deinit();
561 #endif
563 /* Release tty registration of line discipline */
564 if ((err = tty_unregister_ldisc(N_HCI)))
565 BT_ERR("Can't unregister HCI line discipline (%d)", err);
566 }
568 module_init(hci_uart_init);
569 module_exit(hci_uart_exit);
571 module_param(reset, bool, 0644);
572 MODULE_PARM_DESC(reset, "Send HCI reset command on initialization");
574 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>");
575 MODULE_DESCRIPTION("Bluetooth HCI UART driver ver " VERSION);
576 MODULE_VERSION(VERSION);
577 MODULE_LICENSE("GPL");
578 MODULE_ALIAS_LDISC(N_HCI);