net/failsafe: support multicast address list set
[dpdk.git] / drivers / net / failsafe / failsafe_private.h
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright 2017 6WIND S.A.
3  * Copyright 2017 Mellanox Technologies, Ltd
4  */
5
6 #ifndef _RTE_ETH_FAILSAFE_PRIVATE_H_
7 #define _RTE_ETH_FAILSAFE_PRIVATE_H_
8
9 #include <sys/queue.h>
10 #include <pthread.h>
11
12 #include <rte_atomic.h>
13 #include <rte_dev.h>
14 #include <rte_ethdev_driver.h>
15 #include <rte_devargs.h>
16 #include <rte_interrupts.h>
17
18 #define FAILSAFE_DRIVER_NAME "Fail-safe PMD"
19 #define FAILSAFE_OWNER_NAME "Fail-safe"
20
21 #define PMD_FAILSAFE_MAC_KVARG "mac"
22 #define PMD_FAILSAFE_HOTPLUG_POLL_KVARG "hotplug_poll"
23 #define PMD_FAILSAFE_PARAM_STRING       \
24         "dev(<ifc>),"                   \
25         "exec(<shell command>),"        \
26         "fd(<fd number>),"              \
27         "mac=mac_addr,"                 \
28         "hotplug_poll=u64"              \
29         ""
30
31 #define FAILSAFE_HOTPLUG_DEFAULT_TIMEOUT_MS 2000
32
33 #define FAILSAFE_MAX_ETHPORTS 2
34 #define FAILSAFE_MAX_ETHADDR 128
35
36 #define DEVARGS_MAXLEN 4096
37
38 enum rxp_service_state {
39         SS_NO_SERVICE = 0,
40         SS_REGISTERED,
41         SS_READY,
42         SS_RUNNING,
43 };
44
45 /* TYPES */
46
47 struct rx_proxy {
48         /* epoll file descriptor */
49         int efd;
50         /* event vector to be used by epoll */
51         struct rte_epoll_event *evec;
52         /* rte service id */
53         uint32_t sid;
54         /* service core id */
55         uint32_t scid;
56         enum rxp_service_state sstate;
57 };
58
59 struct rxq {
60         struct fs_priv *priv;
61         uint16_t qid;
62         /* next sub_device to poll */
63         struct sub_device *sdev;
64         unsigned int socket_id;
65         int event_fd;
66         unsigned int enable_events:1;
67         struct rte_eth_rxq_info info;
68         rte_atomic64_t refcnt[];
69 };
70
71 struct txq {
72         struct fs_priv *priv;
73         uint16_t qid;
74         unsigned int socket_id;
75         struct rte_eth_txq_info info;
76         rte_atomic64_t refcnt[];
77 };
78
79 struct rte_flow {
80         TAILQ_ENTRY(rte_flow) next;
81         /* sub_flows */
82         struct rte_flow *flows[FAILSAFE_MAX_ETHPORTS];
83         /* flow description for synchronization */
84         struct rte_flow_desc *fd;
85 };
86
87 enum dev_state {
88         DEV_UNDEFINED,
89         DEV_PARSED,
90         DEV_PROBED,
91         DEV_ACTIVE,
92         DEV_STARTED,
93 };
94
95 struct fs_stats {
96         struct rte_eth_stats stats;
97         uint64_t timestamp;
98 };
99
100 struct sub_device {
101         /* Exhaustive DPDK device description */
102         struct sub_device *next;
103         struct rte_devargs devargs;
104         struct rte_bus *bus;
105         struct rte_device *dev;
106         struct rte_eth_dev *edev;
107         uint8_t sid;
108         /* Device state machine */
109         enum dev_state state;
110         /* Last stats snapshot passed to user */
111         struct fs_stats stats_snapshot;
112         /* Some device are defined as a command line */
113         char *cmdline;
114         /* Others are retrieved through a file descriptor */
115         char *fd_str;
116         /* fail-safe device backreference */
117         struct rte_eth_dev *fs_dev;
118         /* flag calling for recollection */
119         volatile unsigned int remove:1;
120         /* flow isolation state */
121         int flow_isolated:1;
122         /* RMV callback registration state */
123         unsigned int rmv_callback:1;
124         /* LSC callback registration state */
125         unsigned int lsc_callback:1;
126 };
127
128 struct fs_priv {
129         struct rte_eth_dev *dev;
130         /*
131          * Set of sub_devices.
132          * subs[0] is the preferred device
133          * any other is just another slave
134          */
135         struct sub_device *subs;
136         uint8_t subs_head; /* if head == tail, no subs */
137         uint8_t subs_tail; /* first invalid */
138         uint8_t subs_tx; /* current emitting device */
139         uint8_t current_probed;
140         /* flow mapping */
141         TAILQ_HEAD(sub_flows, rte_flow) flow_list;
142         /* current number of mac_addr slots allocated. */
143         uint32_t nb_mac_addr;
144         struct ether_addr mac_addrs[FAILSAFE_MAX_ETHADDR];
145         uint32_t mac_addr_pool[FAILSAFE_MAX_ETHADDR];
146         uint32_t nb_mcast_addr;
147         struct ether_addr *mcast_addrs;
148         /* current capabilities */
149         struct rte_eth_dev_info infos;
150         struct rte_eth_dev_owner my_owner; /* Unique owner. */
151         struct rte_intr_handle intr_handle; /* Port interrupt handle. */
152         /*
153          * Fail-safe state machine.
154          * This level will be tracking state of the EAL and eth
155          * layer at large as defined by the user application.
156          * It will then steer the sub_devices toward the same
157          * synchronized state.
158          */
159         enum dev_state state;
160         struct rte_eth_stats stats_accumulator;
161         /*
162          * Rx interrupts/events proxy.
163          * The PMD issues Rx events to the EAL on behalf of its subdevices,
164          * it does that by registering an event-fd for each of its queues with
165          * the EAL. A PMD service thread listens to all the Rx events from the
166          * subdevices, when an Rx event is issued by a subdevice it will be
167          * caught by this service with will trigger an Rx event in the
168          * appropriate failsafe Rx queue.
169          */
170         struct rx_proxy rxp;
171         pthread_mutex_t hotplug_mutex;
172         /* Hot-plug mutex is locked by the alarm mechanism. */
173         volatile unsigned int alarm_lock:1;
174         unsigned int pending_alarm:1; /* An alarm is pending */
175         /* flow isolation state */
176         int flow_isolated:1;
177 };
178
179 /* FAILSAFE_INTR */
180
181 int failsafe_rx_intr_install(struct rte_eth_dev *dev);
182 void failsafe_rx_intr_uninstall(struct rte_eth_dev *dev);
183 int failsafe_rx_intr_install_subdevice(struct sub_device *sdev);
184 void failsafe_rx_intr_uninstall_subdevice(struct sub_device *sdev);
185
186 /* MISC */
187
188 int failsafe_hotplug_alarm_install(struct rte_eth_dev *dev);
189 int failsafe_hotplug_alarm_cancel(struct rte_eth_dev *dev);
190
191 /* RX / TX */
192
193 void set_burst_fn(struct rte_eth_dev *dev, int force_safe);
194
195 uint16_t failsafe_rx_burst(void *rxq,
196                 struct rte_mbuf **rx_pkts, uint16_t nb_pkts);
197 uint16_t failsafe_tx_burst(void *txq,
198                 struct rte_mbuf **tx_pkts, uint16_t nb_pkts);
199
200 uint16_t failsafe_rx_burst_fast(void *rxq,
201                 struct rte_mbuf **rx_pkts, uint16_t nb_pkts);
202 uint16_t failsafe_tx_burst_fast(void *txq,
203                 struct rte_mbuf **tx_pkts, uint16_t nb_pkts);
204
205 /* ARGS */
206
207 int failsafe_args_parse(struct rte_eth_dev *dev, const char *params);
208 void failsafe_args_free(struct rte_eth_dev *dev);
209 int failsafe_args_count_subdevice(struct rte_eth_dev *dev, const char *params);
210 int failsafe_args_parse_subs(struct rte_eth_dev *dev);
211
212 /* EAL */
213
214 int failsafe_eal_init(struct rte_eth_dev *dev);
215 int failsafe_eal_uninit(struct rte_eth_dev *dev);
216
217 /* ETH_DEV */
218
219 int failsafe_eth_dev_state_sync(struct rte_eth_dev *dev);
220 void failsafe_eth_dev_unregister_callbacks(struct sub_device *sdev);
221 void failsafe_dev_remove(struct rte_eth_dev *dev);
222 void failsafe_stats_increment(struct rte_eth_stats *to,
223                                 struct rte_eth_stats *from);
224 int failsafe_eth_rmv_event_callback(uint16_t port_id,
225                                     enum rte_eth_event_type type,
226                                     void *arg, void *out);
227 int failsafe_eth_lsc_event_callback(uint16_t port_id,
228                                     enum rte_eth_event_type event,
229                                     void *cb_arg, void *out);
230 int failsafe_eth_new_event_callback(uint16_t port_id,
231                                     enum rte_eth_event_type event,
232                                     void *cb_arg, void *out);
233
234 /* GLOBALS */
235
236 extern const char pmd_failsafe_driver_name[];
237 extern const struct eth_dev_ops failsafe_ops;
238 extern const struct rte_flow_ops fs_flow_ops;
239 extern uint64_t hotplug_poll;
240 extern int mac_from_arg;
241
242 /* HELPERS */
243
244 /* dev: (struct rte_eth_dev *) fail-safe device */
245 #define PRIV(dev) \
246         ((struct fs_priv *)(dev)->data->dev_private)
247
248 /* sdev: (struct sub_device *) */
249 #define ETH(sdev) \
250         ((sdev)->edev)
251
252 /* sdev: (struct sub_device *) */
253 #define PORT_ID(sdev) \
254         (ETH(sdev)->data->port_id)
255
256 /* sdev: (struct sub_device *) */
257 #define SUB_ID(sdev) \
258         ((sdev)->sid)
259
260 /**
261  * Stateful iterator construct over fail-safe sub-devices:
262  * s:     (struct sub_device *), iterator
263  * i:     (uint8_t), increment
264  * dev:   (struct rte_eth_dev *), fail-safe ethdev
265  * state: (enum dev_state), minimum acceptable device state
266  */
267 #define FOREACH_SUBDEV_STATE(s, i, dev, state)          \
268         for (s = fs_find_next((dev), 0, state, &i);     \
269              s != NULL;                                 \
270              s = fs_find_next((dev), i + 1, state, &i))
271
272 /**
273  * Iterator construct over fail-safe sub-devices:
274  * s:   (struct sub_device *), iterator
275  * i:   (uint8_t), increment
276  * dev: (struct rte_eth_dev *), fail-safe ethdev
277  */
278 #define FOREACH_SUBDEV(s, i, dev)                       \
279         FOREACH_SUBDEV_STATE(s, i, dev, DEV_UNDEFINED)
280
281 /* dev: (struct rte_eth_dev *) fail-safe device */
282 #define PREFERRED_SUBDEV(dev) \
283         (&PRIV(dev)->subs[0])
284
285 /* dev: (struct rte_eth_dev *) fail-safe device */
286 #define TX_SUBDEV(dev)                                                    \
287         (PRIV(dev)->subs_tx >= PRIV(dev)->subs_tail                ? NULL \
288          : (PRIV(dev)->subs[PRIV(dev)->subs_tx].state < DEV_PROBED ? NULL \
289          : &PRIV(dev)->subs[PRIV(dev)->subs_tx]))
290
291 /**
292  * s:   (struct sub_device *)
293  * ops: (struct eth_dev_ops) member
294  */
295 #define SUBOPS(s, ops) \
296         (ETH(s)->dev_ops->ops)
297
298 /**
299  * Atomic guard
300  */
301
302 /**
303  * a: (rte_atomic64_t)
304  */
305 #define FS_ATOMIC_P(a) \
306         rte_atomic64_set(&(a), 1)
307
308 /**
309  * a: (rte_atomic64_t)
310  */
311 #define FS_ATOMIC_V(a) \
312         rte_atomic64_set(&(a), 0)
313
314 /**
315  * s: (struct sub_device *)
316  * i: uint16_t qid
317  */
318 #define FS_ATOMIC_RX(s, i) \
319         rte_atomic64_read( \
320          &((struct rxq *)((s)->fs_dev->data->rx_queues[i]))->refcnt[(s)->sid] \
321         )
322 /**
323  * s: (struct sub_device *)
324  * i: uint16_t qid
325  */
326 #define FS_ATOMIC_TX(s, i) \
327         rte_atomic64_read( \
328          &((struct txq *)((s)->fs_dev->data->tx_queues[i]))->refcnt[(s)->sid] \
329         )
330
331 #ifdef RTE_EXEC_ENV_BSDAPP
332 #define FS_THREADID_TYPE void*
333 #define FS_THREADID_FMT  "p"
334 #else
335 #define FS_THREADID_TYPE unsigned long
336 #define FS_THREADID_FMT  "lu"
337 #endif
338
339 extern int failsafe_logtype;
340
341 #define LOG__(l, m, ...) \
342         rte_log(RTE_LOG_ ## l, failsafe_logtype, \
343                 "net_failsafe: " m "%c", __VA_ARGS__)
344
345 #define LOG_(level, ...) LOG__(level, __VA_ARGS__, '\n')
346 #define DEBUG(...) LOG_(DEBUG, __VA_ARGS__)
347 #define INFO(...) LOG_(INFO, __VA_ARGS__)
348 #define WARN(...) LOG_(WARNING, __VA_ARGS__)
349 #define ERROR(...) LOG_(ERR, __VA_ARGS__)
350
351 /* inlined functions */
352
353 static inline struct sub_device *
354 fs_find_next(struct rte_eth_dev *dev,
355              uint8_t sid,
356              enum dev_state min_state,
357              uint8_t *sid_out)
358 {
359         struct sub_device *subs;
360         uint8_t tail;
361
362         subs = PRIV(dev)->subs;
363         tail = PRIV(dev)->subs_tail;
364         while (sid < tail) {
365                 if (subs[sid].state >= min_state)
366                         break;
367                 sid++;
368         }
369         *sid_out = sid;
370         if (sid >= tail)
371                 return NULL;
372         return &subs[sid];
373 }
374
375 /*
376  * Lock hot-plug mutex.
377  * is_alarm means that the caller is, for sure, the hot-plug alarm mechanism.
378  */
379 static inline int
380 fs_lock(struct rte_eth_dev *dev, unsigned int is_alarm)
381 {
382         int ret;
383
384         if (is_alarm) {
385                 ret = pthread_mutex_trylock(&PRIV(dev)->hotplug_mutex);
386                 if (ret) {
387                         DEBUG("Hot-plug mutex lock trying failed(%s), will try"
388                               " again later...", strerror(ret));
389                         return ret;
390                 }
391                 PRIV(dev)->alarm_lock = 1;
392         } else {
393                 ret = pthread_mutex_lock(&PRIV(dev)->hotplug_mutex);
394                 if (ret) {
395                         ERROR("Cannot lock mutex(%s)", strerror(ret));
396                         return ret;
397                 }
398         }
399         DEBUG("Hot-plug mutex was locked by thread %" FS_THREADID_FMT "%s",
400               (FS_THREADID_TYPE)pthread_self(),
401               PRIV(dev)->alarm_lock ? " by the hot-plug alarm" : "");
402         return ret;
403 }
404
405 /*
406  * Unlock hot-plug mutex.
407  * is_alarm means that the caller is, for sure, the hot-plug alarm mechanism.
408  */
409 static inline void
410 fs_unlock(struct rte_eth_dev *dev, unsigned int is_alarm)
411 {
412         int ret;
413         unsigned int prev_alarm_lock = PRIV(dev)->alarm_lock;
414
415         if (is_alarm) {
416                 RTE_ASSERT(PRIV(dev)->alarm_lock == 1);
417                 PRIV(dev)->alarm_lock = 0;
418         }
419         ret = pthread_mutex_unlock(&PRIV(dev)->hotplug_mutex);
420         if (ret)
421                 ERROR("Cannot unlock hot-plug mutex(%s)", strerror(ret));
422         else
423                 DEBUG("Hot-plug mutex was unlocked by thread %" FS_THREADID_FMT "%s",
424                       (FS_THREADID_TYPE)pthread_self(),
425                       prev_alarm_lock ? " by the hot-plug alarm" : "");
426 }
427
428 /*
429  * Switch emitting device.
430  * If banned is set, banned must not be considered for
431  * the role of emitting device.
432  */
433 static inline void
434 fs_switch_dev(struct rte_eth_dev *dev,
435               struct sub_device *banned)
436 {
437         struct sub_device *txd;
438         enum dev_state req_state;
439
440         req_state = PRIV(dev)->state;
441         txd = TX_SUBDEV(dev);
442         if (PREFERRED_SUBDEV(dev)->state >= req_state &&
443             PREFERRED_SUBDEV(dev) != banned) {
444                 if (txd != PREFERRED_SUBDEV(dev) &&
445                     (txd == NULL ||
446                      (req_state == DEV_STARTED) ||
447                      (txd && txd->state < DEV_STARTED))) {
448                         DEBUG("Switching tx_dev to preferred sub_device");
449                         PRIV(dev)->subs_tx = 0;
450                 }
451         } else if ((txd && txd->state < req_state) ||
452                    txd == NULL ||
453                    txd == banned) {
454                 struct sub_device *sdev = NULL;
455                 uint8_t i;
456
457                 /* Using acceptable device */
458                 FOREACH_SUBDEV_STATE(sdev, i, dev, req_state) {
459                         if (sdev == banned)
460                                 continue;
461                         DEBUG("Switching tx_dev to sub_device %d",
462                               i);
463                         PRIV(dev)->subs_tx = i;
464                         break;
465                 }
466                 if (i >= PRIV(dev)->subs_tail || sdev == NULL) {
467                         DEBUG("No device ready, deactivating tx_dev");
468                         PRIV(dev)->subs_tx = PRIV(dev)->subs_tail;
469                 }
470         } else {
471                 return;
472         }
473         set_burst_fn(dev, 0);
474         rte_wmb();
475 }
476
477 /*
478  * Adjust error value and rte_errno to the fail-safe actual error value.
479  */
480 static inline int
481 fs_err(struct sub_device *sdev, int err)
482 {
483         /* A device removal shouldn't be reported as an error. */
484         if (sdev->remove == 1 || err == -EIO)
485                 return rte_errno = 0;
486         return err;
487 }
488 #endif /* _RTE_ETH_FAILSAFE_PRIVATE_H_ */