app/testpmd: use existing checksum API in flowgen engine
[dpdk.git] / examples / performance-thread / common / lthread_mutex.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2015 Intel Corporation
3  */
4
5 #include <stdio.h>
6 #include <stdlib.h>
7 #include <string.h>
8 #include <stdint.h>
9 #include <stddef.h>
10 #include <limits.h>
11 #include <inttypes.h>
12 #include <unistd.h>
13 #include <pthread.h>
14 #include <fcntl.h>
15 #include <sys/time.h>
16 #include <sys/mman.h>
17
18 #include <rte_per_lcore.h>
19 #include <rte_log.h>
20 #include <rte_spinlock.h>
21 #include <rte_common.h>
22
23 #include "lthread_api.h"
24 #include "lthread_int.h"
25 #include "lthread_mutex.h"
26 #include "lthread_sched.h"
27 #include "lthread_queue.h"
28 #include "lthread_objcache.h"
29 #include "lthread_diag.h"
30
31 /*
32  * Create a mutex
33  */
34 int
35 lthread_mutex_init(char *name, struct lthread_mutex **mutex,
36                    __rte_unused const struct lthread_mutexattr *attr)
37 {
38         struct lthread_mutex *m;
39
40         if (mutex == NULL)
41                 return POSIX_ERRNO(EINVAL);
42
43
44         m = _lthread_objcache_alloc((THIS_SCHED)->mutex_cache);
45         if (m == NULL)
46                 return POSIX_ERRNO(EAGAIN);
47
48         m->blocked = _lthread_queue_create("blocked queue");
49         if (m->blocked == NULL) {
50                 _lthread_objcache_free((THIS_SCHED)->mutex_cache, m);
51                 return POSIX_ERRNO(EAGAIN);
52         }
53
54         if (name == NULL)
55                 strncpy(m->name, "no name", sizeof(m->name));
56         else
57                 strncpy(m->name, name, sizeof(m->name));
58         m->name[sizeof(m->name)-1] = 0;
59
60         m->root_sched = THIS_SCHED;
61         m->owner = NULL;
62
63         rte_atomic64_init(&m->count);
64
65         DIAG_CREATE_EVENT(m, LT_DIAG_MUTEX_CREATE);
66         /* success */
67         (*mutex) = m;
68         return 0;
69 }
70
71 /*
72  * Destroy a mutex
73  */
74 int lthread_mutex_destroy(struct lthread_mutex *m)
75 {
76         if ((m == NULL) || (m->blocked == NULL)) {
77                 DIAG_EVENT(m, LT_DIAG_MUTEX_DESTROY, m, POSIX_ERRNO(EINVAL));
78                 return POSIX_ERRNO(EINVAL);
79         }
80
81         if (m->owner == NULL) {
82                 /* try to delete the blocked queue */
83                 if (_lthread_queue_destroy(m->blocked) < 0) {
84                         DIAG_EVENT(m, LT_DIAG_MUTEX_DESTROY,
85                                         m, POSIX_ERRNO(EBUSY));
86                         return POSIX_ERRNO(EBUSY);
87                 }
88
89                 /* free the mutex to cache */
90                 _lthread_objcache_free(m->root_sched->mutex_cache, m);
91                 DIAG_EVENT(m, LT_DIAG_MUTEX_DESTROY, m, 0);
92                 return 0;
93         }
94         /* can't do its still in use */
95         DIAG_EVENT(m, LT_DIAG_MUTEX_DESTROY, m, POSIX_ERRNO(EBUSY));
96         return POSIX_ERRNO(EBUSY);
97 }
98
99 /*
100  * Try to obtain a mutex
101  */
102 int lthread_mutex_lock(struct lthread_mutex *m)
103 {
104         struct lthread *lt = THIS_LTHREAD;
105
106         if ((m == NULL) || (m->blocked == NULL)) {
107                 DIAG_EVENT(m, LT_DIAG_MUTEX_LOCK, m, POSIX_ERRNO(EINVAL));
108                 return POSIX_ERRNO(EINVAL);
109         }
110
111         /* allow no recursion */
112         if (m->owner == lt) {
113                 DIAG_EVENT(m, LT_DIAG_MUTEX_LOCK, m, POSIX_ERRNO(EDEADLK));
114                 return POSIX_ERRNO(EDEADLK);
115         }
116
117         for (;;) {
118                 rte_atomic64_inc(&m->count);
119                 do {
120                         if (rte_atomic64_cmpset
121                             ((uint64_t *) &m->owner, 0, (uint64_t) lt)) {
122                                 /* happy days, we got the lock */
123                                 DIAG_EVENT(m, LT_DIAG_MUTEX_LOCK, m, 0);
124                                 return 0;
125                         }
126                         /* spin due to race with unlock when
127                         * nothing was blocked
128                         */
129                 } while ((rte_atomic64_read(&m->count) == 1) &&
130                                 (m->owner == NULL));
131
132                 /* queue the current thread in the blocked queue
133                  * we defer this to after we return to the scheduler
134                  * to ensure that the current thread context is saved
135                  * before unlock could result in it being dequeued and
136                  * resumed
137                  */
138                 DIAG_EVENT(m, LT_DIAG_MUTEX_BLOCKED, m, lt);
139                 lt->pending_wr_queue = m->blocked;
140                 /* now relinquish cpu */
141                 _suspend();
142                 /* resumed, must loop and compete for the lock again */
143         }
144         return 0;
145 }
146
147 /* try to lock a mutex but don't block */
148 int lthread_mutex_trylock(struct lthread_mutex *m)
149 {
150         struct lthread *lt = THIS_LTHREAD;
151
152         if ((m == NULL) || (m->blocked == NULL)) {
153                 DIAG_EVENT(m, LT_DIAG_MUTEX_TRYLOCK, m, POSIX_ERRNO(EINVAL));
154                 return POSIX_ERRNO(EINVAL);
155         }
156
157         if (m->owner == lt) {
158                 /* no recursion */
159                 DIAG_EVENT(m, LT_DIAG_MUTEX_TRYLOCK, m, POSIX_ERRNO(EDEADLK));
160                 return POSIX_ERRNO(EDEADLK);
161         }
162
163         rte_atomic64_inc(&m->count);
164         if (rte_atomic64_cmpset
165             ((uint64_t *) &m->owner, (uint64_t) NULL, (uint64_t) lt)) {
166                 /* got the lock */
167                 DIAG_EVENT(m, LT_DIAG_MUTEX_TRYLOCK, m, 0);
168                 return 0;
169         }
170
171         /* failed so return busy */
172         rte_atomic64_dec(&m->count);
173         DIAG_EVENT(m, LT_DIAG_MUTEX_TRYLOCK, m, POSIX_ERRNO(EBUSY));
174         return POSIX_ERRNO(EBUSY);
175 }
176
177 /*
178  * Unlock a mutex
179  */
180 int lthread_mutex_unlock(struct lthread_mutex *m)
181 {
182         struct lthread *lt = THIS_LTHREAD;
183         struct lthread *unblocked;
184
185         if ((m == NULL) || (m->blocked == NULL)) {
186                 DIAG_EVENT(m, LT_DIAG_MUTEX_UNLOCKED, m, POSIX_ERRNO(EINVAL));
187                 return POSIX_ERRNO(EINVAL);
188         }
189
190         /* fail if its owned */
191         if (m->owner != lt || m->owner == NULL) {
192                 DIAG_EVENT(m, LT_DIAG_MUTEX_UNLOCKED, m, POSIX_ERRNO(EPERM));
193                 return POSIX_ERRNO(EPERM);
194         }
195
196         rte_atomic64_dec(&m->count);
197         /* if there are blocked threads then make one ready */
198         while (rte_atomic64_read(&m->count) > 0) {
199                 unblocked = _lthread_queue_remove(m->blocked);
200
201                 if (unblocked != NULL) {
202                         rte_atomic64_dec(&m->count);
203                         DIAG_EVENT(m, LT_DIAG_MUTEX_UNLOCKED, m, unblocked);
204                         RTE_ASSERT(unblocked->sched != NULL);
205                         _ready_queue_insert((struct lthread_sched *)
206                                             unblocked->sched, unblocked);
207                         break;
208                 }
209         }
210         /* release the lock */
211         m->owner = NULL;
212         return 0;
213 }
214
215 /*
216  * return the diagnostic ref val stored in a mutex
217  */
218 uint64_t
219 lthread_mutex_diag_ref(struct lthread_mutex *m)
220 {
221         if (m == NULL)
222                 return 0;
223         return m->diag_ref;
224 }