xref: /openbmc/qemu/net/announce.c (revision 69242e7e)
1 /*
2  *  Self-announce
3  *  (c) 2017-2019 Red Hat, Inc.
4  *
5  * This work is licensed under the terms of the GNU GPL, version 2 or later.
6  * See the COPYING file in the top-level directory.
7  */
8 
9 #include "qemu/osdep.h"
10 #include "qemu/cutils.h"
11 #include "net/announce.h"
12 #include "net/net.h"
13 #include "qapi/clone-visitor.h"
14 #include "qapi/qapi-visit-net.h"
15 #include "qapi/qapi-commands-net.h"
16 #include "trace.h"
17 
18 static GData *named_timers;
19 
20 int64_t qemu_announce_timer_step(AnnounceTimer *timer)
21 {
22     int64_t step;
23 
24     step =  timer->params.initial +
25             (timer->params.rounds - timer->round - 1) *
26             timer->params.step;
27 
28     if (step < 0 || step > timer->params.max) {
29         step = timer->params.max;
30     }
31     timer_mod(timer->tm, qemu_clock_get_ms(timer->type) + step);
32 
33     return step;
34 }
35 
36 /*
37  * If 'free_named' is true, then remove the timer from the list
38  * and free the timer itself.
39  */
40 void qemu_announce_timer_del(AnnounceTimer *timer, bool free_named)
41 {
42     bool free_timer = false;
43     if (timer->tm) {
44         timer_free(timer->tm);
45         timer->tm = NULL;
46     }
47     qapi_free_strList(timer->params.interfaces);
48     timer->params.interfaces = NULL;
49     if (free_named && timer->params.has_id) {
50         AnnounceTimer *list_timer;
51         /*
52          * Sanity check: There should only be one timer on the list with
53          * the id.
54          */
55         list_timer = g_datalist_get_data(&named_timers, timer->params.id);
56         assert(timer == list_timer);
57         free_timer = true;
58         g_datalist_remove_data(&named_timers, timer->params.id);
59     }
60     trace_qemu_announce_timer_del(free_named, free_timer, timer->params.id);
61     g_free(timer->params.id);
62     timer->params.id = NULL;
63 
64     if (free_timer) {
65         g_free(timer);
66     }
67 }
68 
69 /*
70  * Under BQL/main thread
71  * Reset the timer to the given parameters/type/notifier.
72  */
73 void qemu_announce_timer_reset(AnnounceTimer *timer,
74                                AnnounceParameters *params,
75                                QEMUClockType type,
76                                QEMUTimerCB *cb,
77                                void *opaque)
78 {
79     /*
80      * We're under the BQL, so the current timer can't
81      * be firing, so we should be able to delete it.
82      */
83     qemu_announce_timer_del(timer, false);
84 
85     QAPI_CLONE_MEMBERS(AnnounceParameters, &timer->params, params);
86     timer->round = params->rounds;
87     timer->type = type;
88     timer->tm = timer_new_ms(type, cb, opaque);
89 }
90 
91 #ifndef ETH_P_RARP
92 #define ETH_P_RARP 0x8035
93 #endif
94 #define ARP_HTYPE_ETH 0x0001
95 #define ARP_PTYPE_IP 0x0800
96 #define ARP_OP_REQUEST_REV 0x3
97 
98 static int announce_self_create(uint8_t *buf,
99                                 uint8_t *mac_addr)
100 {
101     /* Ethernet header. */
102     memset(buf, 0xff, 6);         /* destination MAC addr */
103     memcpy(buf + 6, mac_addr, 6); /* source MAC addr */
104     *(uint16_t *)(buf + 12) = htons(ETH_P_RARP); /* ethertype */
105 
106     /* RARP header. */
107     *(uint16_t *)(buf + 14) = htons(ARP_HTYPE_ETH); /* hardware addr space */
108     *(uint16_t *)(buf + 16) = htons(ARP_PTYPE_IP); /* protocol addr space */
109     *(buf + 18) = 6; /* hardware addr length (ethernet) */
110     *(buf + 19) = 4; /* protocol addr length (IPv4) */
111     *(uint16_t *)(buf + 20) = htons(ARP_OP_REQUEST_REV); /* opcode */
112     memcpy(buf + 22, mac_addr, 6); /* source hw addr */
113     memset(buf + 28, 0x00, 4);     /* source protocol addr */
114     memcpy(buf + 32, mac_addr, 6); /* target hw addr */
115     memset(buf + 38, 0x00, 4);     /* target protocol addr */
116 
117     /* Padding to get up to 60 bytes (ethernet min packet size, minus FCS). */
118     memset(buf + 42, 0x00, 18);
119 
120     return 60; /* len (FCS will be added by hardware) */
121 }
122 
123 /*
124  * Helper to print ethernet mac address
125  */
126 static const char *qemu_ether_ntoa(const MACAddr *mac)
127 {
128     static char ret[18];
129 
130     snprintf(ret, sizeof(ret), "%02x:%02x:%02x:%02x:%02x:%02x",
131              mac->a[0], mac->a[1], mac->a[2], mac->a[3], mac->a[4], mac->a[5]);
132 
133     return ret;
134 }
135 
136 static void qemu_announce_self_iter(NICState *nic, void *opaque)
137 {
138     AnnounceTimer *timer = opaque;
139     uint8_t buf[60];
140     int len;
141     bool skip;
142 
143     if (timer->params.has_interfaces) {
144         strList *entry = timer->params.interfaces;
145         /* Skip unless we find our name in the requested list */
146         skip = true;
147 
148         while (entry) {
149             if (!strcmp(entry->value, nic->ncs->name)) {
150                 /* Found us */
151                 skip = false;
152                 break;
153             }
154             entry = entry->next;
155         }
156     } else {
157         skip = false;
158     }
159 
160     trace_qemu_announce_self_iter(timer->params.has_id ? timer->params.id : "_",
161                                   nic->ncs->name,
162                                   qemu_ether_ntoa(&nic->conf->macaddr), skip);
163 
164     if (!skip) {
165         len = announce_self_create(buf, nic->conf->macaddr.a);
166 
167         qemu_send_packet_raw(qemu_get_queue(nic), buf, len);
168 
169         /* if the NIC provides it's own announcement support, use it as well */
170         if (nic->ncs->info->announce) {
171             nic->ncs->info->announce(nic->ncs);
172         }
173     }
174 }
175 static void qemu_announce_self_once(void *opaque)
176 {
177     AnnounceTimer *timer = (AnnounceTimer *)opaque;
178 
179     qemu_foreach_nic(qemu_announce_self_iter, timer);
180 
181     if (--timer->round) {
182         qemu_announce_timer_step(timer);
183     } else {
184         qemu_announce_timer_del(timer, true);
185     }
186 }
187 
188 void qemu_announce_self(AnnounceTimer *timer, AnnounceParameters *params)
189 {
190     qemu_announce_timer_reset(timer, params, QEMU_CLOCK_REALTIME,
191                               qemu_announce_self_once, timer);
192     if (params->rounds) {
193         qemu_announce_self_once(timer);
194     } else {
195         qemu_announce_timer_del(timer, true);
196     }
197 }
198 
199 void qmp_announce_self(AnnounceParameters *params, Error **errp)
200 {
201     AnnounceTimer *named_timer;
202     if (!params->has_id) {
203         params->id = g_strdup("");
204         params->has_id = true;
205     }
206 
207     named_timer = g_datalist_get_data(&named_timers, params->id);
208 
209     if (!named_timer) {
210         named_timer = g_new0(AnnounceTimer, 1);
211         g_datalist_set_data(&named_timers, params->id, named_timer);
212     }
213 
214     qemu_announce_self(named_timer, params);
215 }
216