source: rtems-libbsd/rtemsbsd/rtems/rtems-kernel-thread.c @ 64163f3

5-freebsd-12
Last change on this file since 64163f3 was 64163f3, checked in by Sebastian Huber <sebastian.huber@…>, on May 17, 2017 at 8:23:56 AM

Initialize BSD user extension earlier

  • Property mode set to 100644
File size: 8.1 KB
Line 
1/**
2 * @file
3 *
4 * @ingroup rtems_bsd_rtems
5 *
6 * @brief TODO.
7 */
8
9/*
10 * Copyright (c) 2009-2015 embedded brains GmbH.  All rights reserved.
11 *
12 *  embedded brains GmbH
13 *  Dornierstr. 4
14 *  82178 Puchheim
15 *  Germany
16 *  <rtems@embedded-brains.de>
17 *
18 * Redistribution and use in source and binary forms, with or without
19 * modification, are permitted provided that the following conditions
20 * are met:
21 * 1. Redistributions of source code must retain the above copyright
22 *    notice, this list of conditions and the following disclaimer.
23 * 2. Redistributions in binary form must reproduce the above copyright
24 *    notice, this list of conditions and the following disclaimer in the
25 *    documentation and/or other materials provided with the distribution.
26 *
27 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
28 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
31 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
32 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
33 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
34 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
35 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
36 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
37 * SUCH DAMAGE.
38 */
39
40#include <machine/rtems-bsd-kernel-space.h>
41#include <machine/rtems-bsd-thread.h>
42#include <machine/rtems-bsd-support.h>
43
44#include <sys/param.h>
45#include <sys/types.h>
46#include <sys/systm.h>
47#include <sys/kernel.h>
48#include <sys/proc.h>
49#include <sys/kthread.h>
50#include <sys/malloc.h>
51#include <sys/selinfo.h>
52#include <sys/sleepqueue.h>
53
54#include <rtems/bsd/bsd.h>
55
56#undef ticks
57
58#include <rtems/score/objectimpl.h>
59#include <rtems/score/statesimpl.h>
60#include <rtems/score/threaddispatch.h>
61#include <rtems/score/thread.h>
62#include <rtems/score/threadimpl.h>
63#include <rtems/score/threadqimpl.h>
64
65static size_t rtems_bsd_extension_index;
66
67static CHAIN_DEFINE_EMPTY(rtems_bsd_thread_delay_start_chain);
68
69static bool rtems_bsd_thread_ready_to_start;
70
71struct thread *
72rtems_bsd_get_thread(const Thread_Control *thread)
73{
74        return thread->extensions[rtems_bsd_extension_index];
75}
76
77static Thread_Control *
78rtems_bsd_get_thread_by_id(rtems_id task_id)
79{
80        Thread_Control *thread;
81        ISR_lock_Context lock_context;
82
83        thread = _Thread_Get(task_id, &lock_context);
84        if (thread != NULL) {
85                _ISR_lock_ISR_enable(&lock_context);
86        }
87
88        return (thread);
89}
90
91struct thread *
92rtems_bsd_thread_create(Thread_Control *thread, int wait)
93{
94        struct thread *td = malloc(sizeof(*td), M_TEMP, M_ZERO | wait);
95        struct sleepqueue *sq = sleepq_alloc();
96
97        if (td != NULL && sq != NULL) {
98                td->td_thread = thread;
99                td->td_sleepqueue = sq;
100        } else {
101                free(td, M_TEMP);
102                sleepq_free(sq);
103                td = NULL;
104        }
105
106        thread->extensions[rtems_bsd_extension_index] = td;
107
108        return td;
109}
110
111static struct thread *
112rtems_bsd_get_curthread(int wait)
113{
114        Thread_Control *executing = _Thread_Get_executing();
115        struct thread *td = rtems_bsd_get_thread(executing);
116
117        if (td == NULL) {
118                td = rtems_bsd_thread_create(executing, wait);
119        }
120
121        return td;
122}
123
124struct thread *
125rtems_bsd_get_curthread_or_wait_forever(void)
126{
127        return rtems_bsd_get_curthread(M_WAITOK);
128}
129
130struct thread *
131rtems_bsd_get_curthread_or_null(void)
132{
133        return rtems_bsd_get_curthread(0);
134}
135
136static bool
137rtems_bsd_is_bsd_thread(Thread_Control *thread)
138{
139        return thread->Object.name.name_u32 == BSD_TASK_NAME;
140}
141
142static bool
143rtems_bsd_extension_thread_create(
144        Thread_Control *executing,
145        Thread_Control *created
146)
147{
148        bool ok;
149
150        if (rtems_bsd_is_bsd_thread(created)) {
151                struct thread *td = rtems_bsd_thread_create(created, 0);
152
153                ok = td != NULL;
154        } else {
155                ok = true;
156        }
157
158        return ok;
159}
160
161static void
162rtems_bsd_extension_thread_delete(
163        Thread_Control *executing,
164        Thread_Control *deleted
165)
166{
167        struct thread *td = rtems_bsd_get_thread(deleted);
168
169        if (td != NULL) {
170                seltdfini(td);
171                sleepq_free(td->td_sleepqueue);
172                free(td, M_TEMP);
173        }
174}
175
176static const rtems_extensions_table rtems_bsd_extensions = {
177        .thread_create = rtems_bsd_extension_thread_create,
178        .thread_delete = rtems_bsd_extension_thread_delete
179};
180
181static void
182rtems_bsd_threads_init_early(void *arg)
183{
184        rtems_id ext_id;
185        rtems_status_code sc;
186
187        (void) arg;
188
189        sc = rtems_extension_create(
190                BSD_TASK_NAME,
191                &rtems_bsd_extensions,
192                &ext_id
193        );
194        if (sc != RTEMS_SUCCESSFUL) {
195                BSD_PANIC("cannot create extension");
196        }
197
198        rtems_bsd_extension_index = rtems_object_id_get_index(ext_id);
199}
200
201static void
202rtems_bsd_threads_init_late(void *arg)
203{
204        Chain_Control *chain = &rtems_bsd_thread_delay_start_chain;
205        Chain_Node *node;
206
207        (void) arg;
208
209        while ((node = _Chain_Get_unprotected(chain)) != NULL) {
210                Thread_Control *thread = (Thread_Control *) node;
211                rtems_status_code sc;
212
213                sc = rtems_task_start(thread->Object.id,
214                    thread->Start.Entry.Kinds.Numeric.entry,
215                    thread->Start.Entry.Kinds.Numeric.argument);
216                BSD_ASSERT(sc == RTEMS_SUCCESSFUL);
217        }
218
219        rtems_bsd_thread_ready_to_start = true;
220}
221
222SYSINIT(rtems_bsd_threads_early, SI_SUB_TUNABLES, SI_ORDER_ANY,
223    rtems_bsd_threads_init_early, NULL);
224
225SYSINIT(rtems_bsd_threads_late, SI_SUB_LAST, SI_ORDER_ANY,
226    rtems_bsd_threads_init_late, NULL);
227
228static int
229rtems_bsd_thread_start(struct thread **td_ptr, void (*func)(void *), void *arg,
230    int flags, int pages, const char *fmt, va_list ap)
231{
232        int eno = 0;
233        rtems_status_code sc;
234        rtems_id task_id;
235        struct thread *td;
236        char name[32];
237
238        BSD_ASSERT(pages >= 0);
239
240        vsnprintf(name, sizeof(name), fmt, ap);
241
242        sc = rtems_task_create(
243                BSD_TASK_NAME,
244                rtems_bsd_get_task_priority(name),
245                rtems_bsd_get_task_stack_size(name)
246                        + (size_t) pages * PAGE_SIZE,
247                RTEMS_DEFAULT_MODES,
248                RTEMS_DEFAULT_ATTRIBUTES,
249                &task_id
250        );
251        if (sc == RTEMS_SUCCESSFUL) {
252                Thread_Control *thread = rtems_bsd_get_thread_by_id(task_id);
253
254                BSD_ASSERT(thread != NULL);
255
256                td = rtems_bsd_get_thread(thread);
257                BSD_ASSERT(td != NULL);
258
259                _Thread_Set_name(thread, name);
260
261                if (rtems_bsd_thread_ready_to_start) {
262                        sc = rtems_task_start(task_id, (rtems_task_entry) func,
263                            (rtems_task_argument) arg);
264                        BSD_ASSERT(sc == RTEMS_SUCCESSFUL);
265                } else {
266                        thread->Start.Entry.Kinds.Numeric.entry =
267                            (void (*)(Thread_Entry_numeric_type))func;
268                        thread->Start.Entry.Kinds.Numeric.argument =
269                            (Thread_Entry_numeric_type)arg;
270                        _Chain_Append_unprotected(
271                            &rtems_bsd_thread_delay_start_chain,
272                            &thread->Object.Node);
273                }
274
275                if (td_ptr != NULL) {
276                        *td_ptr = td;
277                }
278        } else {
279                eno = ENOMEM;
280        }
281
282        return eno;
283}
284
285static __dead2 void
286rtems_bsd_thread_delete(void)
287{
288        rtems_task_delete(RTEMS_SELF);
289        BSD_PANIC("delete self failed");
290}
291
292void
293kproc_start(const void *udata)
294{
295        const struct kproc_desc *pd = udata;
296        int eno = kproc_create((void (*)(void *))pd->func, NULL, pd->global_procpp, 0, 0, "%s", pd->arg0);
297
298        BSD_ASSERT(eno == 0);
299}
300
301int
302kproc_create(void (*func)(void *), void *arg, struct proc **newpp, int flags, int pages, const char *fmt, ...)
303{
304        int eno = 0;
305        va_list ap;
306
307        va_start(ap, fmt);
308        eno = rtems_bsd_thread_start(newpp, func, arg, flags, pages, fmt, ap);
309        va_end(ap);
310
311        return eno;
312}
313
314void
315kproc_exit(int ecode)
316{
317        rtems_bsd_thread_delete();
318}
319
320void
321kthread_start(const void *udata)
322{
323        const struct kthread_desc *td = udata;
324        int eno = kthread_add((void (*)(void *)) td->func, NULL, NULL, td->global_threadpp, 0, 0, "%s", td->arg0);
325
326        BSD_ASSERT(eno == 0);
327}
328
329int
330kthread_add(void (*func)(void *), void *arg, struct proc *p, struct thread **newtdp, int flags, int pages, const char *fmt, ...)
331{
332        int eno = 0;
333        va_list ap;
334
335        va_start(ap, fmt);
336        eno = rtems_bsd_thread_start(newtdp, func, arg, flags, pages, fmt, ap);
337        va_end(ap);
338
339        return eno;
340}
341
342void
343kthread_exit(void)
344{
345        rtems_bsd_thread_delete();
346}
347
348int
349kproc_kthread_add(void (*func)(void *), void *arg, struct proc **procptr, struct thread **tdptr, int flags, int pages, const char * procname, const char *fmt, ...)
350{
351        int eno = 0;
352        va_list ap;
353
354        va_start(ap, fmt);
355        eno = rtems_bsd_thread_start(tdptr, func, arg, flags, pages, fmt, ap);
356        va_end(ap);
357
358        return eno;
359}
Note: See TracBrowser for help on using the repository browser.