?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
qdev: nuke qdev_init_chardev()
[qemu/kevin.git] / net.c
blob1944539050197d2b69ffcfc554e4ab5f204c8be2
1 /*
2 * QEMU System Emulator
3 *
4 * Copyright (c) 2003-2008 Fabrice Bellard
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24 #include "net.h"
25
26 #include "config-host.h"
27
28 #include "net/tap.h"
29 #include "net/socket.h"
30 #include "net/dump.h"
31 #include "net/slirp.h"
32 #include "net/vde.h"
33 #include "net/util.h"
34 #include "monitor.h"
35 #include "qemu-common.h"
36 #include "qemu_socket.h"
37 #include "qmp-commands.h"
38 #include "hw/qdev.h"
39 #include "iov.h"
40
41 static QTAILQ_HEAD(, VLANState) vlans;
42 static QTAILQ_HEAD(, VLANClientState) non_vlan_clients;
43
44 int default_net = 1;
45
46 /***********************************************************/
47 /* network device redirectors */
48
49 #if defined(DEBUG_NET)
50 static void hex_dump(FILE *f, const uint8_t *buf, int size)
51 {
52 int len, i, j, c;
53
54 for(i=0;i<size;i+=16) {
55 len = size - i;
56 if (len > 16)
57 len = 16;
58 fprintf(f, "%08x ", i);
59 for(j=0;j<16;j++) {
60 if (j < len)
61 fprintf(f, " %02x", buf[i+j]);
62 else
63 fprintf(f, " ");
64 }
65 fprintf(f, " ");
66 for(j=0;j<len;j++) {
67 c = buf[i+j];
68 if (c < ' ' || c > '~')
69 c = '.';
70 fprintf(f, "%c", c);
71 }
72 fprintf(f, "\n");
73 }
74 }
75 #endif
76
77 static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
78 {
79 const char *p, *p1;
80 int len;
81 p = *pp;
82 p1 = strchr(p, sep);
83 if (!p1)
84 return -1;
85 len = p1 - p;
86 p1++;
87 if (buf_size > 0) {
88 if (len > buf_size - 1)
89 len = buf_size - 1;
90 memcpy(buf, p, len);
91 buf[len] = '\0';
92 }
93 *pp = p1;
94 return 0;
95 }
96
97 int parse_host_port(struct sockaddr_in *saddr, const char *str)
98 {
99 char buf[512];
100 struct hostent *he;
101 const char *p, *r;
102 int port;
103
104 p = str;
105 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
106 return -1;
107 saddr->sin_family = AF_INET;
108 if (buf[0] == '\0') {
109 saddr->sin_addr.s_addr = 0;
110 } else {
111 if (qemu_isdigit(buf[0])) {
112 if (!inet_aton(buf, &saddr->sin_addr))
113 return -1;
114 } else {
115 if ((he = gethostbyname(buf)) == NULL)
116 return - 1;
117 saddr->sin_addr = *(struct in_addr *)he->h_addr;
118 }
119 }
120 port = strtol(p, (char **)&r, 0);
121 if (r == p)
122 return -1;
123 saddr->sin_port = htons(port);
124 return 0;
125 }
126
127 void qemu_format_nic_info_str(VLANClientState *vc, uint8_t macaddr[6])
128 {
129 snprintf(vc->info_str, sizeof(vc->info_str),
130 "model=%s,macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
131 vc->model,
132 macaddr[0], macaddr[1], macaddr[2],
133 macaddr[3], macaddr[4], macaddr[5]);
134 }
135
136 void qemu_macaddr_default_if_unset(MACAddr *macaddr)
137 {
138 static int index = 0;
139 static const MACAddr zero = { .a = { 0,0,0,0,0,0 } };
140
141 if (memcmp(macaddr, &zero, sizeof(zero)) != 0)
142 return;
143 macaddr->a[0] = 0x52;
144 macaddr->a[1] = 0x54;
145 macaddr->a[2] = 0x00;
146 macaddr->a[3] = 0x12;
147 macaddr->a[4] = 0x34;
148 macaddr->a[5] = 0x56 + index++;
149 }
150
151 static char *assign_name(VLANClientState *vc1, const char *model)
152 {
153 VLANState *vlan;
154 VLANClientState *vc;
155 char buf[256];
156 int id = 0;
157
158 QTAILQ_FOREACH(vlan, &vlans, next) {
159 QTAILQ_FOREACH(vc, &vlan->clients, next) {
160 if (vc != vc1 && strcmp(vc->model, model) == 0) {
161 id++;
162 }
163 }
164 }
165
166 QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
167 if (vc != vc1 && strcmp(vc->model, model) == 0) {
168 id++;
169 }
170 }
171
172 snprintf(buf, sizeof(buf), "%s.%d", model, id);
173
174 return g_strdup(buf);
175 }
176
177 static ssize_t qemu_deliver_packet(VLANClientState *sender,
178 unsigned flags,
179 const uint8_t *data,
180 size_t size,
181 void *opaque);
182 static ssize_t qemu_deliver_packet_iov(VLANClientState *sender,
183 unsigned flags,
184 const struct iovec *iov,
185 int iovcnt,
186 void *opaque);
187
188 VLANClientState *qemu_new_net_client(NetClientInfo *info,
189 VLANState *vlan,
190 VLANClientState *peer,
191 const char *model,
192 const char *name)
193 {
194 VLANClientState *vc;
195
196 assert(info->size >= sizeof(VLANClientState));
197
198 vc = g_malloc0(info->size);
199
200 vc->info = info;
201 vc->model = g_strdup(model);
202 if (name) {
203 vc->name = g_strdup(name);
204 } else {
205 vc->name = assign_name(vc, model);
206 }
207
208 if (vlan) {
209 assert(!peer);
210 vc->vlan = vlan;
211 QTAILQ_INSERT_TAIL(&vc->vlan->clients, vc, next);
212 } else {
213 if (peer) {
214 assert(!peer->peer);
215 vc->peer = peer;
216 peer->peer = vc;
217 }
218 QTAILQ_INSERT_TAIL(&non_vlan_clients, vc, next);
219
220 vc->send_queue = qemu_new_net_queue(qemu_deliver_packet,
221 qemu_deliver_packet_iov,
222 vc);
223 }
224
225 return vc;
226 }
227
228 NICState *qemu_new_nic(NetClientInfo *info,
229 NICConf *conf,
230 const char *model,
231 const char *name,
232 void *opaque)
233 {
234 VLANClientState *nc;
235 NICState *nic;
236
237 assert(info->type == NET_CLIENT_TYPE_NIC);
238 assert(info->size >= sizeof(NICState));
239
240 nc = qemu_new_net_client(info, conf->vlan, conf->peer, model, name);
241
242 nic = DO_UPCAST(NICState, nc, nc);
243 nic->conf = conf;
244 nic->opaque = opaque;
245
246 return nic;
247 }
248
249 static void qemu_cleanup_vlan_client(VLANClientState *vc)
250 {
251 if (vc->vlan) {
252 QTAILQ_REMOVE(&vc->vlan->clients, vc, next);
253 } else {
254 QTAILQ_REMOVE(&non_vlan_clients, vc, next);
255 }
256
257 if (vc->info->cleanup) {
258 vc->info->cleanup(vc);
259 }
260 }
261
262 static void qemu_free_vlan_client(VLANClientState *vc)
263 {
264 if (!vc->vlan) {
265 if (vc->send_queue) {
266 qemu_del_net_queue(vc->send_queue);
267 }
268 if (vc->peer) {
269 vc->peer->peer = NULL;
270 }
271 }
272 g_free(vc->name);
273 g_free(vc->model);
274 g_free(vc);
275 }
276
277 void qemu_del_vlan_client(VLANClientState *vc)
278 {
279 /* If there is a peer NIC, delete and cleanup client, but do not free. */
280 if (!vc->vlan && vc->peer && vc->peer->info->type == NET_CLIENT_TYPE_NIC) {
281 NICState *nic = DO_UPCAST(NICState, nc, vc->peer);
282 if (nic->peer_deleted) {
283 return;
284 }
285 nic->peer_deleted = true;
286 /* Let NIC know peer is gone. */
287 vc->peer->link_down = true;
288 if (vc->peer->info->link_status_changed) {
289 vc->peer->info->link_status_changed(vc->peer);
290 }
291 qemu_cleanup_vlan_client(vc);
292 return;
293 }
294
295 /* If this is a peer NIC and peer has already been deleted, free it now. */
296 if (!vc->vlan && vc->peer && vc->info->type == NET_CLIENT_TYPE_NIC) {
297 NICState *nic = DO_UPCAST(NICState, nc, vc);
298 if (nic->peer_deleted) {
299 qemu_free_vlan_client(vc->peer);
300 }
301 }
302
303 qemu_cleanup_vlan_client(vc);
304 qemu_free_vlan_client(vc);
305 }
306
307 VLANClientState *
308 qemu_find_vlan_client_by_name(Monitor *mon, int vlan_id,
309 const char *client_str)
310 {
311 VLANState *vlan;
312 VLANClientState *vc;
313
314 vlan = qemu_find_vlan(vlan_id, 0);
315 if (!vlan) {
316 monitor_printf(mon, "unknown VLAN %d\n", vlan_id);
317 return NULL;
318 }
319
320 QTAILQ_FOREACH(vc, &vlan->clients, next) {
321 if (!strcmp(vc->name, client_str)) {
322 break;
323 }
324 }
325 if (!vc) {
326 monitor_printf(mon, "can't find device %s on VLAN %d\n",
327 client_str, vlan_id);
328 }
329
330 return vc;
331 }
332
333 void qemu_foreach_nic(qemu_nic_foreach func, void *opaque)
334 {
335 VLANClientState *nc;
336 VLANState *vlan;
337
338 QTAILQ_FOREACH(nc, &non_vlan_clients, next) {
339 if (nc->info->type == NET_CLIENT_TYPE_NIC) {
340 func(DO_UPCAST(NICState, nc, nc), opaque);
341 }
342 }
343
344 QTAILQ_FOREACH(vlan, &vlans, next) {
345 QTAILQ_FOREACH(nc, &vlan->clients, next) {
346 if (nc->info->type == NET_CLIENT_TYPE_NIC) {
347 func(DO_UPCAST(NICState, nc, nc), opaque);
348 }
349 }
350 }
351 }
352
353 int qemu_can_send_packet(VLANClientState *sender)
354 {
355 VLANState *vlan = sender->vlan;
356 VLANClientState *vc;
357
358 if (sender->peer) {
359 if (sender->peer->receive_disabled) {
360 return 0;
361 } else if (sender->peer->info->can_receive &&
362 !sender->peer->info->can_receive(sender->peer)) {
363 return 0;
364 } else {
365 return 1;
366 }
367 }
368
369 if (!sender->vlan) {
370 return 1;
371 }
372
373 QTAILQ_FOREACH(vc, &vlan->clients, next) {
374 if (vc == sender) {
375 continue;
376 }
377
378 /* no can_receive() handler, they can always receive */
379 if (vc->info->can_receive && !vc->info->can_receive(vc)) {
380 return 0;
381 }
382 }
383 return 1;
384 }
385
386 static ssize_t qemu_deliver_packet(VLANClientState *sender,
387 unsigned flags,
388 const uint8_t *data,
389 size_t size,
390 void *opaque)
391 {
392 VLANClientState *vc = opaque;
393 ssize_t ret;
394
395 if (vc->link_down) {
396 return size;
397 }
398
399 if (vc->receive_disabled) {
400 return 0;
401 }
402
403 if (flags & QEMU_NET_PACKET_FLAG_RAW && vc->info->receive_raw) {
404 ret = vc->info->receive_raw(vc, data, size);
405 } else {
406 ret = vc->info->receive(vc, data, size);
407 }
408
409 if (ret == 0) {
410 vc->receive_disabled = 1;
411 };
412
413 return ret;
414 }
415
416 static ssize_t qemu_vlan_deliver_packet(VLANClientState *sender,
417 unsigned flags,
418 const uint8_t *buf,
419 size_t size,
420 void *opaque)
421 {
422 VLANState *vlan = opaque;
423 VLANClientState *vc;
424 ssize_t ret = -1;
425
426 QTAILQ_FOREACH(vc, &vlan->clients, next) {
427 ssize_t len;
428
429 if (vc == sender) {
430 continue;
431 }
432
433 if (vc->link_down) {
434 ret = size;
435 continue;
436 }
437
438 if (vc->receive_disabled) {
439 ret = 0;
440 continue;
441 }
442
443 if (flags & QEMU_NET_PACKET_FLAG_RAW && vc->info->receive_raw) {
444 len = vc->info->receive_raw(vc, buf, size);
445 } else {
446 len = vc->info->receive(vc, buf, size);
447 }
448
449 if (len == 0) {
450 vc->receive_disabled = 1;
451 }
452
453 ret = (ret >= 0) ? ret : len;
454
455 }
456
457 return ret;
458 }
459
460 void qemu_purge_queued_packets(VLANClientState *vc)
461 {
462 NetQueue *queue;
463
464 if (!vc->peer && !vc->vlan) {
465 return;
466 }
467
468 if (vc->peer) {
469 queue = vc->peer->send_queue;
470 } else {
471 queue = vc->vlan->send_queue;
472 }
473
474 qemu_net_queue_purge(queue, vc);
475 }
476
477 void qemu_flush_queued_packets(VLANClientState *vc)
478 {
479 NetQueue *queue;
480
481 vc->receive_disabled = 0;
482
483 if (vc->vlan) {
484 queue = vc->vlan->send_queue;
485 } else {
486 queue = vc->send_queue;
487 }
488
489 qemu_net_queue_flush(queue);
490 }
491
492 static ssize_t qemu_send_packet_async_with_flags(VLANClientState *sender,
493 unsigned flags,
494 const uint8_t *buf, int size,
495 NetPacketSent *sent_cb)
496 {
497 NetQueue *queue;
498
499 #ifdef DEBUG_NET
500 printf("qemu_send_packet_async:\n");
501 hex_dump(stdout, buf, size);
502 #endif
503
504 if (sender->link_down || (!sender->peer && !sender->vlan)) {
505 return size;
506 }
507
508 if (sender->peer) {
509 queue = sender->peer->send_queue;
510 } else {
511 queue = sender->vlan->send_queue;
512 }
513
514 return qemu_net_queue_send(queue, sender, flags, buf, size, sent_cb);
515 }
516
517 ssize_t qemu_send_packet_async(VLANClientState *sender,
518 const uint8_t *buf, int size,
519 NetPacketSent *sent_cb)
520 {
521 return qemu_send_packet_async_with_flags(sender, QEMU_NET_PACKET_FLAG_NONE,
522 buf, size, sent_cb);
523 }
524
525 void qemu_send_packet(VLANClientState *vc, const uint8_t *buf, int size)
526 {
527 qemu_send_packet_async(vc, buf, size, NULL);
528 }
529
530 ssize_t qemu_send_packet_raw(VLANClientState *vc, const uint8_t *buf, int size)
531 {
532 return qemu_send_packet_async_with_flags(vc, QEMU_NET_PACKET_FLAG_RAW,
533 buf, size, NULL);
534 }
535
536 static ssize_t vc_sendv_compat(VLANClientState *vc, const struct iovec *iov,
537 int iovcnt)
538 {
539 uint8_t buffer[4096];
540 size_t offset;
541
542 offset = iov_to_buf(iov, iovcnt, buffer, 0, sizeof(buffer));
543
544 return vc->info->receive(vc, buffer, offset);
545 }
546
547 static ssize_t qemu_deliver_packet_iov(VLANClientState *sender,
548 unsigned flags,
549 const struct iovec *iov,
550 int iovcnt,
551 void *opaque)
552 {
553 VLANClientState *vc = opaque;
554
555 if (vc->link_down) {
556 return iov_size(iov, iovcnt);
557 }
558
559 if (vc->info->receive_iov) {
560 return vc->info->receive_iov(vc, iov, iovcnt);
561 } else {
562 return vc_sendv_compat(vc, iov, iovcnt);
563 }
564 }
565
566 static ssize_t qemu_vlan_deliver_packet_iov(VLANClientState *sender,
567 unsigned flags,
568 const struct iovec *iov,
569 int iovcnt,
570 void *opaque)
571 {
572 VLANState *vlan = opaque;
573 VLANClientState *vc;
574 ssize_t ret = -1;
575
576 QTAILQ_FOREACH(vc, &vlan->clients, next) {
577 ssize_t len;
578
579 if (vc == sender) {
580 continue;
581 }
582
583 if (vc->link_down) {
584 ret = iov_size(iov, iovcnt);
585 continue;
586 }
587
588 assert(!(flags & QEMU_NET_PACKET_FLAG_RAW));
589
590 if (vc->info->receive_iov) {
591 len = vc->info->receive_iov(vc, iov, iovcnt);
592 } else {
593 len = vc_sendv_compat(vc, iov, iovcnt);
594 }
595
596 ret = (ret >= 0) ? ret : len;
597 }
598
599 return ret;
600 }
601
602 ssize_t qemu_sendv_packet_async(VLANClientState *sender,
603 const struct iovec *iov, int iovcnt,
604 NetPacketSent *sent_cb)
605 {
606 NetQueue *queue;
607
608 if (sender->link_down || (!sender->peer && !sender->vlan)) {
609 return iov_size(iov, iovcnt);
610 }
611
612 if (sender->peer) {
613 queue = sender->peer->send_queue;
614 } else {
615 queue = sender->vlan->send_queue;
616 }
617
618 return qemu_net_queue_send_iov(queue, sender,
619 QEMU_NET_PACKET_FLAG_NONE,
620 iov, iovcnt, sent_cb);
621 }
622
623 ssize_t
624 qemu_sendv_packet(VLANClientState *vc, const struct iovec *iov, int iovcnt)
625 {
626 return qemu_sendv_packet_async(vc, iov, iovcnt, NULL);
627 }
628
629 /* find or alloc a new VLAN */
630 VLANState *qemu_find_vlan(int id, int allocate)
631 {
632 VLANState *vlan;
633
634 QTAILQ_FOREACH(vlan, &vlans, next) {
635 if (vlan->id == id) {
636 return vlan;
637 }
638 }
639
640 if (!allocate) {
641 return NULL;
642 }
643
644 vlan = g_malloc0(sizeof(VLANState));
645 vlan->id = id;
646 QTAILQ_INIT(&vlan->clients);
647
648 vlan->send_queue = qemu_new_net_queue(qemu_vlan_deliver_packet,
649 qemu_vlan_deliver_packet_iov,
650 vlan);
651
652 QTAILQ_INSERT_TAIL(&vlans, vlan, next);
653
654 return vlan;
655 }
656
657 VLANClientState *qemu_find_netdev(const char *id)
658 {
659 VLANClientState *vc;
660
661 QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
662 if (vc->info->type == NET_CLIENT_TYPE_NIC)
663 continue;
664 if (!strcmp(vc->name, id)) {
665 return vc;
666 }
667 }
668
669 return NULL;
670 }
671
672 static int nic_get_free_idx(void)
673 {
674 int index;
675
676 for (index = 0; index < MAX_NICS; index++)
677 if (!nd_table[index].used)
678 return index;
679 return -1;
680 }
681
682 int qemu_show_nic_models(const char *arg, const char *const *models)
683 {
684 int i;
685
686 if (!arg || strcmp(arg, "?"))
687 return 0;
688
689 fprintf(stderr, "qemu: Supported NIC models: ");
690 for (i = 0 ; models[i]; i++)
691 fprintf(stderr, "%s%c", models[i], models[i+1] ? ',' : '\n');
692 return 1;
693 }
694
695 void qemu_check_nic_model(NICInfo *nd, const char *model)
696 {
697 const char *models[2];
698
699 models[0] = model;
700 models[1] = NULL;
701
702 if (qemu_show_nic_models(nd->model, models))
703 exit(0);
704 if (qemu_find_nic_model(nd, models, model) < 0)
705 exit(1);
706 }
707
708 int qemu_find_nic_model(NICInfo *nd, const char * const *models,
709 const char *default_model)
710 {
711 int i;
712
713 if (!nd->model)
714 nd->model = g_strdup(default_model);
715
716 for (i = 0 ; models[i]; i++) {
717 if (strcmp(nd->model, models[i]) == 0)
718 return i;
719 }
720
721 error_report("Unsupported NIC model: %s", nd->model);
722 return -1;
723 }
724
725 int net_handle_fd_param(Monitor *mon, const char *param)
726 {
727 int fd;
728
729 if (!qemu_isdigit(param[0]) && mon) {
730
731 fd = monitor_get_fd(mon, param);
732 if (fd == -1) {
733 error_report("No file descriptor named %s found", param);
734 return -1;
735 }
736 } else {
737 fd = qemu_parse_fd(param);
738 }
739
740 return fd;
741 }
742
743 static int net_init_nic(QemuOpts *opts,
744 Monitor *mon,
745 const char *name,
746 VLANState *vlan)
747 {
748 int idx;
749 NICInfo *nd;
750 const char *netdev;
751
752 idx = nic_get_free_idx();
753 if (idx == -1 || nb_nics >= MAX_NICS) {
754 error_report("Too Many NICs");
755 return -1;
756 }
757
758 nd = &nd_table[idx];
759
760 memset(nd, 0, sizeof(*nd));
761
762 if ((netdev = qemu_opt_get(opts, "netdev"))) {
763 nd->netdev = qemu_find_netdev(netdev);
764 if (!nd->netdev) {
765 error_report("netdev '%s' not found", netdev);
766 return -1;
767 }
768 } else {
769 assert(vlan);
770 nd->vlan = vlan;
771 }
772 if (name) {
773 nd->name = g_strdup(name);
774 }
775 if (qemu_opt_get(opts, "model")) {
776 nd->model = g_strdup(qemu_opt_get(opts, "model"));
777 }
778 if (qemu_opt_get(opts, "addr")) {
779 nd->devaddr = g_strdup(qemu_opt_get(opts, "addr"));
780 }
781
782 if (qemu_opt_get(opts, "macaddr") &&
783 net_parse_macaddr(nd->macaddr.a, qemu_opt_get(opts, "macaddr")) < 0) {
784 error_report("invalid syntax for ethernet address");
785 return -1;
786 }
787 qemu_macaddr_default_if_unset(&nd->macaddr);
788
789 nd->nvectors = qemu_opt_get_number(opts, "vectors",
790 DEV_NVECTORS_UNSPECIFIED);
791 if (nd->nvectors != DEV_NVECTORS_UNSPECIFIED &&
792 (nd->nvectors < 0 || nd->nvectors > 0x7ffffff)) {
793 error_report("invalid # of vectors: %d", nd->nvectors);
794 return -1;
795 }
796
797 nd->used = 1;
798 nb_nics++;
799
800 return idx;
801 }
802
803 #define NET_COMMON_PARAMS_DESC \
804 { \
805 .name = "type", \
806 .type = QEMU_OPT_STRING, \
807 .help = "net client type (nic, tap etc.)", \
808 }, { \
809 .name = "vlan", \
810 .type = QEMU_OPT_NUMBER, \
811 .help = "vlan number", \
812 }, { \
813 .name = "name", \
814 .type = QEMU_OPT_STRING, \
815 .help = "identifier for monitor commands", \
816 }
817
818 typedef int (*net_client_init_func)(QemuOpts *opts,
819 Monitor *mon,
820 const char *name,
821 VLANState *vlan);
822
823 /* magic number, but compiler will warn if too small */
824 #define NET_MAX_DESC 20
825
826 static const struct {
827 const char *type;
828 net_client_init_func init;
829 QemuOptDesc desc[NET_MAX_DESC];
830 } net_client_types[NET_CLIENT_TYPE_MAX] = {
831 [NET_CLIENT_TYPE_NONE] = {
832 .type = "none",
833 .desc = {
834 NET_COMMON_PARAMS_DESC,
835 { /* end of list */ }
836 },
837 },
838 [NET_CLIENT_TYPE_NIC] = {
839 .type = "nic",
840 .init = net_init_nic,
841 .desc = {
842 NET_COMMON_PARAMS_DESC,
843 {
844 .name = "netdev",
845 .type = QEMU_OPT_STRING,
846 .help = "id of -netdev to connect to",
847 },
848 {
849 .name = "macaddr",
850 .type = QEMU_OPT_STRING,
851 .help = "MAC address",
852 }, {
853 .name = "model",
854 .type = QEMU_OPT_STRING,
855 .help = "device model (e1000, rtl8139, virtio etc.)",
856 }, {
857 .name = "addr",
858 .type = QEMU_OPT_STRING,
859 .help = "PCI device address",
860 }, {
861 .name = "vectors",
862 .type = QEMU_OPT_NUMBER,
863 .help = "number of MSI-x vectors, 0 to disable MSI-X",
864 },
865 { /* end of list */ }
866 },
867 },
868 #ifdef CONFIG_SLIRP
869 [NET_CLIENT_TYPE_USER] = {
870 .type = "user",
871 .init = net_init_slirp,
872 .desc = {
873 NET_COMMON_PARAMS_DESC,
874 {
875 .name = "hostname",
876 .type = QEMU_OPT_STRING,
877 .help = "client hostname reported by the builtin DHCP server",
878 }, {
879 .name = "restrict",
880 .type = QEMU_OPT_STRING,
881 .help = "isolate the guest from the host (y|yes|n|no)",
882 }, {
883 .name = "ip",
884 .type = QEMU_OPT_STRING,
885 .help = "legacy parameter, use net= instead",
886 }, {
887 .name = "net",
888 .type = QEMU_OPT_STRING,
889 .help = "IP address and optional netmask",
890 }, {
891 .name = "host",
892 .type = QEMU_OPT_STRING,
893 .help = "guest-visible address of the host",
894 }, {
895 .name = "tftp",
896 .type = QEMU_OPT_STRING,
897 .help = "root directory of the built-in TFTP server",
898 }, {
899 .name = "bootfile",
900 .type = QEMU_OPT_STRING,
901 .help = "BOOTP filename, for use with tftp=",
902 }, {
903 .name = "dhcpstart",
904 .type = QEMU_OPT_STRING,
905 .help = "the first of the 16 IPs the built-in DHCP server can assign",
906 }, {
907 .name = "dns",
908 .type = QEMU_OPT_STRING,
909 .help = "guest-visible address of the virtual nameserver",
910 }, {
911 .name = "smb",
912 .type = QEMU_OPT_STRING,
913 .help = "root directory of the built-in SMB server",
914 }, {
915 .name = "smbserver",
916 .type = QEMU_OPT_STRING,
917 .help = "IP address of the built-in SMB server",
918 }, {
919 .name = "hostfwd",
920 .type = QEMU_OPT_STRING,
921 .help = "guest port number to forward incoming TCP or UDP connections",
922 }, {
923 .name = "guestfwd",
924 .type = QEMU_OPT_STRING,
925 .help = "IP address and port to forward guest TCP connections",
926 },
927 { /* end of list */ }
928 },
929 },
930 #endif
931 [NET_CLIENT_TYPE_TAP] = {
932 .type = "tap",
933 .init = net_init_tap,
934 .desc = {
935 NET_COMMON_PARAMS_DESC,
936 {
937 .name = "ifname",
938 .type = QEMU_OPT_STRING,
939 .help = "interface name",
940 },
941 #ifndef _WIN32
942 {
943 .name = "fd",
944 .type = QEMU_OPT_STRING,
945 .help = "file descriptor of an already opened tap",
946 }, {
947 .name = "script",
948 .type = QEMU_OPT_STRING,
949 .help = "script to initialize the interface",
950 }, {
951 .name = "downscript",
952 .type = QEMU_OPT_STRING,
953 .help = "script to shut down the interface",
954 }, {
955 .name = "helper",
956 .type = QEMU_OPT_STRING,
957 .help = "command to execute to configure bridge",
958 }, {
959 .name = "sndbuf",
960 .type = QEMU_OPT_SIZE,
961 .help = "send buffer limit"
962 }, {
963 .name = "vnet_hdr",
964 .type = QEMU_OPT_BOOL,
965 .help = "enable the IFF_VNET_HDR flag on the tap interface"
966 }, {
967 .name = "vhost",
968 .type = QEMU_OPT_BOOL,
969 .help = "enable vhost-net network accelerator",
970 }, {
971 .name = "vhostfd",
972 .type = QEMU_OPT_STRING,
973 .help = "file descriptor of an already opened vhost net device",
974 }, {
975 .name = "vhostforce",
976 .type = QEMU_OPT_BOOL,
977 .help = "force vhost on for non-MSIX virtio guests",
978 },
979 #endif /* _WIN32 */
980 { /* end of list */ }
981 },
982 },
983 [NET_CLIENT_TYPE_SOCKET] = {
984 .type = "socket",
985 .init = net_init_socket,
986 .desc = {
987 NET_COMMON_PARAMS_DESC,
988 {
989 .name = "fd",
990 .type = QEMU_OPT_STRING,
991 .help = "file descriptor of an already opened socket",
992 }, {
993 .name = "listen",
994 .type = QEMU_OPT_STRING,
995 .help = "port number, and optional hostname, to listen on",
996 }, {
997 .name = "connect",
998 .type = QEMU_OPT_STRING,
999 .help = "port number, and optional hostname, to connect to",
1000 }, {
1001 .name = "mcast",
1002 .type = QEMU_OPT_STRING,
1003 .help = "UDP multicast address and port number",
1004 }, {
1005 .name = "localaddr",
1006 .type = QEMU_OPT_STRING,
1007 .help = "source address and port for multicast and udp packets",
1008 }, {
1009 .name = "udp",
1010 .type = QEMU_OPT_STRING,
1011 .help = "UDP unicast address and port number",
1012 },
1013 { /* end of list */ }
1014 },
1015 },
1016 #ifdef CONFIG_VDE
1017 [NET_CLIENT_TYPE_VDE] = {
1018 .type = "vde",
1019 .init = net_init_vde,
1020 .desc = {
1021 NET_COMMON_PARAMS_DESC,
1022 {
1023 .name = "sock",
1024 .type = QEMU_OPT_STRING,
1025 .help = "socket path",
1026 }, {
1027 .name = "port",
1028 .type = QEMU_OPT_NUMBER,
1029 .help = "port number",
1030 }, {
1031 .name = "group",
1032 .type = QEMU_OPT_STRING,
1033 .help = "group owner of socket",
1034 }, {
1035 .name = "mode",
1036 .type = QEMU_OPT_NUMBER,
1037 .help = "permissions for socket",
1038 },
1039 { /* end of list */ }
1040 },
1041 },
1042 #endif
1043 [NET_CLIENT_TYPE_DUMP] = {
1044 .type = "dump",
1045 .init = net_init_dump,
1046 .desc = {
1047 NET_COMMON_PARAMS_DESC,
1048 {
1049 .name = "len",
1050 .type = QEMU_OPT_SIZE,
1051 .help = "per-packet size limit (64k default)",
1052 }, {
1053 .name = "file",
1054 .type = QEMU_OPT_STRING,
1055 .help = "dump file path (default is qemu-vlan0.pcap)",
1056 },
1057 { /* end of list */ }
1058 },
1059 },
1060 [NET_CLIENT_TYPE_BRIDGE] = {
1061 .type = "bridge",
1062 .init = net_init_bridge,
1063 .desc = {
1064 NET_COMMON_PARAMS_DESC,
1065 {
1066 .name = "br",
1067 .type = QEMU_OPT_STRING,
1068 .help = "bridge name",
1069 }, {
1070 .name = "helper",
1071 .type = QEMU_OPT_STRING,
1072 .help = "command to execute to configure bridge",
1073 },
1074 { /* end of list */ }
1075 },
1076 },
1077 };
1078
1079 int net_client_init(Monitor *mon, QemuOpts *opts, int is_netdev)
1080 {
1081 const char *name;
1082 const char *type;
1083 int i;
1084
1085 type = qemu_opt_get(opts, "type");
1086 if (!type) {
1087 qerror_report(QERR_MISSING_PARAMETER, "type");
1088 return -1;
1089 }
1090
1091 if (is_netdev) {
1092 if (strcmp(type, "tap") != 0 &&
1093 #ifdef CONFIG_SLIRP
1094 strcmp(type, "user") != 0 &&
1095 #endif
1096 #ifdef CONFIG_VDE
1097 strcmp(type, "vde") != 0 &&
1098 #endif
1099 strcmp(type, "socket") != 0 &&
1100 strcmp(type, "bridge") != 0) {
1101 qerror_report(QERR_INVALID_PARAMETER_VALUE, "type",
1102 "a netdev backend type");
1103 return -1;
1104 }
1105
1106 if (qemu_opt_get(opts, "vlan")) {
1107 qerror_report(QERR_INVALID_PARAMETER, "vlan");
1108 return -1;
1109 }
1110 if (qemu_opt_get(opts, "name")) {
1111 qerror_report(QERR_INVALID_PARAMETER, "name");
1112 return -1;
1113 }
1114 if (!qemu_opts_id(opts)) {
1115 qerror_report(QERR_MISSING_PARAMETER, "id");
1116 return -1;
1117 }
1118 }
1119
1120 name = qemu_opts_id(opts);
1121 if (!name) {
1122 name = qemu_opt_get(opts, "name");
1123 }
1124
1125 for (i = 0; i < NET_CLIENT_TYPE_MAX; i++) {
1126 if (net_client_types[i].type != NULL &&
1127 !strcmp(net_client_types[i].type, type)) {
1128 VLANState *vlan = NULL;
1129 int ret;
1130
1131 if (qemu_opts_validate(opts, &net_client_types[i].desc[0]) == -1) {
1132 return -1;
1133 }
1134
1135 /* Do not add to a vlan if it's a -netdev or a nic with a
1136 * netdev= parameter. */
1137 if (!(is_netdev ||
1138 (strcmp(type, "nic") == 0 && qemu_opt_get(opts, "netdev")))) {
1139 vlan = qemu_find_vlan(qemu_opt_get_number(opts, "vlan", 0), 1);
1140 }
1141
1142 ret = 0;
1143 if (net_client_types[i].init) {
1144 ret = net_client_types[i].init(opts, mon, name, vlan);
1145 if (ret < 0) {
1146 /* TODO push error reporting into init() methods */
1147 qerror_report(QERR_DEVICE_INIT_FAILED, type);
1148 return -1;
1149 }
1150 }
1151 return ret;
1152 }
1153 }
1154
1155 qerror_report(QERR_INVALID_PARAMETER_VALUE, "type",
1156 "a network client type");
1157 return -1;
1158 }
1159
1160 static int net_host_check_device(const char *device)
1161 {
1162 int i;
1163 const char *valid_param_list[] = { "tap", "socket", "dump"
1164 #ifdef CONFIG_SLIRP
1165 ,"user"
1166 #endif
1167 #ifdef CONFIG_VDE
1168 ,"vde"
1169 #endif
1170 , "bridge"
1171 };
1172 for (i = 0; i < sizeof(valid_param_list) / sizeof(char *); i++) {
1173 if (!strncmp(valid_param_list[i], device,
1174 strlen(valid_param_list[i])))
1175 return 1;
1176 }
1177
1178 return 0;
1179 }
1180
1181 void net_host_device_add(Monitor *mon, const QDict *qdict)
1182 {
1183 const char *device = qdict_get_str(qdict, "device");
1184 const char *opts_str = qdict_get_try_str(qdict, "opts");
1185 QemuOpts *opts;
1186
1187 if (!net_host_check_device(device)) {
1188 monitor_printf(mon, "invalid host network device %s\n", device);
1189 return;
1190 }
1191
1192 opts = qemu_opts_parse(qemu_find_opts("net"), opts_str ? opts_str : "", 0);
1193 if (!opts) {
1194 return;
1195 }
1196
1197 qemu_opt_set(opts, "type", device);
1198
1199 if (net_client_init(mon, opts, 0) < 0) {
1200 monitor_printf(mon, "adding host network device %s failed\n", device);
1201 }
1202 }
1203
1204 void net_host_device_remove(Monitor *mon, const QDict *qdict)
1205 {
1206 VLANClientState *vc;
1207 int vlan_id = qdict_get_int(qdict, "vlan_id");
1208 const char *device = qdict_get_str(qdict, "device");
1209
1210 vc = qemu_find_vlan_client_by_name(mon, vlan_id, device);
1211 if (!vc) {
1212 return;
1213 }
1214 if (!net_host_check_device(vc->model)) {
1215 monitor_printf(mon, "invalid host network device %s\n", device);
1216 return;
1217 }
1218 qemu_del_vlan_client(vc);
1219 }
1220
1221 int do_netdev_add(Monitor *mon, const QDict *qdict, QObject **ret_data)
1222 {
1223 QemuOpts *opts;
1224 int res;
1225
1226 opts = qemu_opts_from_qdict(qemu_find_opts("netdev"), qdict);
1227 if (!opts) {
1228 return -1;
1229 }
1230
1231 res = net_client_init(mon, opts, 1);
1232 if (res < 0) {
1233 qemu_opts_del(opts);
1234 }
1235
1236 return res;
1237 }
1238
1239 int do_netdev_del(Monitor *mon, const QDict *qdict, QObject **ret_data)
1240 {
1241 const char *id = qdict_get_str(qdict, "id");
1242 VLANClientState *vc;
1243
1244 vc = qemu_find_netdev(id);
1245 if (!vc) {
1246 qerror_report(QERR_DEVICE_NOT_FOUND, id);
1247 return -1;
1248 }
1249 qemu_del_vlan_client(vc);
1250 qemu_opts_del(qemu_opts_find(qemu_find_opts("netdev"), id));
1251 return 0;
1252 }
1253
1254 static void print_net_client(Monitor *mon, VLANClientState *vc)
1255 {
1256 monitor_printf(mon, "%s: type=%s,%s\n", vc->name,
1257 net_client_types[vc->info->type].type, vc->info_str);
1258 }
1259
1260 void do_info_network(Monitor *mon)
1261 {
1262 VLANState *vlan;
1263 VLANClientState *vc, *peer;
1264 net_client_type type;
1265
1266 QTAILQ_FOREACH(vlan, &vlans, next) {
1267 monitor_printf(mon, "VLAN %d devices:\n", vlan->id);
1268
1269 QTAILQ_FOREACH(vc, &vlan->clients, next) {
1270 monitor_printf(mon, " ");
1271 print_net_client(mon, vc);
1272 }
1273 }
1274 monitor_printf(mon, "Devices not on any VLAN:\n");
1275 QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
1276 peer = vc->peer;
1277 type = vc->info->type;
1278 if (!peer || type == NET_CLIENT_TYPE_NIC) {
1279 monitor_printf(mon, " ");
1280 print_net_client(mon, vc);
1281 } /* else it's a netdev connected to a NIC, printed with the NIC */
1282 if (peer && type == NET_CLIENT_TYPE_NIC) {
1283 monitor_printf(mon, " \\ ");
1284 print_net_client(mon, peer);
1285 }
1286 }
1287 }
1288
1289 void qmp_set_link(const char *name, bool up, Error **errp)
1290 {
1291 VLANState *vlan;
1292 VLANClientState *vc = NULL;
1293
1294 QTAILQ_FOREACH(vlan, &vlans, next) {
1295 QTAILQ_FOREACH(vc, &vlan->clients, next) {
1296 if (strcmp(vc->name, name) == 0) {
1297 goto done;
1298 }
1299 }
1300 }
1301 QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
1302 if (!strcmp(vc->name, name)) {
1303 goto done;
1304 }
1305 }
1306 done:
1307
1308 if (!vc) {
1309 error_set(errp, QERR_DEVICE_NOT_FOUND, name);
1310 return;
1311 }
1312
1313 vc->link_down = !up;
1314
1315 if (vc->info->link_status_changed) {
1316 vc->info->link_status_changed(vc);
1317 }
1318
1319 /* Notify peer. Don't update peer link status: this makes it possible to
1320 * disconnect from host network without notifying the guest.
1321 * FIXME: is disconnected link status change operation useful?
1322 *
1323 * Current behaviour is compatible with qemu vlans where there could be
1324 * multiple clients that can still communicate with each other in
1325 * disconnected mode. For now maintain this compatibility. */
1326 if (vc->peer && vc->peer->info->link_status_changed) {
1327 vc->peer->info->link_status_changed(vc->peer);
1328 }
1329 }
1330
1331 void net_cleanup(void)
1332 {
1333 VLANState *vlan;
1334 VLANClientState *vc, *next_vc;
1335
1336 QTAILQ_FOREACH(vlan, &vlans, next) {
1337 QTAILQ_FOREACH_SAFE(vc, &vlan->clients, next, next_vc) {
1338 qemu_del_vlan_client(vc);
1339 }
1340 }
1341
1342 QTAILQ_FOREACH_SAFE(vc, &non_vlan_clients, next, next_vc) {
1343 qemu_del_vlan_client(vc);
1344 }
1345 }
1346
1347 void net_check_clients(void)
1348 {
1349 VLANState *vlan;
1350 VLANClientState *vc;
1351 int i;
1352
1353 /* Don't warn about the default network setup that you get if
1354 * no command line -net or -netdev options are specified. There
1355 * are two cases that we would otherwise complain about:
1356 * (1) board doesn't support a NIC but the implicit "-net nic"
1357 * requested one
1358 * (2) CONFIG_SLIRP not set, in which case the implicit "-net nic"
1359 * sets up a nic that isn't connected to anything.
1360 */
1361 if (default_net) {
1362 return;
1363 }
1364
1365 QTAILQ_FOREACH(vlan, &vlans, next) {
1366 int has_nic = 0, has_host_dev = 0;
1367
1368 QTAILQ_FOREACH(vc, &vlan->clients, next) {
1369 switch (vc->info->type) {
1370 case NET_CLIENT_TYPE_NIC:
1371 has_nic = 1;
1372 break;
1373 case NET_CLIENT_TYPE_USER:
1374 case NET_CLIENT_TYPE_TAP:
1375 case NET_CLIENT_TYPE_SOCKET:
1376 case NET_CLIENT_TYPE_VDE:
1377 has_host_dev = 1;
1378 break;
1379 default: ;
1380 }
1381 }
1382 if (has_host_dev && !has_nic)
1383 fprintf(stderr, "Warning: vlan %d with no nics\n", vlan->id);
1384 if (has_nic && !has_host_dev)
1385 fprintf(stderr,
1386 "Warning: vlan %d is not connected to host network\n",
1387 vlan->id);
1388 }
1389 QTAILQ_FOREACH(vc, &non_vlan_clients, next) {
1390 if (!vc->peer) {
1391 fprintf(stderr, "Warning: %s %s has no peer\n",
1392 vc->info->type == NET_CLIENT_TYPE_NIC ? "nic" : "netdev",
1393 vc->name);
1394 }
1395 }
1396
1397 /* Check that all NICs requested via -net nic actually got created.
1398 * NICs created via -device don't need to be checked here because
1399 * they are always instantiated.
1400 */
1401 for (i = 0; i < MAX_NICS; i++) {
1402 NICInfo *nd = &nd_table[i];
1403 if (nd->used && !nd->instantiated) {
1404 fprintf(stderr, "Warning: requested NIC (%s, model %s) "
1405 "was not created (not supported by this machine?)\n",
1406 nd->name ? nd->name : "anonymous",
1407 nd->model ? nd->model : "unspecified");
1408 }
1409 }
1410 }
1411
1412 static int net_init_client(QemuOpts *opts, void *dummy)
1413 {
1414 if (net_client_init(NULL, opts, 0) < 0)
1415 return -1;
1416 return 0;
1417 }
1418
1419 static int net_init_netdev(QemuOpts *opts, void *dummy)
1420 {
1421 return net_client_init(NULL, opts, 1);
1422 }
1423
1424 int net_init_clients(void)
1425 {
1426 QemuOptsList *net = qemu_find_opts("net");
1427
1428 if (default_net) {
1429 /* if no clients, we use a default config */
1430 qemu_opts_set(net, NULL, "type", "nic");
1431 #ifdef CONFIG_SLIRP
1432 qemu_opts_set(net, NULL, "type", "user");
1433 #endif
1434 }
1435
1436 QTAILQ_INIT(&vlans);
1437 QTAILQ_INIT(&non_vlan_clients);
1438
1439 if (qemu_opts_foreach(qemu_find_opts("netdev"), net_init_netdev, NULL, 1) == -1)
1440 return -1;
1441
1442 if (qemu_opts_foreach(net, net_init_client, NULL, 1) == -1) {
1443 return -1;
1444 }
1445
1446 return 0;
1447 }
1448
1449 int net_client_parse(QemuOptsList *opts_list, const char *optarg)
1450 {
1451 #if defined(CONFIG_SLIRP)
1452 int ret;
1453 if (net_slirp_parse_legacy(opts_list, optarg, &ret)) {
1454 return ret;
1455 }
1456 #endif
1457
1458 if (!qemu_opts_parse(opts_list, optarg, 1)) {
1459 return -1;
1460 }
1461
1462 default_net = 0;
1463 return 0;
1464 }
Random patches