Revert "Replace ff_data interval parameter with automatic generation from remote"
authorHenning Rogge <henning.rogge@fkie.fraunhofer.de>
Wed, 1 Feb 2017 12:38:47 +0000 (13:38 +0100)
committerHenning Rogge <henning.rogge@fkie.fraunhofer.de>
Wed, 1 Feb 2017 12:38:47 +0000 (13:38 +0100)
This reverts commit e768e59c5222aec72656ad9ec67a72d6c19f60a9.

src-plugins/nhdp/ff_dat_metric/ff_dat_metric.c
src-plugins/nhdp/hysteresis_olsrv1/hysteresis_olsrv1.c
src-plugins/nhdp/nhdp/nhdp_db.c
src-plugins/nhdp/nhdp/nhdp_db.h
src-plugins/nhdp/nhdp/nhdp_reader.c

index 38e1700..2105d07 100644 (file)
@@ -75,6 +75,9 @@ enum {
  * Configuration settings of DATFF Metric
  */
 struct ff_dat_if_config {
+  /*! Interval between two updates of the metric */
+  uint64_t interval;
+
   /*! true if metric should include link speed */
   bool ett;
 
@@ -87,6 +90,9 @@ struct ff_dat_if_config {
   /*! true if metric should include unicast into calculation */
   bool accept_unicast;
 
+  /*! timer for sampling interface data */
+  struct oonf_timer_instance _sampling_timer;
+
   /*! true if we registered the interface */
   bool registered;
 };
@@ -113,9 +119,6 @@ struct link_datff_data {
   /*! timer for measuring lost hellos when no further packets are received */
   struct oonf_timer_instance hello_lost_timer;
 
-  /*! timer for sampling interface data */
-  struct oonf_timer_instance sampling_timer;
-
   /*! back pointer to NHDP link */
   struct nhdp_link *nhdp_link;
 
@@ -156,6 +159,9 @@ static void _cb_link_added(void *);
 static void _cb_link_changed(void *);
 static void _cb_link_removed(void *);
 
+static void _cb_nhdpif_added(void *);
+static void _cb_nhdpif_removed(void *);
+
 static void _cb_dat_sampling(struct oonf_timer_instance *);
 static void _calculate_link_neighborhood(struct nhdp_link *lnk,
     struct link_datff_data *ldata);
@@ -210,6 +216,8 @@ static const char *LOSS_SCALING[] = {
 };
 
 static struct cfg_schema_entry _datff_entries[] = {
+  CFG_MAP_CLOCK_MIN(ff_dat_if_config, interval, "ffdat_interval", "1.0",
+      "Time interval between recalculations of metric", 100),
   CFG_MAP_BOOL(ff_dat_if_config, ett, "ffdat_airtime", "true",
       "Activates the handling of linkspeed within the metric, set to false to"
       " downgrade to ETX metric"),
@@ -277,6 +285,9 @@ static struct oonf_class_extension _nhdpif_extenstion = {
   .ext_name = "datff linkmetric",
   .class_name = NHDP_CLASS_INTERFACE,
   .size = sizeof(struct ff_dat_if_config),
+
+  .cb_add = _cb_nhdpif_added,
+  .cb_remove = _cb_nhdpif_removed,
 };
 
 /* timer for sampling in RFC5444 packets */
@@ -385,8 +396,12 @@ _cleanup(void) {
  */
 static void
 _cb_enable_metric(void) {
+  struct nhdp_interface *nhdpif;
   struct nhdp_link *lnk;
 
+  avl_for_each_element(nhdp_interface_get_tree(), nhdpif, _node) {
+    _cb_nhdpif_added(nhdpif);
+  }
   list_for_each_element(nhdp_db_get_link_list(), lnk, _global_node) {
     _cb_link_added(lnk);
   }
@@ -399,6 +414,7 @@ _cb_enable_metric(void) {
  */
 static void
 _cb_disable_metric(void) {
+  struct nhdp_interface *nhdpif;
   struct nhdp_link *lnk;
 
   rfc5444_reader_remove_packet_consumer(&_protocol->reader, &_packet_consumer);
@@ -406,6 +422,9 @@ _cb_disable_metric(void) {
   list_for_each_element(nhdp_db_get_link_list(), lnk, _global_node) {
     _cb_link_removed(lnk);
   }
+  avl_for_each_element(nhdp_interface_get_tree(), nhdpif, _node) {
+    _cb_nhdpif_removed(nhdpif);
+  }
 }
 
 /**
@@ -422,16 +441,15 @@ _cb_link_added(void *ptr) {
   data = oonf_class_get_extension(&_link_extenstion, lnk);
 
   memset(data, 0, sizeof(*data));
-  data->nhdp_link = lnk;
+  // data->contains_data = false;
 
   for (i = 0; i<ARRAYSIZE(data->buckets); i++) {
     data->buckets[i].total = 1;
     // data->buckets[i].scaled_speed = 0;
   }
 
-  /* initialize 'hello lost' and 'sampling' timer for link */
+  /* initialize 'hello lost' timer for link */
   data->hello_lost_timer.class = &_hello_lost_info;
-  data->sampling_timer.class = &_sampling_timer_info;
 
   if (lnk->itime_value > 0) {
     data->hello_interval = lnk->itime_value;
@@ -455,13 +473,10 @@ static void
 _cb_link_changed(void *ptr) {
   struct link_datff_data *data;
   struct nhdp_link *lnk;
-  uint64_t old_interval;
 
   lnk = ptr;
   data = oonf_class_get_extension(&_link_extenstion, lnk);
 
-  old_interval = data->hello_interval;
-
   if (lnk->itime_value > 0) {
     data->hello_interval = lnk->itime_value;
   }
@@ -469,9 +484,6 @@ _cb_link_changed(void *ptr) {
     data->hello_interval = lnk->vtime_value;
   }
 
-  if (old_interval != data->hello_interval) {
-    oonf_timer_set(&data->sampling_timer, data->hello_interval);
-  }
   _reset_missed_hello_timer(data);
 }
 
@@ -486,7 +498,27 @@ _cb_link_removed(void *ptr) {
   data = oonf_class_get_extension(&_link_extenstion, ptr);
 
   oonf_timer_stop(&data->hello_lost_timer);
-  oonf_timer_stop(&data->sampling_timer);
+}
+
+static void
+_cb_nhdpif_added(void *ptr) {
+  struct ff_dat_if_config *ifconfig;
+
+  ifconfig = oonf_class_get_extension(&_nhdpif_extenstion, ptr);
+
+  ifconfig->_sampling_timer.class = &_sampling_timer_info;
+}
+
+static void
+_cb_nhdpif_removed(void *ptr) {
+  struct ff_dat_if_config *ifconfig;
+
+  ifconfig = oonf_class_get_extension(&_nhdpif_extenstion, ptr);
+
+  if (ifconfig->_sampling_timer.class) {
+    oonf_timer_stop(&ifconfig->_sampling_timer);
+    ifconfig->_sampling_timer.class = NULL;
+  }
 }
 
 /**
@@ -606,114 +638,125 @@ _cb_dat_sampling(struct oonf_timer_instance *ptr) {
   uint32_t missing_intervals;
   size_t i;
   int rx_bitrate;
+  bool change_happened;
 
   struct netaddr_str nbuf;
 
-  ldata = container_of(ptr, struct link_datff_data, sampling_timer);
-
-  lnk = ldata->nhdp_link;
-  ifconfig = oonf_class_get_extension(&_nhdpif_extenstion, lnk->local_if);
+  ifconfig = container_of(ptr, struct ff_dat_if_config, _sampling_timer);
 
   OONF_DEBUG(LOG_FF_DAT, "Calculate Metric from sampled data");
 
-  if (!ldata->contains_data) {
-    /* still no data for this link */
-    return;
-  }
-
-  /* initialize counter */
-  total = 0;
-  received = 0;
+  change_happened = false;
 
-  /* calculate metric */
-  for (i=0; i<ARRAYSIZE(ldata->buckets); i++) {
-    received += ldata->buckets[i].received;
-    total += ldata->buckets[i].total;
-  }
+  list_for_each_element(nhdp_db_get_link_list(), lnk, _global_node) {
+    if (oonf_class_get_extension(&_nhdpif_extenstion, lnk->local_if) != ifconfig) {
+      continue;
+    }
 
-  if (ldata->missed_hellos > 0) {
-    missing_intervals = (ldata->missed_hellos * ldata->hello_interval)
-        / (lnk->local_if->refresh_interval / 2);
-    if (missing_intervals > ARRAYSIZE(ldata->buckets)) {
-      received = 0;
+    ldata = oonf_class_get_extension(&_link_extenstion, lnk);
+    if (!ldata->contains_data) {
+      /* still no data for this link */
+      continue;
     }
-    else {
-      received = (received * (ARRAYSIZE(ldata->buckets) - missing_intervals))
-          / ARRAYSIZE(ldata->buckets);
+
+    /* initialize counter */
+    total = 0;
+    received = 0;
+
+    /* calculate metric */
+    for (i=0; i<ARRAYSIZE(ldata->buckets); i++) {
+      received += ldata->buckets[i].received;
+      total += ldata->buckets[i].total;
     }
-  }
 
-  /* update link speed */
-  ldata->buckets[ldata->activePtr].scaled_speed = _get_scaled_rx_linkspeed(ifconfig, lnk);
+    if (ldata->missed_hellos > 0) {
+      missing_intervals = (ldata->missed_hellos * ldata->hello_interval)
+          / ifconfig->interval;
+      if (missing_intervals > ARRAYSIZE(ldata->buckets)) {
+        received = 0;
+      }
+      else {
+        received = (received * (ARRAYSIZE(ldata->buckets) - missing_intervals))
+            / ARRAYSIZE(ldata->buckets);
+      }
+    }
 
-  OONF_DEBUG(LOG_FF_DAT, "Query incoming linkspeed for link %s: %"PRIu64,
-      netaddr_to_string(&nbuf, &lnk->if_addr),
-      (uint64_t)(ldata->buckets[ldata->activePtr].scaled_speed) * DATFF_LINKSPEED_MINIMUM);
+    /* update link speed */
+    ldata->buckets[ldata->activePtr].scaled_speed = _get_scaled_rx_linkspeed(ifconfig, lnk);
 
-  /* get median scaled link speed and apply it to metric */
-  rx_bitrate = _get_median_rx_linkspeed(ldata);
-  if (rx_bitrate > DATFF_LINKSPEED_RANGE) {
-    OONF_WARN(LOG_FF_DAT, "Metric overflow %s (%s): %d",
+    OONF_DEBUG(LOG_FF_DAT, "Query incoming linkspeed for link %s: %"PRIu64,
         netaddr_to_string(&nbuf, &lnk->if_addr),
-        nhdp_interface_get_name(lnk->local_if), rx_bitrate);
-    metric = 1;
-  }
-  else {
-    metric = DATFF_LINKSPEED_RANGE / rx_bitrate;
-  }
+        (uint64_t)(ldata->buckets[ldata->activePtr].scaled_speed) * DATFF_LINKSPEED_MINIMUM);
+
+    /* get median scaled link speed and apply it to metric */
+    rx_bitrate = _get_median_rx_linkspeed(ldata);
+    if (rx_bitrate > DATFF_LINKSPEED_RANGE) {
+      OONF_WARN(LOG_FF_DAT, "Metric overflow %s (%s): %d",
+          netaddr_to_string(&nbuf, &lnk->if_addr),
+          nhdp_interface_get_name(lnk->local_if), rx_bitrate);
+      metric = 1;
+    }
+    else {
+      metric = DATFF_LINKSPEED_RANGE / rx_bitrate;
+    }
 
-  /* calculate frame loss, use discrete values */
-  if (total == 0 || received == 0
-      || received * DATFF_FRAME_SUCCESS_RANGE <= total) {
-    metric *= DATFF_FRAME_SUCCESS_RANGE;
-  }
-  else {
-    metric = _apply_packet_loss(ifconfig, lnk, ldata, metric, received, total);
-  }
+    /* calculate frame loss, use discrete values */
+    if (total == 0 || received == 0
+        || received * DATFF_FRAME_SUCCESS_RANGE <= total) {
+      metric *= DATFF_FRAME_SUCCESS_RANGE;
+    }
+    else {
+      metric = _apply_packet_loss(ifconfig, lnk, ldata, metric, received, total);
+    }
 
-  /* convert into something that can be transmitted over the network */
-  if (metric > RFC7181_METRIC_MAX) {
-    /* give the metric an upper bound */
-    OONF_INFO(LOG_FF_DAT, "Metric overflow %s (%s): %"PRIu64,
-        netaddr_to_string(&nbuf, &lnk->if_addr),
-        nhdp_interface_get_name(lnk->local_if), metric);
-    metric_value = RFC7181_METRIC_MAX;
-  }
-  else if (metric < RFC7181_METRIC_MIN) {
-    OONF_WARN(LOG_FF_DAT, "Metric underflow %s (%s): %"PRIu64,
-        netaddr_to_string(&nbuf, &lnk->if_addr),
-        nhdp_interface_get_name(lnk->local_if), metric);
-    metric_value = RFC7181_METRIC_MIN;
-  }
-  else if(!rfc7181_metric_encode(&encoded_metric, metric)) {
-    metric_value = rfc7181_metric_decode(&encoded_metric);
-  }
-  else {
-    /* metric encoding failed */
-    OONF_WARN(LOG_FF_DAT, "Metric encoding failed for link %s (%s): %"PRIu64,
+    /* convert into something that can be transmitted over the network */
+    if (metric > RFC7181_METRIC_MAX) {
+      /* give the metric an upper bound */
+      OONF_INFO(LOG_FF_DAT, "Metric overflow %s (%s): %"PRIu64,
+          netaddr_to_string(&nbuf, &lnk->if_addr),
+          nhdp_interface_get_name(lnk->local_if), metric);
+      metric_value = RFC7181_METRIC_MAX;
+    }
+    else if (metric < RFC7181_METRIC_MIN) {
+      OONF_WARN(LOG_FF_DAT, "Metric underflow %s (%s): %"PRIu64,
+          netaddr_to_string(&nbuf, &lnk->if_addr),
+          nhdp_interface_get_name(lnk->local_if), metric);
+      metric_value = RFC7181_METRIC_MIN;
+    }
+    else if(!rfc7181_metric_encode(&encoded_metric, metric)) {
+      metric_value = rfc7181_metric_decode(&encoded_metric);
+    }
+    else {
+      /* metric encoding failed */
+      OONF_WARN(LOG_FF_DAT, "Metric encoding failed for link %s (%s): %"PRIu64,
+          netaddr_to_string(&nbuf, &lnk->if_addr),
+          nhdp_interface_get_name(lnk->local_if), metric);
+      metric_value = RFC7181_METRIC_MAX;
+    }
+
+    /* set metric for incoming link */
+    change_happened |= nhdp_domain_set_incoming_metric(
+        &_datff_handler, lnk, metric_value);
+
+    OONF_DEBUG(LOG_FF_DAT, "New sampling rate for link %s (%s):"
+        " %d/%d = %u (speed=%"PRIu64 ")\n",
         netaddr_to_string(&nbuf, &lnk->if_addr),
-        nhdp_interface_get_name(lnk->local_if), metric);
-    metric_value = RFC7181_METRIC_MAX;
-  }
+        nhdp_interface_get_name(lnk->local_if),
+        received, total, metric_value, (uint64_t)(rx_bitrate) * DATFF_LINKSPEED_MINIMUM);
 
-  /* set metric for incoming link */
-  if (nhdp_domain_set_incoming_metric(&_datff_handler, lnk, metric_value)) {
-    nhdp_domain_neighbor_changed(lnk->neigh);
+    /* update rolling buffer */
+    ldata->activePtr++;
+    if (ldata->activePtr >= ARRAYSIZE(ldata->buckets)) {
+      ldata->activePtr = 0;
+    }
+    ldata->buckets[ldata->activePtr].received = 0;
+    ldata->buckets[ldata->activePtr].total = 0;
   }
 
-  OONF_DEBUG(LOG_FF_DAT, "New sampling rate for link %s (%s):"
-      " %d/%d = %u (speed=%"PRIu64 ")\n",
-      netaddr_to_string(&nbuf, &lnk->if_addr),
-      nhdp_interface_get_name(lnk->local_if),
-      received, total, metric_value, (uint64_t)(rx_bitrate) * DATFF_LINKSPEED_MINIMUM);
-
-  /* update rolling buffer */
-  ldata->activePtr++;
-  if (ldata->activePtr >= ARRAYSIZE(ldata->buckets)) {
-    ldata->activePtr = 0;
+  /* update neighbor metrics */
+  if (change_happened) {
+    nhdp_domain_neighborhood_changed();
   }
-  ldata->buckets[ldata->activePtr].received = 0;
-  ldata->buckets[ldata->activePtr].total = 0;
 }
 
 /**
@@ -1105,4 +1148,26 @@ _cb_cfg_changed(void) {
         OONF_FF_DAT_METRIC_SUBSYSTEM);
     return;
   }
+
+  /* start/change sampling timer */
+  oonf_timer_set(&ifconfig->_sampling_timer, ifconfig->interval);
+
+#ifdef COLLECT_RAW_DATA
+  if (_rawdata_fd != -1) {
+    fsync(_rawdata_fd);
+    close(_rawdata_fd);
+    _rawdata_end = 0;
+    _rawdata_count = 0;
+  }
+
+  if (_datff_config.rawdata_start) {
+    _rawdata_fd = open(_datff_config.rawdata_file, O_CREAT | O_TRUNC | O_WRONLY,
+               S_IRUSR|S_IWUSR);
+    if (_rawdata_fd != -1) {
+      abuf_clear(&_rawdata_buf);
+      abuf_appendf(&_rawdata_buf, "Time: %s\n", oonf_log_get_walltime());
+      _rawdata_end = oonf_clock_get_absolute(_datff_config.rawdata_maxtime);
+    }
+  }
+#endif
 }
index 7554712..e2106f6 100644 (file)
@@ -243,14 +243,14 @@ _update_hysteresis(struct nhdp_link *lnk,
   if (!data->pending && !data->lost) {
     if (data->quality < _hysteresis_config.reject) {
       data->lost = true;
-      nhdp_db_link_update_status(lnk, false);
+      nhdp_db_link_update_status(lnk);
     }
   }
   else {
     if (data->quality > _hysteresis_config.accept) {
       data->pending = false;
       data->lost = false;
-      nhdp_db_link_update_status(lnk, false);
+      nhdp_db_link_update_status(lnk);
     }
   }
 }
index 3996298..a99fd53 100644 (file)
@@ -808,10 +808,9 @@ nhdp_db_link_disconnect_dualstack(struct nhdp_link *lnk) {
  * Recalculate the status of a nhdp link and update database
  * if link changed between symmetric and non-symmetric
  * @param lnk nhdp link with (potential) new status
- * @param force true to force a change event
  */
 void
-nhdp_db_link_update_status(struct nhdp_link *lnk, bool force) {
+nhdp_db_link_update_status(struct nhdp_link *lnk) {
   enum nhdp_link_status old_status;
   bool was_symmetric;
 
@@ -834,7 +833,7 @@ nhdp_db_link_update_status(struct nhdp_link *lnk, bool force) {
     nhdp_interface_update_status(lnk->local_if);
   }
 
-  if (force || old_status != lnk->status) {
+  if (old_status != lnk->status) {
     /* link status was changed */
     lnk->last_status_change = oonf_clock_getNow();
 
@@ -999,7 +998,7 @@ _cb_link_heard(struct oonf_timer_instance *ptr) {
 
   lnk = container_of(ptr, struct nhdp_link, heard_time);
   OONF_DEBUG(LOG_NHDP, "Link heard fired: 0x%0zx", (size_t)lnk);
-  nhdp_db_link_update_status(lnk, false);
+  nhdp_db_link_update_status(lnk);
 }
 
 /**
@@ -1012,7 +1011,7 @@ _cb_link_symtime(struct oonf_timer_instance *ptr) {
 
   lnk = container_of(ptr, struct nhdp_link, sym_time);
   OONF_DEBUG(LOG_NHDP, "Link Symtime fired: 0x%0zx", (size_t)lnk);
-  nhdp_db_link_update_status(lnk, false);
+  nhdp_db_link_update_status(lnk);
   nhdp_domain_neighbor_changed(lnk->neigh);
 }
 
index c1a47b8..f18920d 100644 (file)
@@ -382,7 +382,7 @@ EXPORT void nhdp_db_link_connect_dualstack(struct nhdp_link *ipv4, struct nhdp_l
 EXPORT void nhdp_db_link_disconnect_dualstack(struct nhdp_link *lnk);
 
 EXPORT int _nhdp_db_link_calculate_status(struct nhdp_link *lnk);
-EXPORT void nhdp_db_link_update_status(struct nhdp_link *, bool force);
+EXPORT void nhdp_db_link_update_status(struct nhdp_link *);
 
 EXPORT const char *nhdp_db_link_status_to_string(struct nhdp_link *);
 
@@ -464,7 +464,7 @@ static INLINE void
 nhdp_db_link_set_symtime(
     struct nhdp_link *lnk, uint64_t stime) {
   oonf_timer_set(&lnk->sym_time, stime);
-  nhdp_db_link_update_status(lnk, false);
+  nhdp_db_link_update_status(lnk);
 }
 
 /**
index def3ef5..589dd82 100644 (file)
@@ -191,8 +191,6 @@ static struct {
 
   uint8_t mprtypes[NHDP_MAXIMUM_DOMAINS];
   size_t mprtypes_size;
-
-  bool timings_changed;
 } _current;
 
 /**
@@ -667,9 +665,6 @@ _cb_addresstlvs_pass1_end(struct rfc5444_reader_tlvblock_context *context, bool
   }
 
   /* remember vtime and itime */
-  _current.timings_changed = _current.link->vtime_value != _current.vtime;
-  _current.timings_changed |= _current.link->itime_value != _current.itime;
-
   _current.link->vtime_value = _current.vtime;
   _current.link->itime_value = _current.itime;
 
@@ -982,7 +977,7 @@ _cb_msg_pass2_end(struct rfc5444_reader_tlvblock_context *context, bool dropped)
   nhdp_interface_update_status(_current.localif);
 
   /* update link status */
-  nhdp_db_link_update_status(_current.link, _current.timings_changed);
+  nhdp_db_link_update_status(_current.link);
 
   return RFC5444_OKAY;
 }