net/virtio: fix incorrect cast of void *
[dpdk.git] / timer / rte_timer.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2010-2014 Intel Corporation
3  */
4
5 #include <string.h>
6 #include <stdio.h>
7 #include <stdint.h>
8 #include <stdbool.h>
9 #include <inttypes.h>
10 #include <assert.h>
11 #include <sys/queue.h>
12
13 #include <rte_common.h>
14 #include <rte_cycles.h>
15 #include <rte_eal_memconfig.h>
16 #include <rte_per_lcore.h>
17 #include <rte_memory.h>
18 #include <rte_launch.h>
19 #include <rte_eal.h>
20 #include <rte_lcore.h>
21 #include <rte_branch_prediction.h>
22 #include <rte_spinlock.h>
23 #include <rte_random.h>
24 #include <rte_pause.h>
25 #include <rte_memzone.h>
26 #include <rte_malloc.h>
27 #include <rte_errno.h>
28
29 #include "rte_timer.h"
30
31 /**
32  * Per-lcore info for timers.
33  */
34 struct priv_timer {
35         struct rte_timer pending_head;  /**< dummy timer instance to head up list */
36         rte_spinlock_t list_lock;       /**< lock to protect list access */
37
38         /** per-core variable that true if a timer was updated on this
39          *  core since last reset of the variable */
40         int updated;
41
42         /** track the current depth of the skiplist */
43         unsigned curr_skiplist_depth;
44
45         unsigned prev_lcore;              /**< used for lcore round robin */
46
47         /** running timer on this lcore now */
48         struct rte_timer *running_tim;
49
50 #ifdef RTE_LIBRTE_TIMER_DEBUG
51         /** per-lcore statistics */
52         struct rte_timer_debug_stats stats;
53 #endif
54 } __rte_cache_aligned;
55
56 #define FL_ALLOCATED    (1 << 0)
57 struct rte_timer_data {
58         struct priv_timer priv_timer[RTE_MAX_LCORE];
59         uint8_t internal_flags;
60 };
61
62 #define RTE_MAX_DATA_ELS 64
63 static const struct rte_memzone *rte_timer_data_mz;
64 static int *volatile rte_timer_mz_refcnt;
65 static struct rte_timer_data *rte_timer_data_arr;
66 static const uint32_t default_data_id;
67 static uint32_t rte_timer_subsystem_initialized;
68
69 /* when debug is enabled, store some statistics */
70 #ifdef RTE_LIBRTE_TIMER_DEBUG
71 #define __TIMER_STAT_ADD(priv_timer, name, n) do {                      \
72                 unsigned __lcore_id = rte_lcore_id();                   \
73                 if (__lcore_id < RTE_MAX_LCORE)                         \
74                         priv_timer[__lcore_id].stats.name += (n);       \
75         } while(0)
76 #else
77 #define __TIMER_STAT_ADD(priv_timer, name, n) do {} while (0)
78 #endif
79
80 static inline int
81 timer_data_valid(uint32_t id)
82 {
83         return rte_timer_data_arr &&
84                 (rte_timer_data_arr[id].internal_flags & FL_ALLOCATED);
85 }
86
87 /* validate ID and retrieve timer data pointer, or return error value */
88 #define TIMER_DATA_VALID_GET_OR_ERR_RET(id, timer_data, retval) do {    \
89         if (id >= RTE_MAX_DATA_ELS || !timer_data_valid(id))            \
90                 return retval;                                          \
91         timer_data = &rte_timer_data_arr[id];                           \
92 } while (0)
93
94 int
95 rte_timer_data_alloc(uint32_t *id_ptr)
96 {
97         int i;
98         struct rte_timer_data *data;
99
100         if (!rte_timer_subsystem_initialized)
101                 return -ENOMEM;
102
103         for (i = 0; i < RTE_MAX_DATA_ELS; i++) {
104                 data = &rte_timer_data_arr[i];
105                 if (!(data->internal_flags & FL_ALLOCATED)) {
106                         data->internal_flags |= FL_ALLOCATED;
107
108                         if (id_ptr)
109                                 *id_ptr = i;
110
111                         return 0;
112                 }
113         }
114
115         return -ENOSPC;
116 }
117
118 int
119 rte_timer_data_dealloc(uint32_t id)
120 {
121         struct rte_timer_data *timer_data;
122         TIMER_DATA_VALID_GET_OR_ERR_RET(id, timer_data, -EINVAL);
123
124         timer_data->internal_flags &= ~(FL_ALLOCATED);
125
126         return 0;
127 }
128
129 /* Init the timer library. Allocate an array of timer data structs in shared
130  * memory, and allocate the zeroth entry for use with original timer
131  * APIs. Since the intersection of the sets of lcore ids in primary and
132  * secondary processes should be empty, the zeroth entry can be shared by
133  * multiple processes.
134  */
135 int
136 rte_timer_subsystem_init(void)
137 {
138         const struct rte_memzone *mz;
139         struct rte_timer_data *data;
140         int i, lcore_id;
141         static const char *mz_name = "rte_timer_mz";
142         const size_t data_arr_size =
143                         RTE_MAX_DATA_ELS * sizeof(*rte_timer_data_arr);
144         const size_t mem_size = data_arr_size + sizeof(*rte_timer_mz_refcnt);
145         bool do_full_init = true;
146
147         rte_mcfg_timer_lock();
148
149         if (rte_timer_subsystem_initialized) {
150                 rte_mcfg_timer_unlock();
151                 return -EALREADY;
152         }
153
154         mz = rte_memzone_lookup(mz_name);
155         if (mz == NULL) {
156                 mz = rte_memzone_reserve_aligned(mz_name, mem_size,
157                                 SOCKET_ID_ANY, 0, RTE_CACHE_LINE_SIZE);
158                 if (mz == NULL) {
159                         rte_mcfg_timer_unlock();
160                         return -ENOMEM;
161                 }
162                 do_full_init = true;
163         } else
164                 do_full_init = false;
165
166         rte_timer_data_mz = mz;
167         rte_timer_data_arr = mz->addr;
168         rte_timer_mz_refcnt = (void *)((char *)mz->addr + data_arr_size);
169
170         if (do_full_init) {
171                 for (i = 0; i < RTE_MAX_DATA_ELS; i++) {
172                         data = &rte_timer_data_arr[i];
173
174                         for (lcore_id = 0; lcore_id < RTE_MAX_LCORE;
175                              lcore_id++) {
176                                 rte_spinlock_init(
177                                         &data->priv_timer[lcore_id].list_lock);
178                                 data->priv_timer[lcore_id].prev_lcore =
179                                         lcore_id;
180                         }
181                 }
182         }
183
184         rte_timer_data_arr[default_data_id].internal_flags |= FL_ALLOCATED;
185         (*rte_timer_mz_refcnt)++;
186
187         rte_timer_subsystem_initialized = 1;
188
189         rte_mcfg_timer_unlock();
190
191         return 0;
192 }
193
194 void
195 rte_timer_subsystem_finalize(void)
196 {
197         rte_mcfg_timer_lock();
198
199         if (!rte_timer_subsystem_initialized) {
200                 rte_mcfg_timer_unlock();
201                 return;
202         }
203
204         if (--(*rte_timer_mz_refcnt) == 0)
205                 rte_memzone_free(rte_timer_data_mz);
206
207         rte_timer_subsystem_initialized = 0;
208
209         rte_mcfg_timer_unlock();
210 }
211
212 /* Initialize the timer handle tim for use */
213 void
214 rte_timer_init(struct rte_timer *tim)
215 {
216         union rte_timer_status status;
217
218         status.state = RTE_TIMER_STOP;
219         status.owner = RTE_TIMER_NO_OWNER;
220         __atomic_store_n(&tim->status.u32, status.u32, __ATOMIC_RELAXED);
221 }
222
223 /*
224  * if timer is pending or stopped (or running on the same core than
225  * us), mark timer as configuring, and on success return the previous
226  * status of the timer
227  */
228 static int
229 timer_set_config_state(struct rte_timer *tim,
230                        union rte_timer_status *ret_prev_status,
231                        struct priv_timer *priv_timer)
232 {
233         union rte_timer_status prev_status, status;
234         int success = 0;
235         unsigned lcore_id;
236
237         lcore_id = rte_lcore_id();
238
239         /* wait that the timer is in correct status before update,
240          * and mark it as being configured */
241         prev_status.u32 = __atomic_load_n(&tim->status.u32, __ATOMIC_RELAXED);
242
243         while (success == 0) {
244                 /* timer is running on another core
245                  * or ready to run on local core, exit
246                  */
247                 if (prev_status.state == RTE_TIMER_RUNNING &&
248                     (prev_status.owner != (uint16_t)lcore_id ||
249                      tim != priv_timer[lcore_id].running_tim))
250                         return -1;
251
252                 /* timer is being configured on another core */
253                 if (prev_status.state == RTE_TIMER_CONFIG)
254                         return -1;
255
256                 /* here, we know that timer is stopped or pending,
257                  * mark it atomically as being configured */
258                 status.state = RTE_TIMER_CONFIG;
259                 status.owner = (int16_t)lcore_id;
260                 /* CONFIG states are acting as locked states. If the
261                  * timer is in CONFIG state, the state cannot be changed
262                  * by other threads. So, we should use ACQUIRE here.
263                  */
264                 success = __atomic_compare_exchange_n(&tim->status.u32,
265                                               &prev_status.u32,
266                                               status.u32, 0,
267                                               __ATOMIC_ACQUIRE,
268                                               __ATOMIC_RELAXED);
269         }
270
271         ret_prev_status->u32 = prev_status.u32;
272         return 0;
273 }
274
275 /*
276  * if timer is pending, mark timer as running
277  */
278 static int
279 timer_set_running_state(struct rte_timer *tim)
280 {
281         union rte_timer_status prev_status, status;
282         unsigned lcore_id = rte_lcore_id();
283         int success = 0;
284
285         /* wait that the timer is in correct status before update,
286          * and mark it as running */
287         prev_status.u32 = __atomic_load_n(&tim->status.u32, __ATOMIC_RELAXED);
288
289         while (success == 0) {
290                 /* timer is not pending anymore */
291                 if (prev_status.state != RTE_TIMER_PENDING)
292                         return -1;
293
294                 /* we know that the timer will be pending at this point
295                  * mark it atomically as being running
296                  */
297                 status.state = RTE_TIMER_RUNNING;
298                 status.owner = (int16_t)lcore_id;
299                 /* RUNNING states are acting as locked states. If the
300                  * timer is in RUNNING state, the state cannot be changed
301                  * by other threads. So, we should use ACQUIRE here.
302                  */
303                 success = __atomic_compare_exchange_n(&tim->status.u32,
304                                               &prev_status.u32,
305                                               status.u32, 0,
306                                               __ATOMIC_ACQUIRE,
307                                               __ATOMIC_RELAXED);
308         }
309
310         return 0;
311 }
312
313 /*
314  * Return a skiplist level for a new entry.
315  * This probabilistically gives a level with p=1/4 that an entry at level n
316  * will also appear at level n+1.
317  */
318 static uint32_t
319 timer_get_skiplist_level(unsigned curr_depth)
320 {
321 #ifdef RTE_LIBRTE_TIMER_DEBUG
322         static uint32_t i, count = 0;
323         static uint32_t levels[MAX_SKIPLIST_DEPTH] = {0};
324 #endif
325
326         /* probability value is 1/4, i.e. all at level 0, 1 in 4 is at level 1,
327          * 1 in 16 at level 2, 1 in 64 at level 3, etc. Calculated using lowest
328          * bit position of a (pseudo)random number.
329          */
330         uint32_t rand = rte_rand() & (UINT32_MAX - 1);
331         uint32_t level = rand == 0 ? MAX_SKIPLIST_DEPTH : (rte_bsf32(rand)-1) / 2;
332
333         /* limit the levels used to one above our current level, so we don't,
334          * for instance, have a level 0 and a level 7 without anything between
335          */
336         if (level > curr_depth)
337                 level = curr_depth;
338         if (level >= MAX_SKIPLIST_DEPTH)
339                 level = MAX_SKIPLIST_DEPTH-1;
340 #ifdef RTE_LIBRTE_TIMER_DEBUG
341         count ++;
342         levels[level]++;
343         if (count % 10000 == 0)
344                 for (i = 0; i < MAX_SKIPLIST_DEPTH; i++)
345                         printf("Level %u: %u\n", (unsigned)i, (unsigned)levels[i]);
346 #endif
347         return level;
348 }
349
350 /*
351  * For a given time value, get the entries at each level which
352  * are <= that time value.
353  */
354 static void
355 timer_get_prev_entries(uint64_t time_val, unsigned tim_lcore,
356                        struct rte_timer **prev, struct priv_timer *priv_timer)
357 {
358         unsigned lvl = priv_timer[tim_lcore].curr_skiplist_depth;
359         prev[lvl] = &priv_timer[tim_lcore].pending_head;
360         while(lvl != 0) {
361                 lvl--;
362                 prev[lvl] = prev[lvl+1];
363                 while (prev[lvl]->sl_next[lvl] &&
364                                 prev[lvl]->sl_next[lvl]->expire <= time_val)
365                         prev[lvl] = prev[lvl]->sl_next[lvl];
366         }
367 }
368
369 /*
370  * Given a timer node in the skiplist, find the previous entries for it at
371  * all skiplist levels.
372  */
373 static void
374 timer_get_prev_entries_for_node(struct rte_timer *tim, unsigned tim_lcore,
375                                 struct rte_timer **prev,
376                                 struct priv_timer *priv_timer)
377 {
378         int i;
379
380         /* to get a specific entry in the list, look for just lower than the time
381          * values, and then increment on each level individually if necessary
382          */
383         timer_get_prev_entries(tim->expire - 1, tim_lcore, prev, priv_timer);
384         for (i = priv_timer[tim_lcore].curr_skiplist_depth - 1; i >= 0; i--) {
385                 while (prev[i]->sl_next[i] != NULL &&
386                                 prev[i]->sl_next[i] != tim &&
387                                 prev[i]->sl_next[i]->expire <= tim->expire)
388                         prev[i] = prev[i]->sl_next[i];
389         }
390 }
391
392 /* call with lock held as necessary
393  * add in list
394  * timer must be in config state
395  * timer must not be in a list
396  */
397 static void
398 timer_add(struct rte_timer *tim, unsigned int tim_lcore,
399           struct priv_timer *priv_timer)
400 {
401         unsigned lvl;
402         struct rte_timer *prev[MAX_SKIPLIST_DEPTH+1];
403
404         /* find where exactly this element goes in the list of elements
405          * for each depth. */
406         timer_get_prev_entries(tim->expire, tim_lcore, prev, priv_timer);
407
408         /* now assign it a new level and add at that level */
409         const unsigned tim_level = timer_get_skiplist_level(
410                         priv_timer[tim_lcore].curr_skiplist_depth);
411         if (tim_level == priv_timer[tim_lcore].curr_skiplist_depth)
412                 priv_timer[tim_lcore].curr_skiplist_depth++;
413
414         lvl = tim_level;
415         while (lvl > 0) {
416                 tim->sl_next[lvl] = prev[lvl]->sl_next[lvl];
417                 prev[lvl]->sl_next[lvl] = tim;
418                 lvl--;
419         }
420         tim->sl_next[0] = prev[0]->sl_next[0];
421         prev[0]->sl_next[0] = tim;
422
423         /* save the lowest list entry into the expire field of the dummy hdr
424          * NOTE: this is not atomic on 32-bit*/
425         priv_timer[tim_lcore].pending_head.expire = priv_timer[tim_lcore].\
426                         pending_head.sl_next[0]->expire;
427 }
428
429 /*
430  * del from list, lock if needed
431  * timer must be in config state
432  * timer must be in a list
433  */
434 static void
435 timer_del(struct rte_timer *tim, union rte_timer_status prev_status,
436           int local_is_locked, struct priv_timer *priv_timer)
437 {
438         unsigned lcore_id = rte_lcore_id();
439         unsigned prev_owner = prev_status.owner;
440         int i;
441         struct rte_timer *prev[MAX_SKIPLIST_DEPTH+1];
442
443         /* if timer needs is pending another core, we need to lock the
444          * list; if it is on local core, we need to lock if we are not
445          * called from rte_timer_manage() */
446         if (prev_owner != lcore_id || !local_is_locked)
447                 rte_spinlock_lock(&priv_timer[prev_owner].list_lock);
448
449         /* save the lowest list entry into the expire field of the dummy hdr.
450          * NOTE: this is not atomic on 32-bit */
451         if (tim == priv_timer[prev_owner].pending_head.sl_next[0])
452                 priv_timer[prev_owner].pending_head.expire =
453                                 ((tim->sl_next[0] == NULL) ? 0 : tim->sl_next[0]->expire);
454
455         /* adjust pointers from previous entries to point past this */
456         timer_get_prev_entries_for_node(tim, prev_owner, prev, priv_timer);
457         for (i = priv_timer[prev_owner].curr_skiplist_depth - 1; i >= 0; i--) {
458                 if (prev[i]->sl_next[i] == tim)
459                         prev[i]->sl_next[i] = tim->sl_next[i];
460         }
461
462         /* in case we deleted last entry at a level, adjust down max level */
463         for (i = priv_timer[prev_owner].curr_skiplist_depth - 1; i >= 0; i--)
464                 if (priv_timer[prev_owner].pending_head.sl_next[i] == NULL)
465                         priv_timer[prev_owner].curr_skiplist_depth --;
466                 else
467                         break;
468
469         if (prev_owner != lcore_id || !local_is_locked)
470                 rte_spinlock_unlock(&priv_timer[prev_owner].list_lock);
471 }
472
473 /* Reset and start the timer associated with the timer handle (private func) */
474 static int
475 __rte_timer_reset(struct rte_timer *tim, uint64_t expire,
476                   uint64_t period, unsigned tim_lcore,
477                   rte_timer_cb_t fct, void *arg,
478                   int local_is_locked,
479                   struct rte_timer_data *timer_data)
480 {
481         union rte_timer_status prev_status, status;
482         int ret;
483         unsigned lcore_id = rte_lcore_id();
484         struct priv_timer *priv_timer = timer_data->priv_timer;
485
486         /* round robin for tim_lcore */
487         if (tim_lcore == (unsigned)LCORE_ID_ANY) {
488                 if (lcore_id < RTE_MAX_LCORE) {
489                         /* EAL thread with valid lcore_id */
490                         tim_lcore = rte_get_next_lcore(
491                                 priv_timer[lcore_id].prev_lcore,
492                                 0, 1);
493                         priv_timer[lcore_id].prev_lcore = tim_lcore;
494                 } else
495                         /* non-EAL thread do not run rte_timer_manage(),
496                          * so schedule the timer on the first enabled lcore. */
497                         tim_lcore = rte_get_next_lcore(LCORE_ID_ANY, 0, 1);
498         }
499
500         /* wait that the timer is in correct status before update,
501          * and mark it as being configured */
502         ret = timer_set_config_state(tim, &prev_status, priv_timer);
503         if (ret < 0)
504                 return -1;
505
506         __TIMER_STAT_ADD(priv_timer, reset, 1);
507         if (prev_status.state == RTE_TIMER_RUNNING &&
508             lcore_id < RTE_MAX_LCORE) {
509                 priv_timer[lcore_id].updated = 1;
510         }
511
512         /* remove it from list */
513         if (prev_status.state == RTE_TIMER_PENDING) {
514                 timer_del(tim, prev_status, local_is_locked, priv_timer);
515                 __TIMER_STAT_ADD(priv_timer, pending, -1);
516         }
517
518         tim->period = period;
519         tim->expire = expire;
520         tim->f = fct;
521         tim->arg = arg;
522
523         /* if timer needs to be scheduled on another core, we need to
524          * lock the destination list; if it is on local core, we need to lock if
525          * we are not called from rte_timer_manage()
526          */
527         if (tim_lcore != lcore_id || !local_is_locked)
528                 rte_spinlock_lock(&priv_timer[tim_lcore].list_lock);
529
530         __TIMER_STAT_ADD(priv_timer, pending, 1);
531         timer_add(tim, tim_lcore, priv_timer);
532
533         /* update state: as we are in CONFIG state, only us can modify
534          * the state so we don't need to use cmpset() here */
535         status.state = RTE_TIMER_PENDING;
536         status.owner = (int16_t)tim_lcore;
537         /* The "RELEASE" ordering guarantees the memory operations above
538          * the status update are observed before the update by all threads
539          */
540         __atomic_store_n(&tim->status.u32, status.u32, __ATOMIC_RELEASE);
541
542         if (tim_lcore != lcore_id || !local_is_locked)
543                 rte_spinlock_unlock(&priv_timer[tim_lcore].list_lock);
544
545         return 0;
546 }
547
548 /* Reset and start the timer associated with the timer handle tim */
549 int
550 rte_timer_reset(struct rte_timer *tim, uint64_t ticks,
551                       enum rte_timer_type type, unsigned int tim_lcore,
552                       rte_timer_cb_t fct, void *arg)
553 {
554         return rte_timer_alt_reset(default_data_id, tim, ticks, type,
555                                    tim_lcore, fct, arg);
556 }
557
558 int
559 rte_timer_alt_reset(uint32_t timer_data_id, struct rte_timer *tim,
560                     uint64_t ticks, enum rte_timer_type type,
561                     unsigned int tim_lcore, rte_timer_cb_t fct, void *arg)
562 {
563         uint64_t cur_time = rte_get_timer_cycles();
564         uint64_t period;
565         struct rte_timer_data *timer_data;
566
567         TIMER_DATA_VALID_GET_OR_ERR_RET(timer_data_id, timer_data, -EINVAL);
568
569         if (type == PERIODICAL)
570                 period = ticks;
571         else
572                 period = 0;
573
574         return __rte_timer_reset(tim,  cur_time + ticks, period, tim_lcore,
575                                  fct, arg, 0, timer_data);
576 }
577
578 /* loop until rte_timer_reset() succeed */
579 void
580 rte_timer_reset_sync(struct rte_timer *tim, uint64_t ticks,
581                      enum rte_timer_type type, unsigned tim_lcore,
582                      rte_timer_cb_t fct, void *arg)
583 {
584         while (rte_timer_reset(tim, ticks, type, tim_lcore,
585                                fct, arg) != 0)
586                 rte_pause();
587 }
588
589 static int
590 __rte_timer_stop(struct rte_timer *tim, int local_is_locked,
591                  struct rte_timer_data *timer_data)
592 {
593         union rte_timer_status prev_status, status;
594         unsigned lcore_id = rte_lcore_id();
595         int ret;
596         struct priv_timer *priv_timer = timer_data->priv_timer;
597
598         /* wait that the timer is in correct status before update,
599          * and mark it as being configured */
600         ret = timer_set_config_state(tim, &prev_status, priv_timer);
601         if (ret < 0)
602                 return -1;
603
604         __TIMER_STAT_ADD(priv_timer, stop, 1);
605         if (prev_status.state == RTE_TIMER_RUNNING &&
606             lcore_id < RTE_MAX_LCORE) {
607                 priv_timer[lcore_id].updated = 1;
608         }
609
610         /* remove it from list */
611         if (prev_status.state == RTE_TIMER_PENDING) {
612                 timer_del(tim, prev_status, local_is_locked, priv_timer);
613                 __TIMER_STAT_ADD(priv_timer, pending, -1);
614         }
615
616         /* mark timer as stopped */
617         status.state = RTE_TIMER_STOP;
618         status.owner = RTE_TIMER_NO_OWNER;
619         /* The "RELEASE" ordering guarantees the memory operations above
620          * the status update are observed before the update by all threads
621          */
622         __atomic_store_n(&tim->status.u32, status.u32, __ATOMIC_RELEASE);
623
624         return 0;
625 }
626
627 /* Stop the timer associated with the timer handle tim */
628 int
629 rte_timer_stop(struct rte_timer *tim)
630 {
631         return rte_timer_alt_stop(default_data_id, tim);
632 }
633
634 int
635 rte_timer_alt_stop(uint32_t timer_data_id, struct rte_timer *tim)
636 {
637         struct rte_timer_data *timer_data;
638
639         TIMER_DATA_VALID_GET_OR_ERR_RET(timer_data_id, timer_data, -EINVAL);
640
641         return __rte_timer_stop(tim, 0, timer_data);
642 }
643
644 /* loop until rte_timer_stop() succeed */
645 void
646 rte_timer_stop_sync(struct rte_timer *tim)
647 {
648         while (rte_timer_stop(tim) != 0)
649                 rte_pause();
650 }
651
652 /* Test the PENDING status of the timer handle tim */
653 int
654 rte_timer_pending(struct rte_timer *tim)
655 {
656         return __atomic_load_n(&tim->status.state,
657                                 __ATOMIC_RELAXED) == RTE_TIMER_PENDING;
658 }
659
660 /* must be called periodically, run all timer that expired */
661 static void
662 __rte_timer_manage(struct rte_timer_data *timer_data)
663 {
664         union rte_timer_status status;
665         struct rte_timer *tim, *next_tim;
666         struct rte_timer *run_first_tim, **pprev;
667         unsigned lcore_id = rte_lcore_id();
668         struct rte_timer *prev[MAX_SKIPLIST_DEPTH + 1];
669         uint64_t cur_time;
670         int i, ret;
671         struct priv_timer *priv_timer = timer_data->priv_timer;
672
673         /* timer manager only runs on EAL thread with valid lcore_id */
674         assert(lcore_id < RTE_MAX_LCORE);
675
676         __TIMER_STAT_ADD(priv_timer, manage, 1);
677         /* optimize for the case where per-cpu list is empty */
678         if (priv_timer[lcore_id].pending_head.sl_next[0] == NULL)
679                 return;
680         cur_time = rte_get_timer_cycles();
681
682 #ifdef RTE_ARCH_64
683         /* on 64-bit the value cached in the pending_head.expired will be
684          * updated atomically, so we can consult that for a quick check here
685          * outside the lock */
686         if (likely(priv_timer[lcore_id].pending_head.expire > cur_time))
687                 return;
688 #endif
689
690         /* browse ordered list, add expired timers in 'expired' list */
691         rte_spinlock_lock(&priv_timer[lcore_id].list_lock);
692
693         /* if nothing to do just unlock and return */
694         if (priv_timer[lcore_id].pending_head.sl_next[0] == NULL ||
695             priv_timer[lcore_id].pending_head.sl_next[0]->expire > cur_time) {
696                 rte_spinlock_unlock(&priv_timer[lcore_id].list_lock);
697                 return;
698         }
699
700         /* save start of list of expired timers */
701         tim = priv_timer[lcore_id].pending_head.sl_next[0];
702
703         /* break the existing list at current time point */
704         timer_get_prev_entries(cur_time, lcore_id, prev, priv_timer);
705         for (i = priv_timer[lcore_id].curr_skiplist_depth -1; i >= 0; i--) {
706                 if (prev[i] == &priv_timer[lcore_id].pending_head)
707                         continue;
708                 priv_timer[lcore_id].pending_head.sl_next[i] =
709                     prev[i]->sl_next[i];
710                 if (prev[i]->sl_next[i] == NULL)
711                         priv_timer[lcore_id].curr_skiplist_depth--;
712                 prev[i] ->sl_next[i] = NULL;
713         }
714
715         /* transition run-list from PENDING to RUNNING */
716         run_first_tim = tim;
717         pprev = &run_first_tim;
718
719         for ( ; tim != NULL; tim = next_tim) {
720                 next_tim = tim->sl_next[0];
721
722                 ret = timer_set_running_state(tim);
723                 if (likely(ret == 0)) {
724                         pprev = &tim->sl_next[0];
725                 } else {
726                         /* another core is trying to re-config this one,
727                          * remove it from local expired list
728                          */
729                         *pprev = next_tim;
730                 }
731         }
732
733         /* update the next to expire timer value */
734         priv_timer[lcore_id].pending_head.expire =
735             (priv_timer[lcore_id].pending_head.sl_next[0] == NULL) ? 0 :
736                 priv_timer[lcore_id].pending_head.sl_next[0]->expire;
737
738         rte_spinlock_unlock(&priv_timer[lcore_id].list_lock);
739
740         /* now scan expired list and call callbacks */
741         for (tim = run_first_tim; tim != NULL; tim = next_tim) {
742                 next_tim = tim->sl_next[0];
743                 priv_timer[lcore_id].updated = 0;
744                 priv_timer[lcore_id].running_tim = tim;
745
746                 /* execute callback function with list unlocked */
747                 tim->f(tim, tim->arg);
748
749                 __TIMER_STAT_ADD(priv_timer, pending, -1);
750                 /* the timer was stopped or reloaded by the callback
751                  * function, we have nothing to do here */
752                 if (priv_timer[lcore_id].updated == 1)
753                         continue;
754
755                 if (tim->period == 0) {
756                         /* remove from done list and mark timer as stopped */
757                         status.state = RTE_TIMER_STOP;
758                         status.owner = RTE_TIMER_NO_OWNER;
759                         /* The "RELEASE" ordering guarantees the memory
760                          * operations above the status update are observed
761                          * before the update by all threads
762                          */
763                         __atomic_store_n(&tim->status.u32, status.u32,
764                                 __ATOMIC_RELEASE);
765                 }
766                 else {
767                         /* keep it in list and mark timer as pending */
768                         rte_spinlock_lock(&priv_timer[lcore_id].list_lock);
769                         status.state = RTE_TIMER_PENDING;
770                         __TIMER_STAT_ADD(priv_timer, pending, 1);
771                         status.owner = (int16_t)lcore_id;
772                         /* The "RELEASE" ordering guarantees the memory
773                          * operations above the status update are observed
774                          * before the update by all threads
775                          */
776                         __atomic_store_n(&tim->status.u32, status.u32,
777                                 __ATOMIC_RELEASE);
778                         __rte_timer_reset(tim, tim->expire + tim->period,
779                                 tim->period, lcore_id, tim->f, tim->arg, 1,
780                                 timer_data);
781                         rte_spinlock_unlock(&priv_timer[lcore_id].list_lock);
782                 }
783         }
784         priv_timer[lcore_id].running_tim = NULL;
785 }
786
787 int
788 rte_timer_manage(void)
789 {
790         struct rte_timer_data *timer_data;
791
792         TIMER_DATA_VALID_GET_OR_ERR_RET(default_data_id, timer_data, -EINVAL);
793
794         __rte_timer_manage(timer_data);
795
796         return 0;
797 }
798
799 int
800 rte_timer_alt_manage(uint32_t timer_data_id,
801                      unsigned int *poll_lcores,
802                      int nb_poll_lcores,
803                      rte_timer_alt_manage_cb_t f)
804 {
805         unsigned int default_poll_lcores[] = {rte_lcore_id()};
806         union rte_timer_status status;
807         struct rte_timer *tim, *next_tim, **pprev;
808         struct rte_timer *run_first_tims[RTE_MAX_LCORE];
809         unsigned int this_lcore = rte_lcore_id();
810         struct rte_timer *prev[MAX_SKIPLIST_DEPTH + 1];
811         uint64_t cur_time;
812         int i, j, ret;
813         int nb_runlists = 0;
814         struct rte_timer_data *data;
815         struct priv_timer *privp;
816         uint32_t poll_lcore;
817
818         TIMER_DATA_VALID_GET_OR_ERR_RET(timer_data_id, data, -EINVAL);
819
820         /* timer manager only runs on EAL thread with valid lcore_id */
821         assert(this_lcore < RTE_MAX_LCORE);
822
823         __TIMER_STAT_ADD(data->priv_timer, manage, 1);
824
825         if (poll_lcores == NULL) {
826                 poll_lcores = default_poll_lcores;
827                 nb_poll_lcores = RTE_DIM(default_poll_lcores);
828         }
829
830         for (i = 0; i < nb_poll_lcores; i++) {
831                 poll_lcore = poll_lcores[i];
832                 privp = &data->priv_timer[poll_lcore];
833
834                 /* optimize for the case where per-cpu list is empty */
835                 if (privp->pending_head.sl_next[0] == NULL)
836                         continue;
837                 cur_time = rte_get_timer_cycles();
838
839 #ifdef RTE_ARCH_64
840                 /* on 64-bit the value cached in the pending_head.expired will
841                  * be updated atomically, so we can consult that for a quick
842                  * check here outside the lock
843                  */
844                 if (likely(privp->pending_head.expire > cur_time))
845                         continue;
846 #endif
847
848                 /* browse ordered list, add expired timers in 'expired' list */
849                 rte_spinlock_lock(&privp->list_lock);
850
851                 /* if nothing to do just unlock and return */
852                 if (privp->pending_head.sl_next[0] == NULL ||
853                     privp->pending_head.sl_next[0]->expire > cur_time) {
854                         rte_spinlock_unlock(&privp->list_lock);
855                         continue;
856                 }
857
858                 /* save start of list of expired timers */
859                 tim = privp->pending_head.sl_next[0];
860
861                 /* break the existing list at current time point */
862                 timer_get_prev_entries(cur_time, poll_lcore, prev,
863                                        data->priv_timer);
864                 for (j = privp->curr_skiplist_depth - 1; j >= 0; j--) {
865                         if (prev[j] == &privp->pending_head)
866                                 continue;
867                         privp->pending_head.sl_next[j] =
868                                 prev[j]->sl_next[j];
869                         if (prev[j]->sl_next[j] == NULL)
870                                 privp->curr_skiplist_depth--;
871
872                         prev[j]->sl_next[j] = NULL;
873                 }
874
875                 /* transition run-list from PENDING to RUNNING */
876                 run_first_tims[nb_runlists] = tim;
877                 pprev = &run_first_tims[nb_runlists];
878                 nb_runlists++;
879
880                 for ( ; tim != NULL; tim = next_tim) {
881                         next_tim = tim->sl_next[0];
882
883                         ret = timer_set_running_state(tim);
884                         if (likely(ret == 0)) {
885                                 pprev = &tim->sl_next[0];
886                         } else {
887                                 /* another core is trying to re-config this one,
888                                  * remove it from local expired list
889                                  */
890                                 *pprev = next_tim;
891                         }
892                 }
893
894                 /* update the next to expire timer value */
895                 privp->pending_head.expire =
896                     (privp->pending_head.sl_next[0] == NULL) ? 0 :
897                         privp->pending_head.sl_next[0]->expire;
898
899                 rte_spinlock_unlock(&privp->list_lock);
900         }
901
902         /* Now process the run lists */
903         while (1) {
904                 bool done = true;
905                 uint64_t min_expire = UINT64_MAX;
906                 int min_idx = 0;
907
908                 /* Find the next oldest timer to process */
909                 for (i = 0; i < nb_runlists; i++) {
910                         tim = run_first_tims[i];
911
912                         if (tim != NULL && tim->expire < min_expire) {
913                                 min_expire = tim->expire;
914                                 min_idx = i;
915                                 done = false;
916                         }
917                 }
918
919                 if (done)
920                         break;
921
922                 tim = run_first_tims[min_idx];
923
924                 /* Move down the runlist from which we picked a timer to
925                  * execute
926                  */
927                 run_first_tims[min_idx] = run_first_tims[min_idx]->sl_next[0];
928
929                 data->priv_timer[this_lcore].updated = 0;
930                 data->priv_timer[this_lcore].running_tim = tim;
931
932                 /* Call the provided callback function */
933                 f(tim);
934
935                 __TIMER_STAT_ADD(data->priv_timer, pending, -1);
936
937                 /* the timer was stopped or reloaded by the callback
938                  * function, we have nothing to do here
939                  */
940                 if (data->priv_timer[this_lcore].updated == 1)
941                         continue;
942
943                 if (tim->period == 0) {
944                         /* remove from done list and mark timer as stopped */
945                         status.state = RTE_TIMER_STOP;
946                         status.owner = RTE_TIMER_NO_OWNER;
947                         /* The "RELEASE" ordering guarantees the memory
948                          * operations above the status update are observed
949                          * before the update by all threads
950                          */
951                         __atomic_store_n(&tim->status.u32, status.u32,
952                                 __ATOMIC_RELEASE);
953                 } else {
954                         /* keep it in list and mark timer as pending */
955                         rte_spinlock_lock(
956                                 &data->priv_timer[this_lcore].list_lock);
957                         status.state = RTE_TIMER_PENDING;
958                         __TIMER_STAT_ADD(data->priv_timer, pending, 1);
959                         status.owner = (int16_t)this_lcore;
960                         /* The "RELEASE" ordering guarantees the memory
961                          * operations above the status update are observed
962                          * before the update by all threads
963                          */
964                         __atomic_store_n(&tim->status.u32, status.u32,
965                                 __ATOMIC_RELEASE);
966                         __rte_timer_reset(tim, tim->expire + tim->period,
967                                 tim->period, this_lcore, tim->f, tim->arg, 1,
968                                 data);
969                         rte_spinlock_unlock(
970                                 &data->priv_timer[this_lcore].list_lock);
971                 }
972
973                 data->priv_timer[this_lcore].running_tim = NULL;
974         }
975
976         return 0;
977 }
978
979 /* Walk pending lists, stopping timers and calling user-specified function */
980 int
981 rte_timer_stop_all(uint32_t timer_data_id, unsigned int *walk_lcores,
982                    int nb_walk_lcores,
983                    rte_timer_stop_all_cb_t f, void *f_arg)
984 {
985         int i;
986         struct priv_timer *priv_timer;
987         uint32_t walk_lcore;
988         struct rte_timer *tim, *next_tim;
989         struct rte_timer_data *timer_data;
990
991         TIMER_DATA_VALID_GET_OR_ERR_RET(timer_data_id, timer_data, -EINVAL);
992
993         for (i = 0; i < nb_walk_lcores; i++) {
994                 walk_lcore = walk_lcores[i];
995                 priv_timer = &timer_data->priv_timer[walk_lcore];
996
997                 rte_spinlock_lock(&priv_timer->list_lock);
998
999                 for (tim = priv_timer->pending_head.sl_next[0];
1000                      tim != NULL;
1001                      tim = next_tim) {
1002                         next_tim = tim->sl_next[0];
1003
1004                         /* Call timer_stop with lock held */
1005                         __rte_timer_stop(tim, 1, timer_data);
1006
1007                         if (f)
1008                                 f(tim, f_arg);
1009                 }
1010
1011                 rte_spinlock_unlock(&priv_timer->list_lock);
1012         }
1013
1014         return 0;
1015 }
1016
1017 int64_t
1018 rte_timer_next_ticks(void)
1019 {
1020         unsigned int lcore_id = rte_lcore_id();
1021         struct rte_timer_data *timer_data;
1022         struct priv_timer *priv_timer;
1023         const struct rte_timer *tm;
1024         uint64_t cur_time;
1025         int64_t left = -ENOENT;
1026
1027         TIMER_DATA_VALID_GET_OR_ERR_RET(default_data_id, timer_data, -EINVAL);
1028
1029         priv_timer = timer_data->priv_timer;
1030         cur_time = rte_get_timer_cycles();
1031
1032         rte_spinlock_lock(&priv_timer[lcore_id].list_lock);
1033         tm = priv_timer[lcore_id].pending_head.sl_next[0];
1034         if (tm) {
1035                 left = tm->expire - cur_time;
1036                 if (left < 0)
1037                         left = 0;
1038         }
1039         rte_spinlock_unlock(&priv_timer[lcore_id].list_lock);
1040
1041         return left;
1042 }
1043
1044 /* dump statistics about timers */
1045 static void
1046 __rte_timer_dump_stats(struct rte_timer_data *timer_data __rte_unused, FILE *f)
1047 {
1048 #ifdef RTE_LIBRTE_TIMER_DEBUG
1049         struct rte_timer_debug_stats sum;
1050         unsigned lcore_id;
1051         struct priv_timer *priv_timer = timer_data->priv_timer;
1052
1053         memset(&sum, 0, sizeof(sum));
1054         for (lcore_id = 0; lcore_id < RTE_MAX_LCORE; lcore_id++) {
1055                 sum.reset += priv_timer[lcore_id].stats.reset;
1056                 sum.stop += priv_timer[lcore_id].stats.stop;
1057                 sum.manage += priv_timer[lcore_id].stats.manage;
1058                 sum.pending += priv_timer[lcore_id].stats.pending;
1059         }
1060         fprintf(f, "Timer statistics:\n");
1061         fprintf(f, "  reset = %"PRIu64"\n", sum.reset);
1062         fprintf(f, "  stop = %"PRIu64"\n", sum.stop);
1063         fprintf(f, "  manage = %"PRIu64"\n", sum.manage);
1064         fprintf(f, "  pending = %"PRIu64"\n", sum.pending);
1065 #else
1066         fprintf(f, "No timer statistics, RTE_LIBRTE_TIMER_DEBUG is disabled\n");
1067 #endif
1068 }
1069
1070 int
1071 rte_timer_dump_stats(FILE *f)
1072 {
1073         return rte_timer_alt_dump_stats(default_data_id, f);
1074 }
1075
1076 int
1077 rte_timer_alt_dump_stats(uint32_t timer_data_id __rte_unused, FILE *f)
1078 {
1079         struct rte_timer_data *timer_data;
1080
1081         TIMER_DATA_VALID_GET_OR_ERR_RET(timer_data_id, timer_data, -EINVAL);
1082
1083         __rte_timer_dump_stats(timer_data, f);
1084
1085         return 0;
1086 }