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