sptests/spscheduler01/init.c

0001 /* SPDX-License-Identifier: BSD-2-Clause */
0002
0003 /*
0004  * Copyright (C) 2014, 2020 embedded brains GmbH & Co. KG
0005  *
0006  * Redistribution and use in source and binary forms, with or without
0007  * modification, are permitted provided that the following conditions
0008  * are met:
0009  * 1. Redistributions of source code must retain the above copyright
0010  *    notice, this list of conditions and the following disclaimer.
0011  * 2. Redistributions in binary form must reproduce the above copyright
0012  *    notice, this list of conditions and the following disclaimer in the
0013  *    documentation and/or other materials provided with the distribution.
0014  *
0015  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
0016  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
0017  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
0018  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
0019  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
0020  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
0021  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
0022  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
0023  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
0024  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
0025  * POSSIBILITY OF SUCH DAMAGE.
0026  */
0027
0028 #define _GNU_SOURCE
0029
0030 #ifdef HAVE_CONFIG_H
0031 #include "config.h"
0032 #endif
0033
0034 #include <rtems.h>
0035 #include <rtems/libcsupport.h>
0036
0037 #include <errno.h>
0038 #include <limits.h>
0039 #include <string.h>
0040 #include <pthread.h>
0041
0042 #include "tmacros.h"
0043
0044 const char rtems_test_name[] = "SPSCHEDULER 1";
0045
0046 #define BLUE rtems_build_name('b', 'l', 'u', 'e')
0047
0048 #define RED rtems_build_name('r', 'e', 'd', ' ')
0049
0050 #define BIG_NUM_CPUS (2 * CHAR_BIT * sizeof(cpu_set_t))
0051
0052 static const rtems_id invalid_id = 1;
0053
0054 static rtems_id master_id;
0055
0056 static rtems_id sema_id;
0057
0058 static void assert_eno(rtems_status_code sc, int eno)
0059 {
0060   switch (sc) {
0061     case RTEMS_SUCCESSFUL:
0062       rtems_test_assert(eno == 0);
0063       break;
0064     case RTEMS_INVALID_ADDRESS:
0065       rtems_test_assert(eno == EFAULT);
0066       break;
0067     case RTEMS_INVALID_ID:
0068       rtems_test_assert(eno == ESRCH);
0069       break;
0070     case RTEMS_INVALID_NUMBER:
0071     case RTEMS_INVALID_SIZE:
0072       rtems_test_assert(eno == EINVAL);
0073       break;
0074     default:
0075       rtems_test_assert(0);
0076   }
0077 }
0078
0079 static rtems_status_code task_get_affinity(
0080   rtems_id id,
0081   size_t cpusetsize,
0082   cpu_set_t *cpuset
0083 )
0084 {
0085   rtems_status_code sc;
0086   int eno;
0087   cpu_set_t *cpusetbig;
0088
0089   sc = rtems_task_get_affinity(id, cpusetsize, cpuset);
0090
0091   if (cpuset != NULL) {
0092     cpusetbig = CPU_ALLOC(BIG_NUM_CPUS);
0093     rtems_test_assert(cpusetbig != NULL);
0094
0095     memcpy(cpusetbig, cpuset, cpusetsize);
0096   } else {
0097     cpusetbig = NULL;
0098   }
0099
0100   eno = pthread_getaffinity_np(id, cpusetsize, cpusetbig);
0101
0102   if (cpuset != NULL) {
0103     rtems_test_assert(CPU_EQUAL_S(cpusetsize, cpusetbig, cpuset));
0104     CPU_FREE(cpusetbig);
0105   }
0106
0107   assert_eno(sc, eno);
0108
0109   return sc;
0110 }
0111
0112 static rtems_status_code task_set_affinity(
0113   rtems_id id,
0114   size_t cpusetsize,
0115   const cpu_set_t *cpuset
0116 )
0117 {
0118   rtems_status_code sc;
0119   int eno;
0120
0121   sc = rtems_task_set_affinity(id, cpusetsize, cpuset);
0122   eno = pthread_setaffinity_np(id, cpusetsize, cpuset);
0123   assert_eno(sc, eno);
0124
0125   return sc;
0126 }
0127
0128 static void test_task_get_set_affinity(void)
0129 {
0130   rtems_id self_id = rtems_task_self();
0131   rtems_id task_id;
0132   rtems_status_code sc;
0133   cpu_set_t cpusetone;
0134   cpu_set_t cpusetall;
0135   cpu_set_t cpuset;
0136   size_t cpusetbigsize = CPU_ALLOC_SIZE(BIG_NUM_CPUS);
0137   cpu_set_t *cpusetbigone;
0138   cpu_set_t *cpusetbig;
0139
0140   CPU_ZERO(&cpusetone);
0141   CPU_SET(0, &cpusetone);
0142
0143   CPU_FILL(&cpusetall);
0144
0145   sc = rtems_task_create(
0146     rtems_build_name('T', 'A', 'S', 'K'),
0147     2,
0148     RTEMS_MINIMUM_STACK_SIZE,
0149     RTEMS_DEFAULT_MODES,
0150     RTEMS_DEFAULT_ATTRIBUTES,
0151     &task_id
0152   );
0153   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0154
0155   sc = task_get_affinity(RTEMS_SELF, sizeof(cpuset), NULL);
0156   rtems_test_assert(sc == RTEMS_INVALID_ADDRESS);
0157
0158   sc = task_set_affinity(RTEMS_SELF, sizeof(cpuset), NULL);
0159   rtems_test_assert(sc == RTEMS_INVALID_ADDRESS);
0160
0161   sc = task_get_affinity(RTEMS_SELF, 0, &cpuset);
0162   rtems_test_assert(sc == RTEMS_INVALID_SIZE);
0163
0164   sc = task_set_affinity(RTEMS_SELF, 0, &cpuset);
0165   rtems_test_assert(sc == RTEMS_INVALID_NUMBER);
0166
0167   sc = task_get_affinity(invalid_id, sizeof(cpuset), &cpuset);
0168   rtems_test_assert(sc == RTEMS_INVALID_ID);
0169
0170   sc = task_set_affinity(invalid_id, sizeof(cpuset), &cpuset);
0171   rtems_test_assert(sc == RTEMS_INVALID_ID);
0172
0173   sc = task_get_affinity(RTEMS_SELF, sizeof(cpuset), &cpuset);
0174   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0175
0176   rtems_test_assert(CPU_EQUAL(&cpuset, &cpusetone));
0177
0178   sc = task_set_affinity(RTEMS_SELF, sizeof(cpuset), &cpuset);
0179   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0180
0181   sc = task_set_affinity(self_id, sizeof(cpuset), &cpuset);
0182   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0183
0184   sc = task_set_affinity(task_id, sizeof(cpuset), &cpuset);
0185   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0186
0187   sc = task_get_affinity(task_id, sizeof(cpuset), &cpuset);
0188   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0189
0190   rtems_test_assert(CPU_EQUAL(&cpuset, &cpusetone));
0191
0192   sc = task_set_affinity(RTEMS_SELF, sizeof(cpusetall), &cpusetall);
0193   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0194
0195   sc = task_get_affinity(task_id, sizeof(cpuset), &cpuset);
0196   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0197
0198   rtems_test_assert(CPU_EQUAL(&cpuset, &cpusetone));
0199
0200   cpusetbigone = CPU_ALLOC(BIG_NUM_CPUS);
0201   rtems_test_assert(cpusetbigone != NULL);
0202
0203   cpusetbig = CPU_ALLOC(BIG_NUM_CPUS);
0204   rtems_test_assert(cpusetbig != NULL);
0205
0206   CPU_ZERO_S(cpusetbigsize, cpusetbigone);
0207   CPU_SET_S(0, cpusetbigsize, cpusetbigone);
0208
0209   sc = task_get_affinity(task_id, cpusetbigsize, cpusetbig);
0210   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0211
0212   rtems_test_assert(CPU_EQUAL_S(cpusetbigsize, cpusetbig, cpusetbigone));
0213
0214   sc = task_set_affinity(task_id, cpusetbigsize, cpusetbig);
0215   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0216
0217   sc = rtems_task_delete(task_id);
0218   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0219
0220   CPU_FREE(cpusetbig);
0221   CPU_FREE(cpusetbigone);
0222 }
0223
0224 static rtems_task_priority set_prio(rtems_id id, rtems_task_priority prio)
0225 {
0226   rtems_status_code sc;
0227   rtems_task_priority old_prio;
0228
0229   old_prio = 0xffffffff;
0230   sc = rtems_task_set_priority(id, prio, &old_prio);
0231   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0232
0233   return old_prio;
0234 }
0235
0236 static void forbidden_task(rtems_task_argument arg)
0237 {
0238   (void) arg;
0239
0240   rtems_test_assert(0);
0241 }
0242
0243 static void restart_task(rtems_task_argument arg)
0244 {
0245   rtems_status_code sc;
0246
0247   if (arg == 0) {
0248     rtems_test_assert(set_prio(RTEMS_SELF, 3) == 2);
0249
0250     rtems_task_restart(RTEMS_SELF, 1);
0251   } else if (arg == 1) {
0252     rtems_id scheduler_id;
0253
0254     rtems_test_assert(set_prio(RTEMS_SELF, 3) == 2);
0255
0256     sc = rtems_task_get_scheduler(RTEMS_SELF, &scheduler_id);
0257     rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0258
0259     sc = rtems_task_set_scheduler(RTEMS_SELF, scheduler_id, 4);
0260     rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0261
0262     rtems_test_assert(set_prio(RTEMS_SELF, 3) == 4);
0263
0264     rtems_task_restart(RTEMS_SELF, 2);
0265   } else {
0266     rtems_test_assert(set_prio(RTEMS_SELF, 3) == 4);
0267
0268     rtems_task_resume(master_id);
0269   }
0270
0271   rtems_test_assert(0);
0272 }
0273
0274 static void sema_task(rtems_task_argument arg)
0275 {
0276   rtems_status_code sc;
0277
0278   sc = rtems_semaphore_obtain(sema_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
0279   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0280
0281   rtems_test_assert(0);
0282 }
0283
0284 static void test_task_get_set_scheduler(void)
0285 {
0286   rtems_status_code sc;
0287   rtems_id self_id = rtems_task_self();
0288   rtems_name name = BLUE;
0289   rtems_id scheduler_id;
0290   rtems_id scheduler_by_name;
0291   rtems_id task_id;
0292   rtems_id mtx_id;
0293
0294   sc = rtems_scheduler_ident(name, &scheduler_by_name);
0295   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0296
0297   sc = rtems_task_get_scheduler(RTEMS_SELF, NULL);
0298   rtems_test_assert(sc == RTEMS_INVALID_ADDRESS);
0299
0300   sc = rtems_task_get_scheduler(invalid_id, &scheduler_id);
0301   rtems_test_assert(sc == RTEMS_INVALID_ID);
0302
0303   scheduler_id = 0;
0304   sc = rtems_task_get_scheduler(RTEMS_SELF, &scheduler_id);
0305   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0306
0307   rtems_test_assert(scheduler_id == scheduler_by_name);
0308
0309   scheduler_id = 0;
0310   sc = rtems_task_get_scheduler(self_id, &scheduler_id);
0311   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0312
0313   rtems_test_assert(scheduler_id == scheduler_by_name);
0314
0315   sc = rtems_task_set_scheduler(invalid_id, scheduler_id, 1);
0316   rtems_test_assert(sc == RTEMS_INVALID_ID);
0317
0318   sc = rtems_task_set_scheduler(self_id, invalid_id, 1);
0319   rtems_test_assert(sc == RTEMS_INVALID_ID);
0320
0321   sc = rtems_task_set_scheduler(self_id, scheduler_id, UINT32_C(0x80000000));
0322   rtems_test_assert(sc == RTEMS_INVALID_PRIORITY);
0323
0324   sc = rtems_task_set_scheduler(self_id, scheduler_id, 1);
0325   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0326
0327   sc = rtems_semaphore_create(
0328     rtems_build_name(' ', 'M', 'T', 'X'),
0329     0,
0330     RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY,
0331     0,
0332     &mtx_id
0333   );
0334   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0335
0336   sc = rtems_task_set_scheduler(self_id, scheduler_id, 1);
0337   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0338
0339   sc = rtems_semaphore_release(mtx_id);
0340   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0341
0342   rtems_test_assert(set_prio(self_id, RTEMS_CURRENT_PRIORITY) == 1);
0343
0344   sc = rtems_task_set_scheduler(self_id, scheduler_id, 2);
0345   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0346
0347   rtems_test_assert(set_prio(self_id, RTEMS_CURRENT_PRIORITY) == 2);
0348
0349   sc = rtems_task_set_scheduler(self_id, scheduler_id, 1);
0350   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0351
0352   rtems_test_assert(set_prio(self_id, RTEMS_CURRENT_PRIORITY) == 1);
0353
0354   sc = rtems_semaphore_delete(mtx_id);
0355   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0356
0357   sc = rtems_task_create(
0358     rtems_build_name('T', 'A', 'S', 'K'),
0359     2,
0360     RTEMS_MINIMUM_STACK_SIZE,
0361     RTEMS_DEFAULT_MODES,
0362     RTEMS_DEFAULT_ATTRIBUTES,
0363     &task_id
0364   );
0365   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0366
0367   scheduler_id = 0;
0368   sc = rtems_task_get_scheduler(task_id, &scheduler_id);
0369   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0370
0371   rtems_test_assert(scheduler_id == scheduler_by_name);
0372
0373   sc = rtems_task_set_scheduler(task_id, scheduler_id, 2);
0374   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0375
0376   sc = rtems_task_start(task_id, forbidden_task, 0);
0377   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0378
0379   sc = rtems_task_set_scheduler(task_id, scheduler_id, 2);
0380   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0381
0382   sc = rtems_task_delete(task_id);
0383   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0384
0385   sc = rtems_task_create(
0386     rtems_build_name('T', 'A', 'S', 'K'),
0387     2,
0388     RTEMS_MINIMUM_STACK_SIZE,
0389     RTEMS_DEFAULT_MODES,
0390     RTEMS_DEFAULT_ATTRIBUTES,
0391     &task_id
0392   );
0393   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0394
0395   sc = rtems_task_start(task_id, restart_task, 0);
0396   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0397
0398   sc = rtems_task_suspend(self_id);
0399   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0400
0401   sc = rtems_task_delete(task_id);
0402   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0403
0404   sc = rtems_semaphore_create(
0405     rtems_build_name('S', 'E', 'M', 'A'),
0406     0,
0407     RTEMS_COUNTING_SEMAPHORE,
0408     0,
0409     &sema_id
0410   );
0411   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0412
0413   sc = rtems_task_create(
0414     rtems_build_name('T', 'A', 'S', 'K'),
0415     1,
0416     RTEMS_MINIMUM_STACK_SIZE,
0417     RTEMS_DEFAULT_MODES,
0418     RTEMS_DEFAULT_ATTRIBUTES,
0419     &task_id
0420   );
0421   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0422
0423   sc = rtems_task_start(task_id, sema_task, 0);
0424   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0425
0426   sc = rtems_task_wake_after(RTEMS_YIELD_PROCESSOR);
0427   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0428
0429   sc = rtems_task_set_scheduler(task_id, scheduler_id, 1);
0430   rtems_test_assert(sc == RTEMS_RESOURCE_IN_USE);
0431
0432   sc = rtems_semaphore_delete(sema_id);
0433   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0434
0435   sc = rtems_task_delete(task_id);
0436   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0437 }
0438
0439 static void test_scheduler_ident(void)
0440 {
0441   rtems_status_code sc;
0442   rtems_id expected_id = rtems_build_id(7, 1, 1, 1);
0443   rtems_id scheduler_id;
0444   rtems_name name = BLUE;
0445   rtems_name invalid_name = RED;
0446   cpu_set_t s;
0447
0448   sc = rtems_scheduler_ident(name, NULL);
0449   rtems_test_assert(sc == RTEMS_INVALID_ADDRESS);
0450
0451   sc = rtems_scheduler_ident(invalid_name, &scheduler_id);
0452   rtems_test_assert(sc == RTEMS_INVALID_NAME);
0453
0454   scheduler_id = 0;
0455   sc = rtems_scheduler_ident(name, &scheduler_id);
0456   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0457
0458   rtems_test_assert(scheduler_id == expected_id);
0459
0460   sc = rtems_scheduler_ident_by_processor(1, NULL);
0461   rtems_test_assert(sc == RTEMS_INVALID_ADDRESS);
0462
0463   sc = rtems_scheduler_ident_by_processor(1, &scheduler_id);
0464   rtems_test_assert(sc == RTEMS_INVALID_NAME);
0465
0466   scheduler_id = 0;
0467   sc = rtems_scheduler_ident_by_processor(0, &scheduler_id);
0468   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0469
0470   rtems_test_assert(scheduler_id == expected_id);
0471
0472   CPU_ZERO(&s);
0473   CPU_SET(1, &s);
0474   sc = rtems_scheduler_ident_by_processor_set(sizeof(s), &s, NULL);
0475   rtems_test_assert(sc == RTEMS_INVALID_ADDRESS);
0476
0477   sc = rtems_scheduler_ident_by_processor_set(1, &s, &scheduler_id);
0478   rtems_test_assert(sc == RTEMS_INVALID_SIZE);
0479
0480   sc = rtems_scheduler_ident_by_processor_set(sizeof(s), &s, &scheduler_id);
0481   rtems_test_assert(sc == RTEMS_INVALID_NAME);
0482
0483   CPU_SET(0, &s);
0484   scheduler_id = 0;
0485   sc = rtems_scheduler_ident_by_processor_set(sizeof(s), &s, &scheduler_id);
0486   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0487
0488   rtems_test_assert(scheduler_id == expected_id);
0489 }
0490
0491 static void test_scheduler_get_max_prio(void)
0492 {
0493   rtems_status_code sc;
0494   rtems_task_priority priority;
0495   rtems_id scheduler_id;
0496
0497   priority = 0;
0498   sc = rtems_scheduler_get_maximum_priority(invalid_id, &priority);
0499   rtems_test_assert(sc == RTEMS_INVALID_ID);
0500   rtems_test_assert(priority == 0);
0501
0502   sc = rtems_task_get_scheduler(RTEMS_SELF, &scheduler_id);
0503   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0504
0505   sc = rtems_scheduler_get_maximum_priority(scheduler_id, NULL);
0506   rtems_test_assert(sc == RTEMS_INVALID_ADDRESS);
0507
0508   priority = 0;
0509   sc = rtems_scheduler_get_maximum_priority(scheduler_id, &priority);
0510   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0511   rtems_test_assert(priority == 255);
0512 }
0513
0514 static void test_scheduler_map_to_posix(void)
0515 {
0516   rtems_status_code sc;
0517   int posix_priority;
0518   rtems_id scheduler_id;
0519
0520   posix_priority = 123;
0521   sc = rtems_scheduler_map_priority_to_posix(invalid_id, 1, &posix_priority);
0522   rtems_test_assert(sc == RTEMS_INVALID_ID);
0523   rtems_test_assert(posix_priority == 123);
0524
0525   sc = rtems_task_get_scheduler(RTEMS_SELF, &scheduler_id);
0526   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0527
0528   sc = rtems_scheduler_map_priority_to_posix(scheduler_id, 1, NULL);
0529   rtems_test_assert(sc == RTEMS_INVALID_ADDRESS);
0530
0531   posix_priority = 123;
0532   sc = rtems_scheduler_map_priority_to_posix(scheduler_id, 0, &posix_priority);
0533   rtems_test_assert(sc == RTEMS_INVALID_PRIORITY);
0534   rtems_test_assert(posix_priority == 123);
0535
0536   posix_priority = 123;
0537   sc = rtems_scheduler_map_priority_to_posix(scheduler_id, 255, &posix_priority);
0538   rtems_test_assert(sc == RTEMS_INVALID_PRIORITY);
0539   rtems_test_assert(posix_priority == 123);
0540
0541   posix_priority = 123;
0542   sc = rtems_scheduler_map_priority_to_posix(scheduler_id, 256, &posix_priority);
0543   rtems_test_assert(sc == RTEMS_INVALID_PRIORITY);
0544   rtems_test_assert(posix_priority == 123);
0545
0546   posix_priority = 123;
0547   sc = rtems_scheduler_map_priority_to_posix(scheduler_id, 1, &posix_priority);
0548   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0549   rtems_test_assert(posix_priority == 254);
0550
0551   posix_priority = 123;
0552   sc = rtems_scheduler_map_priority_to_posix(scheduler_id, 254, &posix_priority);
0553   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0554   rtems_test_assert(posix_priority == 1);
0555 }
0556
0557 static void test_scheduler_map_from_posix(void)
0558 {
0559   rtems_status_code sc;
0560   rtems_task_priority priority;
0561   rtems_id scheduler_id;
0562
0563   priority = 123;
0564   sc = rtems_scheduler_map_priority_from_posix(invalid_id, 1, &priority);
0565   rtems_test_assert(sc == RTEMS_INVALID_ID);
0566   rtems_test_assert(priority == 123);
0567
0568   sc = rtems_task_get_scheduler(RTEMS_SELF, &scheduler_id);
0569   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0570
0571   sc = rtems_scheduler_map_priority_from_posix(scheduler_id, 1, NULL);
0572   rtems_test_assert(sc == RTEMS_INVALID_ADDRESS);
0573
0574   priority = 123;
0575   sc = rtems_scheduler_map_priority_from_posix(scheduler_id, -1, &priority);
0576   rtems_test_assert(sc == RTEMS_INVALID_PRIORITY);
0577   rtems_test_assert(priority == 123);
0578
0579   priority = 123;
0580   sc = rtems_scheduler_map_priority_from_posix(scheduler_id, 0, &priority);
0581   rtems_test_assert(sc == RTEMS_INVALID_PRIORITY);
0582   rtems_test_assert(priority == 123);
0583
0584   priority = 123;
0585   sc = rtems_scheduler_map_priority_from_posix(scheduler_id, 255, &priority);
0586   rtems_test_assert(sc == RTEMS_INVALID_PRIORITY);
0587   rtems_test_assert(priority == 123);
0588
0589   priority = 123;
0590   sc = rtems_scheduler_map_priority_from_posix(scheduler_id, 1, &priority);
0591   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0592   rtems_test_assert(priority == 254);
0593
0594   priority = 123;
0595   sc = rtems_scheduler_map_priority_from_posix(scheduler_id, 254, &priority);
0596   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0597   rtems_test_assert(priority == 1);
0598 }
0599
0600 static void test_scheduler_get_processors(void)
0601 {
0602   rtems_status_code sc;
0603   rtems_name name = BLUE;
0604   rtems_id scheduler_id;
0605   cpu_set_t cpusetone;
0606   cpu_set_t cpuset;
0607   size_t cpusetbigsize = CPU_ALLOC_SIZE(BIG_NUM_CPUS);
0608   cpu_set_t *cpusetbigone;
0609   cpu_set_t *cpusetbig;
0610
0611   CPU_ZERO(&cpusetone);
0612   CPU_SET(0, &cpusetone);
0613
0614   sc = rtems_scheduler_ident(name, &scheduler_id);
0615   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0616
0617   sc = rtems_scheduler_get_processor_set(scheduler_id, sizeof(cpuset), NULL);
0618   rtems_test_assert(sc == RTEMS_INVALID_ADDRESS);
0619
0620   sc = rtems_scheduler_get_processor_set(invalid_id, sizeof(cpuset), &cpuset);
0621   rtems_test_assert(sc == RTEMS_INVALID_ID);
0622
0623   sc = rtems_scheduler_get_processor_set(scheduler_id, 0, &cpuset);
0624   rtems_test_assert(sc == RTEMS_INVALID_SIZE);
0625
0626   sc = rtems_scheduler_get_processor_set(scheduler_id, sizeof(cpuset), &cpuset);
0627   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0628
0629   rtems_test_assert(CPU_EQUAL(&cpuset, &cpusetone));
0630
0631   cpusetbigone = CPU_ALLOC(BIG_NUM_CPUS);
0632   rtems_test_assert(cpusetbigone != NULL);
0633
0634   cpusetbig = CPU_ALLOC(BIG_NUM_CPUS);
0635   rtems_test_assert(cpusetbig != NULL);
0636
0637   CPU_ZERO_S(cpusetbigsize, cpusetbigone);
0638   CPU_SET_S(0, cpusetbigsize, cpusetbigone);
0639
0640   sc = rtems_scheduler_get_processor_set(scheduler_id, cpusetbigsize, cpusetbig);
0641   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0642
0643   rtems_test_assert(CPU_EQUAL_S(cpusetbigsize, cpusetbig, cpusetbigone));
0644
0645   CPU_FREE(cpusetbig);
0646   CPU_FREE(cpusetbigone);
0647 }
0648
0649 static void test_scheduler_add_remove_processors(void)
0650 {
0651   rtems_status_code sc;
0652   rtems_id scheduler_id;
0653
0654   sc = rtems_scheduler_ident(BLUE, &scheduler_id);
0655   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0656
0657   sc = rtems_scheduler_add_processor(invalid_id, 0);
0658   rtems_test_assert(sc == RTEMS_INVALID_ID);
0659
0660   sc = rtems_scheduler_remove_processor(invalid_id, 0);
0661   rtems_test_assert(sc == RTEMS_INVALID_ID);
0662
0663   sc = rtems_scheduler_add_processor(scheduler_id, 1);
0664   rtems_test_assert(sc == RTEMS_NOT_CONFIGURED);
0665
0666   sc = rtems_scheduler_remove_processor(scheduler_id, 1);
0667   rtems_test_assert(sc == RTEMS_INVALID_NUMBER);
0668
0669   sc = rtems_scheduler_add_processor(scheduler_id, 0);
0670   rtems_test_assert(sc == RTEMS_RESOURCE_IN_USE);
0671
0672   sc = rtems_scheduler_remove_processor(scheduler_id, 0);
0673   rtems_test_assert(sc == RTEMS_RESOURCE_IN_USE);
0674 }
0675
0676 static void test_task_get_priority(void)
0677 {
0678   rtems_status_code sc;
0679   rtems_id scheduler_id;
0680   rtems_task_priority priority;
0681   rtems_task_priority priority_2;
0682
0683   sc = rtems_task_get_scheduler(RTEMS_SELF, &scheduler_id);
0684   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0685
0686   sc = rtems_task_get_priority(RTEMS_SELF, scheduler_id, NULL);
0687   rtems_test_assert(sc == RTEMS_INVALID_ADDRESS);
0688
0689   priority = 0;
0690
0691   sc = rtems_task_get_priority(RTEMS_SELF, invalid_id, &priority);
0692   rtems_test_assert(sc == RTEMS_INVALID_ID);
0693   rtems_test_assert(priority == 0);
0694
0695   sc = rtems_task_get_priority(invalid_id, scheduler_id, &priority);
0696   rtems_test_assert(sc == RTEMS_INVALID_ID);
0697   rtems_test_assert(priority == 0);
0698
0699   sc = rtems_task_set_priority(RTEMS_SELF, RTEMS_CURRENT_PRIORITY, &priority);
0700   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0701   rtems_test_assert(priority != 0);
0702
0703   priority_2 = 0;
0704   sc = rtems_task_get_priority(RTEMS_SELF, scheduler_id, &priority_2);
0705   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0706   rtems_test_assert(priority_2 == priority);
0707
0708   priority_2 = 0;
0709   sc = rtems_task_get_priority(rtems_task_self(), scheduler_id, &priority_2);
0710   rtems_test_assert(sc == RTEMS_SUCCESSFUL);
0711   rtems_test_assert(priority_2 == priority);
0712 }
0713
0714 static void Init(rtems_task_argument arg)
0715 {
0716   rtems_resource_snapshot snapshot;
0717
0718   TEST_BEGIN();
0719
0720   rtems_resource_snapshot_take(&snapshot);
0721
0722   master_id = rtems_task_self();
0723
0724   test_task_get_set_affinity();
0725   test_task_get_set_scheduler();
0726   test_scheduler_ident();
0727   test_scheduler_get_max_prio();
0728   test_scheduler_map_to_posix();
0729   test_scheduler_map_from_posix();
0730   test_scheduler_get_processors();
0731   test_scheduler_add_remove_processors();
0732   test_task_get_priority();
0733
0734   rtems_test_assert(rtems_resource_snapshot_check(&snapshot));
0735
0736   TEST_END();
0737   rtems_test_exit(0);
0738 }
0739
0740 #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
0741 #define CONFIGURE_APPLICATION_NEEDS_SIMPLE_CONSOLE_DRIVER
0742
0743 #define CONFIGURE_MAXIMUM_TASKS 2
0744 #define CONFIGURE_MAXIMUM_SEMAPHORES 1
0745
0746 #define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION
0747
0748 #define CONFIGURE_RTEMS_INIT_TASKS_TABLE
0749
0750 #define CONFIGURE_SCHEDULER_NAME BLUE
0751
0752 #define CONFIGURE_INIT
0753
0754 #include <rtems/confdefs.h>