net/announce.c

   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-common.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 int64_t qemu_announce_timer_step(AnnounceTimer *timer)
  19 {
  20     int64_t step;
  21
  22     step =  timer->params.initial +
  23             (timer->params.rounds - timer->round - 1) *
  24             timer->params.step;
  25
  26     if (step < 0 || step > timer->params.max) {
  27         step = timer->params.max;
  28     }
  29     timer_mod(timer->tm, qemu_clock_get_ms(timer->type) + step);
  30
  31     return step;
  32 }
  33
  34 void qemu_announce_timer_del(AnnounceTimer *timer)
  35 {
  36     if (timer->tm) {
  37         timer_del(timer->tm);
  38         timer_free(timer->tm);
  39         timer->tm = NULL;
  40     }
  41 }
  42
  43 /*
  44  * Under BQL/main thread
  45  * Reset the timer to the given parameters/type/notifier.
  46  */
  47 void qemu_announce_timer_reset(AnnounceTimer *timer,
  48                                AnnounceParameters *params,
  49                                QEMUClockType type,
  50                                QEMUTimerCB *cb,
  51                                void *opaque)
  52 {
  53     /*
  54      * We're under the BQL, so the current timer can't
  55      * be firing, so we should be able to delete it.
  56      */
  57     qemu_announce_timer_del(timer);
  58
  59     QAPI_CLONE_MEMBERS(AnnounceParameters, &timer->params, params);
  60     timer->round = params->rounds;
  61     timer->type = type;
  62     timer->tm = timer_new_ms(type, cb, opaque);
  63 }
  64
  65 #ifndef ETH_P_RARP
  66 #define ETH_P_RARP 0x8035
  67 #endif
  68 #define ARP_HTYPE_ETH 0x0001
  69 #define ARP_PTYPE_IP 0x0800
  70 #define ARP_OP_REQUEST_REV 0x3
  71
  72 static int announce_self_create(uint8_t *buf,
  73                                 uint8_t *mac_addr)
  74 {
  75     /* Ethernet header. */
  76     memset(buf, 0xff, 6);         /* destination MAC addr */
  77     memcpy(buf + 6, mac_addr, 6); /* source MAC addr */
  78     *(uint16_t *)(buf + 12) = htons(ETH_P_RARP); /* ethertype */
  79
  80     /* RARP header. */
  81     *(uint16_t *)(buf + 14) = htons(ARP_HTYPE_ETH); /* hardware addr space */
  82     *(uint16_t *)(buf + 16) = htons(ARP_PTYPE_IP); /* protocol addr space */
  83     *(buf + 18) = 6; /* hardware addr length (ethernet) */
  84     *(buf + 19) = 4; /* protocol addr length (IPv4) */
  85     *(uint16_t *)(buf + 20) = htons(ARP_OP_REQUEST_REV); /* opcode */
  86     memcpy(buf + 22, mac_addr, 6); /* source hw addr */
  87     memset(buf + 28, 0x00, 4);     /* source protocol addr */
  88     memcpy(buf + 32, mac_addr, 6); /* target hw addr */
  89     memset(buf + 38, 0x00, 4);     /* target protocol addr */
  90
  91     /* Padding to get up to 60 bytes (ethernet min packet size, minus FCS). */
  92     memset(buf + 42, 0x00, 18);
  93
  94     return 60; /* len (FCS will be added by hardware) */
  95 }
  96
  97 static void qemu_announce_self_iter(NICState *nic, void *opaque)
  98 {
  99     uint8_t buf[60];
 100     int len;
 101
 102     trace_qemu_announce_self_iter(qemu_ether_ntoa(&nic->conf->macaddr));
 103     len = announce_self_create(buf, nic->conf->macaddr.a);
 104
 105     qemu_send_packet_raw(qemu_get_queue(nic), buf, len);
 106
 107     /* if the NIC provides it's own announcement support, use it as well */
 108     if (nic->ncs->info->announce) {
 109         nic->ncs->info->announce(nic->ncs);
 110     }
 111 }
 112 static void qemu_announce_self_once(void *opaque)
 113 {
 114     AnnounceTimer *timer = (AnnounceTimer *)opaque;
 115
 116     qemu_foreach_nic(qemu_announce_self_iter, NULL);
 117
 118     if (--timer->round) {
 119         qemu_announce_timer_step(timer);
 120     } else {
 121         qemu_announce_timer_del(timer);
 122     }
 123 }
 124
 125 void qemu_announce_self(AnnounceTimer *timer, AnnounceParameters *params)
 126 {
 127     qemu_announce_timer_reset(timer, params, QEMU_CLOCK_REALTIME,
 128                               qemu_announce_self_once, timer);
 129     if (params->rounds) {
 130         qemu_announce_self_once(timer);
 131     } else {
 132         qemu_announce_timer_del(timer);
 133     }
 134 }
 135
 136 void qmp_announce_self(AnnounceParameters *params, Error **errp)
 137 {
 138     static AnnounceTimer announce_timer;
 139     qemu_announce_self(&announce_timer, params);
 140 }