lib/librte_eal/windows/eal_thread.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2019 Intel Corporation
   3  */
   4
   5 #include <io.h>
   6
   7 #include <rte_atomic.h>
   8 #include <rte_debug.h>
   9 #include <rte_launch.h>
  10 #include <rte_lcore.h>
  11 #include <rte_per_lcore.h>
  12 #include <rte_common.h>
  13 #include <rte_memory.h>
  14 #include <eal_thread.h>
  15
  16 #include "eal_private.h"
  17 #include "eal_windows.h"
  18
  19 RTE_DEFINE_PER_LCORE(unsigned int, _lcore_id) = LCORE_ID_ANY;
  20 RTE_DEFINE_PER_LCORE(unsigned int, _socket_id) = (unsigned int)SOCKET_ID_ANY;
  21 RTE_DEFINE_PER_LCORE(rte_cpuset_t, _cpuset);
  22
  23 /*
  24  * Send a message to a slave lcore identified by slave_id to call a
  25  * function f with argument arg. Once the execution is done, the
  26  * remote lcore switch in FINISHED state.
  27  */
  28 int
  29 rte_eal_remote_launch(lcore_function_t *f, void *arg, unsigned int slave_id)
  30 {
  31         int n;
  32         char c = 0;
  33         int m2s = lcore_config[slave_id].pipe_master2slave[1];
  34         int s2m = lcore_config[slave_id].pipe_slave2master[0];
  35
  36         if (lcore_config[slave_id].state != WAIT)
  37                 return -EBUSY;
  38
  39         lcore_config[slave_id].f = f;
  40         lcore_config[slave_id].arg = arg;
  41
  42         /* send message */
  43         n = 0;
  44         while (n == 0 || (n < 0 && errno == EINTR))
  45                 n = _write(m2s, &c, 1);
  46         if (n < 0)
  47                 rte_panic("cannot write on configuration pipe\n");
  48
  49         /* wait ack */
  50         do {
  51                 n = _read(s2m, &c, 1);
  52         } while (n < 0 && errno == EINTR);
  53
  54         if (n <= 0)
  55                 rte_panic("cannot read on configuration pipe\n");
  56
  57         return 0;
  58 }
  59
  60 void
  61 eal_thread_init_master(unsigned int lcore_id)
  62 {
  63         /* set the lcore ID in per-lcore memory area */
  64         RTE_PER_LCORE(_lcore_id) = lcore_id;
  65 }
  66
  67 /* main loop of threads */
  68 void *
  69 eal_thread_loop(void *arg __rte_unused)
  70 {
  71         char c;
  72         int n, ret;
  73         unsigned int lcore_id;
  74         pthread_t thread_id;
  75         int m2s, s2m;
  76         char cpuset[RTE_CPU_AFFINITY_STR_LEN];
  77
  78         thread_id = pthread_self();
  79
  80         /* retrieve our lcore_id from the configuration structure */
  81         RTE_LCORE_FOREACH_SLAVE(lcore_id) {
  82                 if (thread_id == lcore_config[lcore_id].thread_id)
  83                         break;
  84         }
  85         if (lcore_id == RTE_MAX_LCORE)
  86                 rte_panic("cannot retrieve lcore id\n");
  87
  88         m2s = lcore_config[lcore_id].pipe_master2slave[0];
  89         s2m = lcore_config[lcore_id].pipe_slave2master[1];
  90
  91         /* set the lcore ID in per-lcore memory area */
  92         RTE_PER_LCORE(_lcore_id) = lcore_id;
  93
  94         RTE_LOG(DEBUG, EAL, "lcore %u is ready (tid=%zx;cpuset=[%s])\n",
  95                 lcore_id, (uintptr_t)thread_id, cpuset);
  96
  97         /* read on our pipe to get commands */
  98         while (1) {
  99                 void *fct_arg;
 100
 101                 /* wait command */
 102                 do {
 103                         n = _read(m2s, &c, 1);
 104                 } while (n < 0 && errno == EINTR);
 105
 106                 if (n <= 0)
 107                         rte_panic("cannot read on configuration pipe\n");
 108
 109                 lcore_config[lcore_id].state = RUNNING;
 110
 111                 /* send ack */
 112                 n = 0;
 113                 while (n == 0 || (n < 0 && errno == EINTR))
 114                         n = _write(s2m, &c, 1);
 115                 if (n < 0)
 116                         rte_panic("cannot write on configuration pipe\n");
 117
 118                 if (lcore_config[lcore_id].f == NULL)
 119                         rte_panic("NULL function pointer\n");
 120
 121                 /* call the function and store the return value */
 122                 fct_arg = lcore_config[lcore_id].arg;
 123                 ret = lcore_config[lcore_id].f(fct_arg);
 124                 lcore_config[lcore_id].ret = ret;
 125                 rte_wmb();
 126
 127                 /* when a service core returns, it should go directly to WAIT
 128                  * state, because the application will not lcore_wait() for it.
 129                  */
 130                 if (lcore_config[lcore_id].core_role == ROLE_SERVICE)
 131                         lcore_config[lcore_id].state = WAIT;
 132                 else
 133                         lcore_config[lcore_id].state = FINISHED;
 134         }
 135 }
 136
 137 /* function to create threads */
 138 int
 139 eal_thread_create(pthread_t *thread)
 140 {
 141         HANDLE th;
 142
 143         th = CreateThread(NULL, 0,
 144                 (LPTHREAD_START_ROUTINE)(ULONG_PTR)eal_thread_loop,
 145                                                 NULL, 0, (LPDWORD)thread);
 146         if (!th)
 147                 return -1;
 148
 149         SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);
 150         SetThreadPriority(th, THREAD_PRIORITY_TIME_CRITICAL);
 151
 152         return 0;
 153 }
 154
 155 /* get current thread ID */
 156 int
 157 rte_sys_gettid(void)
 158 {
 159         return GetCurrentThreadId();
 160 }
 161
 162 int
 163 rte_thread_setname(__rte_unused pthread_t id, __rte_unused const char *name)
 164 {
 165         /* TODO */
 166         /* This is a stub, not the expected result */
 167         return 0;
 168 }