ia64/linux-2.6.18-xen.hg

view drivers/atm/atmtcp.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 /* drivers/atm/atmtcp.c - ATM over TCP "device" driver */
3 /* Written 1997-2000 by Werner Almesberger, EPFL LRC/ICA */
6 #include <linux/module.h>
7 #include <linux/wait.h>
8 #include <linux/atmdev.h>
9 #include <linux/atm_tcp.h>
10 #include <linux/bitops.h>
11 #include <linux/init.h>
12 #include <asm/uaccess.h>
13 #include <asm/atomic.h>
16 extern int atm_init_aal5(struct atm_vcc *vcc); /* "raw" AAL5 transport */
19 #define PRIV(dev) ((struct atmtcp_dev_data *) ((dev)->dev_data))
22 struct atmtcp_dev_data {
23 struct atm_vcc *vcc; /* control VCC; NULL if detached */
24 int persist; /* non-zero if persistent */
25 };
28 #define DEV_LABEL "atmtcp"
30 #define MAX_VPI_BITS 8 /* simplifies life */
31 #define MAX_VCI_BITS 16
34 /*
35 * Hairy code ahead: the control VCC may be closed while we're still
36 * waiting for an answer, so we need to re-validate out_vcc every once
37 * in a while.
38 */
41 static int atmtcp_send_control(struct atm_vcc *vcc,int type,
42 const struct atmtcp_control *msg,int flag)
43 {
44 DECLARE_WAITQUEUE(wait,current);
45 struct atm_vcc *out_vcc;
46 struct sk_buff *skb;
47 struct atmtcp_control *new_msg;
48 int old_test;
49 int error = 0;
51 out_vcc = PRIV(vcc->dev) ? PRIV(vcc->dev)->vcc : NULL;
52 if (!out_vcc) return -EUNATCH;
53 skb = alloc_skb(sizeof(*msg),GFP_KERNEL);
54 if (!skb) return -ENOMEM;
55 mb();
56 out_vcc = PRIV(vcc->dev) ? PRIV(vcc->dev)->vcc : NULL;
57 if (!out_vcc) {
58 dev_kfree_skb(skb);
59 return -EUNATCH;
60 }
61 atm_force_charge(out_vcc,skb->truesize);
62 new_msg = (struct atmtcp_control *) skb_put(skb,sizeof(*new_msg));
63 *new_msg = *msg;
64 new_msg->hdr.length = ATMTCP_HDR_MAGIC;
65 new_msg->type = type;
66 memset(&new_msg->vcc,0,sizeof(atm_kptr_t));
67 *(struct atm_vcc **) &new_msg->vcc = vcc;
68 old_test = test_bit(flag,&vcc->flags);
69 out_vcc->push(out_vcc,skb);
70 add_wait_queue(sk_atm(vcc)->sk_sleep, &wait);
71 while (test_bit(flag,&vcc->flags) == old_test) {
72 mb();
73 out_vcc = PRIV(vcc->dev) ? PRIV(vcc->dev)->vcc : NULL;
74 if (!out_vcc) {
75 error = -EUNATCH;
76 break;
77 }
78 set_current_state(TASK_UNINTERRUPTIBLE);
79 schedule();
80 }
81 set_current_state(TASK_RUNNING);
82 remove_wait_queue(sk_atm(vcc)->sk_sleep, &wait);
83 return error;
84 }
87 static int atmtcp_recv_control(const struct atmtcp_control *msg)
88 {
89 struct atm_vcc *vcc = *(struct atm_vcc **) &msg->vcc;
91 vcc->vpi = msg->addr.sap_addr.vpi;
92 vcc->vci = msg->addr.sap_addr.vci;
93 vcc->qos = msg->qos;
94 sk_atm(vcc)->sk_err = -msg->result;
95 switch (msg->type) {
96 case ATMTCP_CTRL_OPEN:
97 change_bit(ATM_VF_READY,&vcc->flags);
98 break;
99 case ATMTCP_CTRL_CLOSE:
100 change_bit(ATM_VF_ADDR,&vcc->flags);
101 break;
102 default:
103 printk(KERN_ERR "atmtcp_recv_control: unknown type %d\n",
104 msg->type);
105 return -EINVAL;
106 }
107 wake_up(sk_atm(vcc)->sk_sleep);
108 return 0;
109 }
112 static void atmtcp_v_dev_close(struct atm_dev *dev)
113 {
114 /* Nothing.... Isn't this simple :-) -- REW */
115 }
118 static int atmtcp_v_open(struct atm_vcc *vcc)
119 {
120 struct atmtcp_control msg;
121 int error;
122 short vpi = vcc->vpi;
123 int vci = vcc->vci;
125 memset(&msg,0,sizeof(msg));
126 msg.addr.sap_family = AF_ATMPVC;
127 msg.hdr.vpi = htons(vpi);
128 msg.addr.sap_addr.vpi = vpi;
129 msg.hdr.vci = htons(vci);
130 msg.addr.sap_addr.vci = vci;
131 if (vpi == ATM_VPI_UNSPEC || vci == ATM_VCI_UNSPEC) return 0;
132 msg.type = ATMTCP_CTRL_OPEN;
133 msg.qos = vcc->qos;
134 set_bit(ATM_VF_ADDR,&vcc->flags);
135 clear_bit(ATM_VF_READY,&vcc->flags); /* just in case ... */
136 error = atmtcp_send_control(vcc,ATMTCP_CTRL_OPEN,&msg,ATM_VF_READY);
137 if (error) return error;
138 return -sk_atm(vcc)->sk_err;
139 }
142 static void atmtcp_v_close(struct atm_vcc *vcc)
143 {
144 struct atmtcp_control msg;
146 memset(&msg,0,sizeof(msg));
147 msg.addr.sap_family = AF_ATMPVC;
148 msg.addr.sap_addr.vpi = vcc->vpi;
149 msg.addr.sap_addr.vci = vcc->vci;
150 clear_bit(ATM_VF_READY,&vcc->flags);
151 (void) atmtcp_send_control(vcc,ATMTCP_CTRL_CLOSE,&msg,ATM_VF_ADDR);
152 }
155 static int atmtcp_v_ioctl(struct atm_dev *dev,unsigned int cmd,void __user *arg)
156 {
157 struct atm_cirange ci;
158 struct atm_vcc *vcc;
159 struct hlist_node *node;
160 struct sock *s;
161 int i;
163 if (cmd != ATM_SETCIRANGE) return -ENOIOCTLCMD;
164 if (copy_from_user(&ci, arg,sizeof(ci))) return -EFAULT;
165 if (ci.vpi_bits == ATM_CI_MAX) ci.vpi_bits = MAX_VPI_BITS;
166 if (ci.vci_bits == ATM_CI_MAX) ci.vci_bits = MAX_VCI_BITS;
167 if (ci.vpi_bits > MAX_VPI_BITS || ci.vpi_bits < 0 ||
168 ci.vci_bits > MAX_VCI_BITS || ci.vci_bits < 0) return -EINVAL;
169 read_lock(&vcc_sklist_lock);
170 for(i = 0; i < VCC_HTABLE_SIZE; ++i) {
171 struct hlist_head *head = &vcc_hash[i];
173 sk_for_each(s, node, head) {
174 vcc = atm_sk(s);
175 if (vcc->dev != dev)
176 continue;
177 if ((vcc->vpi >> ci.vpi_bits) ||
178 (vcc->vci >> ci.vci_bits)) {
179 read_unlock(&vcc_sklist_lock);
180 return -EBUSY;
181 }
182 }
183 }
184 read_unlock(&vcc_sklist_lock);
185 dev->ci_range = ci;
186 return 0;
187 }
190 static int atmtcp_v_send(struct atm_vcc *vcc,struct sk_buff *skb)
191 {
192 struct atmtcp_dev_data *dev_data;
193 struct atm_vcc *out_vcc=NULL; /* Initializer quietens GCC warning */
194 struct sk_buff *new_skb;
195 struct atmtcp_hdr *hdr;
196 int size;
198 if (vcc->qos.txtp.traffic_class == ATM_NONE) {
199 if (vcc->pop) vcc->pop(vcc,skb);
200 else dev_kfree_skb(skb);
201 return -EINVAL;
202 }
203 dev_data = PRIV(vcc->dev);
204 if (dev_data) out_vcc = dev_data->vcc;
205 if (!dev_data || !out_vcc) {
206 if (vcc->pop) vcc->pop(vcc,skb);
207 else dev_kfree_skb(skb);
208 if (dev_data) return 0;
209 atomic_inc(&vcc->stats->tx_err);
210 return -ENOLINK;
211 }
212 size = skb->len+sizeof(struct atmtcp_hdr);
213 new_skb = atm_alloc_charge(out_vcc,size,GFP_ATOMIC);
214 if (!new_skb) {
215 if (vcc->pop) vcc->pop(vcc,skb);
216 else dev_kfree_skb(skb);
217 atomic_inc(&vcc->stats->tx_err);
218 return -ENOBUFS;
219 }
220 hdr = (void *) skb_put(new_skb,sizeof(struct atmtcp_hdr));
221 hdr->vpi = htons(vcc->vpi);
222 hdr->vci = htons(vcc->vci);
223 hdr->length = htonl(skb->len);
224 memcpy(skb_put(new_skb,skb->len),skb->data,skb->len);
225 if (vcc->pop) vcc->pop(vcc,skb);
226 else dev_kfree_skb(skb);
227 out_vcc->push(out_vcc,new_skb);
228 atomic_inc(&vcc->stats->tx);
229 atomic_inc(&out_vcc->stats->rx);
230 return 0;
231 }
234 static int atmtcp_v_proc(struct atm_dev *dev,loff_t *pos,char *page)
235 {
236 struct atmtcp_dev_data *dev_data = PRIV(dev);
238 if (*pos) return 0;
239 if (!dev_data->persist) return sprintf(page,"ephemeral\n");
240 return sprintf(page,"persistent, %sconnected\n",
241 dev_data->vcc ? "" : "dis");
242 }
245 static void atmtcp_c_close(struct atm_vcc *vcc)
246 {
247 struct atm_dev *atmtcp_dev;
248 struct atmtcp_dev_data *dev_data;
250 atmtcp_dev = (struct atm_dev *) vcc->dev_data;
251 dev_data = PRIV(atmtcp_dev);
252 dev_data->vcc = NULL;
253 if (dev_data->persist) return;
254 atmtcp_dev->dev_data = NULL;
255 kfree(dev_data);
256 atm_dev_deregister(atmtcp_dev);
257 vcc->dev_data = NULL;
258 module_put(THIS_MODULE);
259 }
262 static struct atm_vcc *find_vcc(struct atm_dev *dev, short vpi, int vci)
263 {
264 struct hlist_head *head;
265 struct atm_vcc *vcc;
266 struct hlist_node *node;
267 struct sock *s;
269 head = &vcc_hash[vci & (VCC_HTABLE_SIZE -1)];
271 sk_for_each(s, node, head) {
272 vcc = atm_sk(s);
273 if (vcc->dev == dev &&
274 vcc->vci == vci && vcc->vpi == vpi &&
275 vcc->qos.rxtp.traffic_class != ATM_NONE) {
276 return vcc;
277 }
278 }
279 return NULL;
280 }
283 static int atmtcp_c_send(struct atm_vcc *vcc,struct sk_buff *skb)
284 {
285 struct atm_dev *dev;
286 struct atmtcp_hdr *hdr;
287 struct atm_vcc *out_vcc;
288 struct sk_buff *new_skb;
289 int result = 0;
291 if (!skb->len) return 0;
292 dev = vcc->dev_data;
293 hdr = (struct atmtcp_hdr *) skb->data;
294 if (hdr->length == ATMTCP_HDR_MAGIC) {
295 result = atmtcp_recv_control(
296 (struct atmtcp_control *) skb->data);
297 goto done;
298 }
299 read_lock(&vcc_sklist_lock);
300 out_vcc = find_vcc(dev, ntohs(hdr->vpi), ntohs(hdr->vci));
301 read_unlock(&vcc_sklist_lock);
302 if (!out_vcc) {
303 atomic_inc(&vcc->stats->tx_err);
304 goto done;
305 }
306 skb_pull(skb,sizeof(struct atmtcp_hdr));
307 new_skb = atm_alloc_charge(out_vcc,skb->len,GFP_KERNEL);
308 if (!new_skb) {
309 result = -ENOBUFS;
310 goto done;
311 }
312 __net_timestamp(new_skb);
313 memcpy(skb_put(new_skb,skb->len),skb->data,skb->len);
314 out_vcc->push(out_vcc,new_skb);
315 atomic_inc(&vcc->stats->tx);
316 atomic_inc(&out_vcc->stats->rx);
317 done:
318 if (vcc->pop) vcc->pop(vcc,skb);
319 else dev_kfree_skb(skb);
320 return result;
321 }
324 /*
325 * Device operations for the virtual ATM devices created by ATMTCP.
326 */
329 static struct atmdev_ops atmtcp_v_dev_ops = {
330 .dev_close = atmtcp_v_dev_close,
331 .open = atmtcp_v_open,
332 .close = atmtcp_v_close,
333 .ioctl = atmtcp_v_ioctl,
334 .send = atmtcp_v_send,
335 .proc_read = atmtcp_v_proc,
336 .owner = THIS_MODULE
337 };
340 /*
341 * Device operations for the ATMTCP control device.
342 */
345 static struct atmdev_ops atmtcp_c_dev_ops = {
346 .close = atmtcp_c_close,
347 .send = atmtcp_c_send
348 };
351 static struct atm_dev atmtcp_control_dev = {
352 .ops = &atmtcp_c_dev_ops,
353 .type = "atmtcp",
354 .number = 999,
355 .lock = SPIN_LOCK_UNLOCKED
356 };
359 static int atmtcp_create(int itf,int persist,struct atm_dev **result)
360 {
361 struct atmtcp_dev_data *dev_data;
362 struct atm_dev *dev;
364 dev_data = kmalloc(sizeof(*dev_data),GFP_KERNEL);
365 if (!dev_data)
366 return -ENOMEM;
368 dev = atm_dev_register(DEV_LABEL,&atmtcp_v_dev_ops,itf,NULL);
369 if (!dev) {
370 kfree(dev_data);
371 return itf == -1 ? -ENOMEM : -EBUSY;
372 }
373 dev->ci_range.vpi_bits = MAX_VPI_BITS;
374 dev->ci_range.vci_bits = MAX_VCI_BITS;
375 dev->dev_data = dev_data;
376 PRIV(dev)->vcc = NULL;
377 PRIV(dev)->persist = persist;
378 if (result) *result = dev;
379 return 0;
380 }
383 static int atmtcp_attach(struct atm_vcc *vcc,int itf)
384 {
385 struct atm_dev *dev;
387 dev = NULL;
388 if (itf != -1) dev = atm_dev_lookup(itf);
389 if (dev) {
390 if (dev->ops != &atmtcp_v_dev_ops) {
391 atm_dev_put(dev);
392 return -EMEDIUMTYPE;
393 }
394 if (PRIV(dev)->vcc) return -EBUSY;
395 }
396 else {
397 int error;
399 error = atmtcp_create(itf,0,&dev);
400 if (error) return error;
401 }
402 PRIV(dev)->vcc = vcc;
403 vcc->dev = &atmtcp_control_dev;
404 vcc_insert_socket(sk_atm(vcc));
405 set_bit(ATM_VF_META,&vcc->flags);
406 set_bit(ATM_VF_READY,&vcc->flags);
407 vcc->dev_data = dev;
408 (void) atm_init_aal5(vcc); /* @@@ losing AAL in transit ... */
409 vcc->stats = &atmtcp_control_dev.stats.aal5;
410 return dev->number;
411 }
414 static int atmtcp_create_persistent(int itf)
415 {
416 return atmtcp_create(itf,1,NULL);
417 }
420 static int atmtcp_remove_persistent(int itf)
421 {
422 struct atm_dev *dev;
423 struct atmtcp_dev_data *dev_data;
425 dev = atm_dev_lookup(itf);
426 if (!dev) return -ENODEV;
427 if (dev->ops != &atmtcp_v_dev_ops) {
428 atm_dev_put(dev);
429 return -EMEDIUMTYPE;
430 }
431 dev_data = PRIV(dev);
432 if (!dev_data->persist) return 0;
433 dev_data->persist = 0;
434 if (PRIV(dev)->vcc) return 0;
435 kfree(dev_data);
436 atm_dev_put(dev);
437 atm_dev_deregister(dev);
438 return 0;
439 }
441 static int atmtcp_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
442 {
443 int err = 0;
444 struct atm_vcc *vcc = ATM_SD(sock);
446 if (cmd != SIOCSIFATMTCP && cmd != ATMTCP_CREATE && cmd != ATMTCP_REMOVE)
447 return -ENOIOCTLCMD;
449 if (!capable(CAP_NET_ADMIN))
450 return -EPERM;
452 switch (cmd) {
453 case SIOCSIFATMTCP:
454 err = atmtcp_attach(vcc, (int) arg);
455 if (err >= 0) {
456 sock->state = SS_CONNECTED;
457 __module_get(THIS_MODULE);
458 }
459 break;
460 case ATMTCP_CREATE:
461 err = atmtcp_create_persistent((int) arg);
462 break;
463 case ATMTCP_REMOVE:
464 err = atmtcp_remove_persistent((int) arg);
465 break;
466 }
467 return err;
468 }
470 static struct atm_ioctl atmtcp_ioctl_ops = {
471 .owner = THIS_MODULE,
472 .ioctl = atmtcp_ioctl,
473 };
475 static __init int atmtcp_init(void)
476 {
477 register_atm_ioctl(&atmtcp_ioctl_ops);
478 return 0;
479 }
482 static void __exit atmtcp_exit(void)
483 {
484 deregister_atm_ioctl(&atmtcp_ioctl_ops);
485 }
487 MODULE_LICENSE("GPL");
488 module_init(atmtcp_init);
489 module_exit(atmtcp_exit);