VNFs/DPPD-PROX/run.c

   1 /*
   2 // Copyright (c) 2010-2017 Intel Corporation
   3 //
   4 // Licensed under the Apache License, Version 2.0 (the "License");
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //     http://www.apache.org/licenses/LICENSE-2.0
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an "AS IS" BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15 */
  16
  17 #include <inttypes.h>
  18 #include <string.h>
  19
  20 #include <rte_launch.h>
  21 #include <rte_cycles.h>
  22 #include <rte_atomic.h>
  23
  24 #include "run.h"
  25 #include "prox_cfg.h"
  26 #include "prox_port_cfg.h"
  27 #include "quit.h"
  28 #include "commands.h"
  29 #include "main.h"
  30 #include "log.h"
  31 #include "display.h"
  32 #include "stats.h"
  33 #include "stats_cons.h"
  34 #include "stats_cons_log.h"
  35 #include "stats_cons_cli.h"
  36
  37 #include "input.h"
  38 #include "input_curses.h"
  39 #include "input_conn.h"
  40 #include "handle_master.h"
  41
  42 static int needs_refresh;
  43 static uint64_t update_interval;
  44 static int stop_prox = 0; /* set to 1 to stop prox */
  45
  46 void set_update_interval(uint32_t msec)
  47 {
  48         update_interval = msec_to_tsc(msec);
  49 }
  50
  51 void req_refresh(void)
  52 {
  53         needs_refresh = 1;
  54 }
  55
  56 void quit(void)
  57 {
  58         static rte_atomic32_t already_leaving = RTE_ATOMIC32_INIT(0);
  59         if (!rte_atomic32_test_and_set(&already_leaving))
  60                 return;
  61
  62         plog_info("Leaving...\n");
  63         if (lcore_cfg == NULL)
  64                 exit(EXIT_SUCCESS);
  65         stop_core_all(-1);
  66         stop_prox = 1;
  67 }
  68
  69 static void update_link_states(void)
  70 {
  71         struct prox_port_cfg *port_cfg;
  72         struct rte_eth_link link;
  73
  74         for (uint8_t portid = 0; portid < PROX_MAX_PORTS; ++portid) {
  75                 if (!prox_port_cfg[portid].active) {
  76                         continue;
  77                 }
  78
  79                 port_cfg  = &prox_port_cfg[portid];
  80                 rte_eth_link_get_nowait(portid, &link);
  81 #if RTE_VERSION < RTE_VERSION_NUM(16,4,0,0)
  82                 // On more recent DPDK, we use the speed_capa of the port, and not the negotiated speed
  83                 port_cfg->link_speed = link.link_speed;
  84 #endif
  85                 if (port_cfg->link_up != link.link_status) {
  86                         port_cfg->link_up = link.link_status;
  87                         plog_info("port %d: Link speed now %d Mbps\n", portid, link.link_speed);
  88                 }
  89         }
  90 }
  91
  92 static struct stats_cons stats_cons[8];
  93 static size_t n_stats_cons = 0;
  94 static uint16_t stats_cons_flags = 0;
  95
  96 static void stats_cons_add(struct stats_cons *sc)
  97 {
  98         if (n_stats_cons == sizeof(stats_cons)/sizeof(stats_cons[0]))
  99                 return;
 100
 101         stats_cons[n_stats_cons++] = *sc;
 102         sc->init();
 103         stats_cons_flags |= sc->flags;
 104 }
 105
 106 static void stats_cons_notify(void)
 107 {
 108         for (size_t i = 0; i < n_stats_cons; ++i) {
 109                 stats_cons[i].notify();
 110         }
 111 }
 112
 113 static void stats_cons_refresh(void)
 114 {
 115         for (size_t i = 0; i < n_stats_cons; ++i) {
 116                 if (stats_cons[i].refresh)
 117                         stats_cons[i].refresh();
 118         }
 119 }
 120
 121 static void stats_cons_finish(void)
 122 {
 123         for (size_t i = 0; i < n_stats_cons; ++i) {
 124                 if (stats_cons[i].finish)
 125                         stats_cons[i].finish();
 126         }
 127 }
 128
 129 static void busy_wait_until(uint64_t deadline)
 130 {
 131         while (rte_rdtsc() < deadline)
 132                 ;
 133 }
 134
 135 static void multiplexed_input_stats(uint64_t deadline)
 136 {
 137         if (deadline)
 138                 input_proc_until(deadline);
 139         else
 140                 input_proc();
 141
 142         if (needs_refresh) {
 143                 needs_refresh = 0;
 144                 stats_cons_refresh();
 145         }
 146
 147         if (rte_atomic32_read(&lsc)) {
 148                 rte_atomic32_dec(&lsc);
 149                 update_link_states();
 150                 stats_cons_refresh();
 151         }
 152 }
 153
 154 static void print_warnings(void)
 155 {
 156         if (get_n_warnings() == -1) {
 157                 plog_info("Warnings disabled\n");
 158         }
 159         else if (get_n_warnings() > 0) {
 160                 int n_print = get_n_warnings() < 5? get_n_warnings(): 5;
 161                 plog_info("Started with %d warnings, last %d warnings: \n", get_n_warnings(), n_print);
 162                 for (int i = -n_print + 1; i <= 0; ++i) {
 163                         plog_info("%s", get_warning(i));
 164                 }
 165         }
 166         else {
 167                 plog_info("Started without warnings\n");
 168         }
 169 }
 170
 171 /* start main loop */
 172 void __attribute__((noreturn)) run(uint32_t flags)
 173 {
 174         uint64_t cur_tsc;
 175         uint64_t next_update;
 176         uint64_t stop_tsc = 0;
 177         int ret = 0;
 178         const uint64_t update_interval_threshold = usec_to_tsc(1);
 179
 180         if (flags & DSF_LISTEN_TCP)
 181                 PROX_PANIC(reg_input_tcp(), "Failed to start listening on TCP port 8474: %s\n", strerror(errno));
 182         if (flags & DSF_LISTEN_UDS)
 183                 PROX_PANIC(reg_input_uds(), "Failed to start listening on UDS /tmp/prox.sock: %s\n", strerror(errno));
 184
 185         if (prox_cfg.use_stats_logger)
 186                 stats_cons_add(stats_cons_log_get());
 187
 188         stats_init(prox_cfg.start_time, prox_cfg.duration_time);
 189         stats_update(STATS_CONS_F_ALL);
 190
 191         switch (prox_cfg.ui) {
 192         case PROX_UI_CURSES:
 193                 reg_input_curses();
 194                 stats_cons_add(&display);
 195                 break;
 196         case PROX_UI_CLI:
 197                 stats_cons_add(stats_cons_cli_get());
 198                 break;
 199         case PROX_UI_NONE:
 200         default:
 201                 break;
 202         }
 203
 204         if (flags & DSF_AUTOSTART)
 205                 start_core_all(-1);
 206         else
 207                 stop_core_all(-1);
 208
 209         cur_tsc = rte_rdtsc();
 210         if (prox_cfg.duration_time != 0) {
 211                 stop_tsc = cur_tsc + sec_to_tsc(prox_cfg.start_time + prox_cfg.duration_time);
 212         }
 213
 214         stats_cons_notify();
 215         stats_cons_refresh();
 216
 217         update_interval = str_to_tsc(prox_cfg.update_interval_str);
 218         next_update = cur_tsc + update_interval;
 219
 220         cmd_rx_tx_info();
 221         print_warnings();
 222
 223         struct task_master *task = (struct task_master *)lcore_cfg[prox_cfg.master].tasks_all[0];
 224         if (handle_ctrl_plane) {
 225                 while (stop_prox == 0) {
 226                         ret = 1;
 227                         // Run ctrl plane for max 10 msec to let screen and keyboard updates
 228                         if (prox_cfg.flags & DSF_CTRL_PLANE_ENABLED) {
 229                                 uint64_t ctrl_plane_update = rte_rdtsc() + msec_to_tsc(10);
 230                                 while ((ret) && (rte_rdtsc() < ctrl_plane_update))
 231                                         ret = handle_ctrl_plane(lcore_cfg[prox_cfg.master].tasks_all[0], NULL, 0);
 232                         }
 233                         multiplexed_input_stats(0);
 234                         if (rte_rdtsc() < next_update)
 235                                 continue;
 236                         next_update += update_interval;
 237                         stats_update(stats_cons_flags);
 238                         stats_cons_notify();
 239
 240                         if (stop_tsc && rte_rdtsc() >= stop_tsc) {
 241                                 stop_prox = 1;
 242                         }
 243                 }
 244         } else {
 245                 while (stop_prox == 0) {
 246
 247                         if (update_interval < update_interval_threshold)
 248                                 busy_wait_until(next_update);
 249                         else
 250                                 multiplexed_input_stats(next_update);
 251
 252                         next_update += update_interval;
 253
 254                         stats_update(stats_cons_flags);
 255                         stats_cons_notify();
 256
 257                         if (stop_tsc && rte_rdtsc() >= stop_tsc) {
 258                                 stop_prox = 1;
 259                         }
 260                 }
 261         }
 262
 263         stats_cons_finish();
 264
 265         if (prox_cfg.flags & DSF_WAIT_ON_QUIT) {
 266                 stop_core_all(-1);
 267         }
 268
 269         if (prox_cfg.logbuf) {
 270                 file_print(prox_cfg.logbuf);
 271         }
 272
 273         display_end();
 274         exit(EXIT_SUCCESS);
 275 }