source: rtems-libbsd/testsuite/thread01/test_main.c @ 0237319

5-freebsd-12
Last change on this file since 0237319 was 0237319, checked in by Sebastian Huber <sebastian.huber@…>, on May 23, 2017 at 11:18:31 AM

Update due to Newlib 2017-06-07 changes

The following files are now provided by Newlib:

  • arpa/inet.h
  • net/if.h
  • netinet/in.h
  • netinet/tcp.h
  • sys/socket.h
  • sys/uio.h
  • sys/un.h

The <sys/param.h> and <sys/cpuset.h> are now compatible enough to be
used directly.

Update #2833.

  • Property mode set to 100644
File size: 6.4 KB
Line 
1/*
2 * Copyright (c) 2013-2014 embedded brains GmbH.  All rights reserved.
3 *
4 *  embedded brains GmbH
5 *  Dornierstr. 4
6 *  82178 Puchheim
7 *  Germany
8 *  <rtems@embedded-brains.de>
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 *    notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 *    notice, this list of conditions and the following disclaimer in the
17 *    documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 */
31
32#include <machine/rtems-bsd-kernel-space.h>
33#include <machine/rtems-bsd-thread.h>
34
35#include <stdlib.h>
36#include <stdio.h>
37#include <string.h>
38#include <assert.h>
39
40#include <sys/types.h>
41#include <sys/param.h>
42#include <sys/proc.h>
43#include <sys/kthread.h>
44#include <sys/errno.h>
45
46#include <rtems/bsd/bsd.h>
47
48#include <rtems.h>
49#include <rtems/libcsupport.h>
50#include <rtems/score/threaddispatch.h>
51#include <rtems/score/wkspace.h>
52
53#define TEST_NAME "LIBBSD THREAD 1"
54
55#define TEST_KTHREAD_ADD ((void *) 0xdeadbeef)
56
57static rtems_id main_task_id;
58
59static char test_kproc_name[] = "kproc";
60
61static struct kproc_desc test_kproc_start_desc;
62
63static char test_kthread_name[] = "kthread";
64
65static struct kthread_desc test_kthread_start_desc;
66
67static void
68test_curthread(const char *name)
69{
70        struct thread *td_0 = rtems_bsd_get_curthread_or_null();
71        struct thread *td_1 = rtems_bsd_get_curthread_or_wait_forever();
72        struct thread *td_2 = curthread;
73
74        assert(td_0 != NULL);
75        assert(td_0 == td_1);
76        assert(td_0 == td_2);
77        assert(strcmp(td_0->td_thread->Join_queue.Queue.name, name) == 0);
78}
79
80static void
81wake_up_main_thread(void)
82{
83        rtems_status_code sc;
84
85        sc = rtems_event_transient_send(main_task_id);
86        assert(sc == RTEMS_SUCCESSFUL);
87}
88
89static void
90wait_for_worker_thread(void)
91{
92        rtems_status_code sc;
93
94        sc = rtems_event_transient_receive(RTEMS_WAIT, RTEMS_NO_TIMEOUT);
95        assert(sc == RTEMS_SUCCESSFUL);
96}
97
98static void
99non_bsd_thread(rtems_task_argument arg)
100{
101        rtems_status_code sc;
102
103        test_curthread("");
104        wake_up_main_thread();
105
106        sc = rtems_task_delete(RTEMS_SELF);
107        assert(sc == RTEMS_SUCCESSFUL);
108}
109
110static void
111test_non_bsd_thread(void)
112{
113        rtems_status_code sc;
114        rtems_id task_id;
115        rtems_resource_snapshot snapshot;
116
117        rtems_resource_snapshot_take(&snapshot);
118
119        sc = rtems_task_create(
120                rtems_build_name('T', 'A', 'S', 'K'),
121                RTEMS_MINIMUM_PRIORITY,
122                RTEMS_MINIMUM_STACK_SIZE,
123                RTEMS_DEFAULT_MODES,
124                RTEMS_FLOATING_POINT,
125                &task_id
126        );
127        assert(sc == RTEMS_SUCCESSFUL);
128
129        sc = rtems_task_start(task_id, non_bsd_thread, 0);
130        assert(sc == RTEMS_SUCCESSFUL);
131
132        wait_for_worker_thread();
133
134        assert(rtems_resource_snapshot_check(&snapshot));
135}
136
137static void
138test_kproc_start_proc(void)
139{
140        test_curthread(&test_kproc_name[0]);
141        wake_up_main_thread();
142        kproc_exit(0);
143}
144
145static void
146test_kproc_start(void)
147{
148        rtems_resource_snapshot snapshot;
149        struct proc *pr = NULL;
150        struct kproc_desc *kpd = &test_kproc_start_desc;
151
152        puts("test kproc_start()");
153
154        rtems_resource_snapshot_take(&snapshot);
155
156        kpd->arg0 = &test_kproc_name[0];
157        kpd->func = test_kproc_start_proc,
158        kpd->global_procpp = &pr;
159
160        kproc_start(kpd);
161        wait_for_worker_thread();
162
163        assert(pr != NULL);
164
165        assert(rtems_resource_snapshot_check(&snapshot));
166}
167
168static void
169test_kthread_start_thread(void)
170{
171        test_curthread(&test_kthread_name[0]);
172        wake_up_main_thread();
173        kthread_exit();
174}
175
176static void
177test_kthread_start(void)
178{
179        rtems_resource_snapshot snapshot;
180        struct thread *td = NULL;
181        struct kthread_desc *ktd = &test_kthread_start_desc;
182
183        puts("test kthread_start()");
184
185        rtems_resource_snapshot_take(&snapshot);
186
187        ktd->arg0 = &test_kthread_name[0];
188        ktd->func = test_kthread_start_thread,
189        ktd->global_threadpp = &td;
190
191        kthread_start(ktd);
192        wait_for_worker_thread();
193
194        assert(td != NULL);
195
196        assert(rtems_resource_snapshot_check(&snapshot));
197}
198
199static void
200test_kthread_add_thread(void *arg)
201{
202        test_curthread(&test_kthread_name[0]);
203
204        assert(arg == TEST_KTHREAD_ADD);
205
206        wake_up_main_thread();
207        kthread_exit();
208}
209
210static void
211test_kthread_add(void)
212{
213        rtems_resource_snapshot snapshot;
214        void *greedy;
215        uintptr_t take_away = 2 * rtems_bsd_get_task_stack_size("");
216
217        puts("test kthread_add()");
218
219        greedy = rtems_workspace_greedy_allocate(&take_away, 1);
220
221        rtems_resource_snapshot_take(&snapshot);
222
223        assert(rtems_configuration_get_unified_work_area());
224
225        while (take_away > 0) {
226                void *away;
227                bool ok;
228
229                ok = rtems_workspace_allocate(take_away, &away);
230                if (ok) {
231                        struct thread *td = NULL;
232                        int eno;
233
234                        eno = kthread_add(
235                                test_kthread_add_thread,
236                                TEST_KTHREAD_ADD,
237                                NULL,
238                                &td,
239                                0,
240                                0,
241                                "%s",
242                                &test_kthread_name[0]
243                        );
244
245                        ok = rtems_workspace_free(away);
246                        assert(ok);
247
248                        if (eno == 0) {
249                                wait_for_worker_thread();
250                                assert(td != NULL);
251
252                                break;
253                        } else {
254                                assert(eno == ENOMEM);
255                                assert(rtems_resource_snapshot_check(&snapshot));
256                        }
257                }
258
259                --take_away;
260        }
261
262        assert(take_away > 0);
263
264        rtems_workspace_greedy_free(greedy);
265}
266
267static void
268test_rtems_bsd_get_curthread_or_null(void)
269{
270        rtems_resource_snapshot snapshot;
271        void *greedy;
272
273        puts("test rtems_bsd_get_curthread_or_null()");
274
275        rtems_resource_snapshot_take(&snapshot);
276
277        greedy = rtems_workspace_greedy_allocate(NULL, 0);
278        assert(rtems_bsd_get_curthread_or_null() == NULL);
279        rtems_workspace_greedy_free(greedy);
280
281        rtems_resource_snapshot_take(&snapshot);
282}
283
284static void
285test_main(void)
286{
287        main_task_id = rtems_task_self();
288
289        test_non_bsd_thread();
290        test_kproc_start();
291        test_kthread_start();
292        test_kthread_add();
293        test_rtems_bsd_get_curthread_or_null();
294
295        exit(0);
296}
297
298#include <rtems/bsd/test/default-init.h>
Note: See TracBrowser for help on using the repository browser.