1 /*
2 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
3 * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without modification,
6 * are permitted provided that the following conditions are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright notice, this list of
9 * conditions and the following disclaimer.
10 *
11 * 2. Redistributions in binary form must reproduce the above copyright notice, this list
12 * of conditions and the following disclaimer in the documentation and/or other materials
13 * provided with the distribution.
14 *
15 * 3. Neither the name of the copyright holder nor the names of its contributors may be used
16 * to endorse or promote products derived from this software without specific prior written
17 * permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
21 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
24 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
26 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
27 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
28 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
29 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 */
31 #include "it_test_process.h"
32 #include <spawn.h>
33
34 static const int HIGH_PRIORITY = 10; // 10, set high prio.
35
TestSpawnAttrDef(posix_spawnattr_t * attr)36 static int TestSpawnAttrDef(posix_spawnattr_t *attr)
37 {
38 sigset_t signalset;
39 sigset_t signalset1;
40 int ret;
41
42 ret = sigemptyset(&signalset);
43 ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
44
45 ret = sigaddset(&signalset, SIGPIPE);
46 ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
47
48 ret = posix_spawnattr_setsigdefault(attr, &signalset);
49 ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
50
51 posix_spawnattr_getsigdefault(attr, &signalset1);
52 ret = memcmp(&signalset, &signalset1, sizeof(sigset_t));
53 ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
54
55 ret = sigismember(&signalset, SIGPIPE);
56 ICUNIT_GOTO_EQUAL(ret, 1, ret, EXIT);
57 return 0;
58 EXIT:
59 return 1;
60 }
61
TestSpawnAttrMask(posix_spawnattr_t * attr)62 static int TestSpawnAttrMask(posix_spawnattr_t *attr)
63 {
64 sigset_t signalset;
65 sigset_t signalset1;
66 int ret;
67
68 ret = sigemptyset(&signalset);
69 ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
70
71 ret = sigaddset(&signalset, SIGPIPE);
72 ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
73
74 ret = posix_spawnattr_setsigmask(attr, &signalset);
75 ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
76
77 posix_spawnattr_getsigmask(attr, &signalset1);
78 ret = memcmp(&signalset, &signalset1, sizeof(sigset_t));
79 ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
80
81 ret = sigismember(&signalset, SIGPIPE);
82 ICUNIT_GOTO_EQUAL(ret, 1, ret, EXIT);
83 return 0;
84 EXIT:
85 return 1;
86 }
87
TestSpawnAttrGroup(posix_spawnattr_t * attr)88 static int TestSpawnAttrGroup(posix_spawnattr_t *attr)
89 {
90 pid_t val = -1;
91 pid_t pid = getpgrp();
92 int ret;
93 posix_spawnattr_getpgroup(attr, &val);
94 ICUNIT_GOTO_EQUAL(val, 0, val, EXIT);
95
96 val = getpgid(getpid());
97 ret = posix_spawnattr_setpgroup(attr, val);
98 ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
99
100 val = -1;
101
102 posix_spawnattr_getpgroup(attr, &val);
103 ICUNIT_GOTO_EQUAL(val, pid, val, EXIT);
104 return 0;
105 EXIT:
106 return 1;
107 }
108
TestSpawnAttrPrio(posix_spawnattr_t * attr)109 static int TestSpawnAttrPrio(posix_spawnattr_t *attr)
110 {
111 struct sched_param val = { -1 };
112 struct sched_param val1 = { -1 };
113 int ret;
114 posix_spawnattr_getschedparam(attr, &val);
115 ICUNIT_GOTO_EQUAL(val.sched_priority, 0, ret, EXIT);
116
117 val.sched_priority = HIGH_PRIORITY;
118 ret = posix_spawnattr_setschedparam(attr, &val);
119 ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
120
121 posix_spawnattr_getschedparam(attr, &val1);
122 ICUNIT_GOTO_EQUAL(val1.sched_priority, HIGH_PRIORITY, ret, EXIT);
123
124 return 0;
125 EXIT:
126 return 1;
127 }
128
TestSpawnAttrPol(posix_spawnattr_t * attr)129 static int TestSpawnAttrPol(posix_spawnattr_t *attr)
130 {
131 int val = -1;
132 int ret;
133
134 posix_spawnattr_getschedpolicy(attr, &val);
135 ICUNIT_GOTO_EQUAL(val, 0, val, EXIT);
136
137 val = SCHED_RR;
138 ret = posix_spawnattr_setschedpolicy(attr, val);
139 ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
140
141 val = -1;
142
143 posix_spawnattr_getschedpolicy(attr, &val);
144 ICUNIT_GOTO_EQUAL(val, SCHED_RR, val, EXIT);
145
146 ret = TestSpawnAttrPrio(attr);
147 ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
148
149 return 0;
150 EXIT:
151 return 1;
152 }
153
TestSpawnAttr(short flag)154 static int TestSpawnAttr(short flag)
155 {
156 pid_t pid;
157 posix_spawnattr_t attr;
158 int status = 1;
159 char *argv1[] = {"tftp", NULL};
160 short iflag = -1;
161 int ret;
162
163 ret = posix_spawnattr_init(&attr);
164 ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
165
166 posix_spawnattr_getflags(&attr, &iflag);
167 ICUNIT_GOTO_EQUAL(iflag, 0, iflag, EXIT);
168
169 ret = posix_spawnattr_setflags(&attr, flag);
170 ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
171
172 iflag = -1;
173
174 posix_spawnattr_getflags(&attr, &iflag);
175 ICUNIT_GOTO_EQUAL(iflag, flag, iflag, EXIT);
176
177 if (POSIX_SPAWN_SETSIGDEF == flag) {
178 ret = TestSpawnAttrDef(&attr);
179 } else if (POSIX_SPAWN_SETSIGMASK == flag) {
180 ret = TestSpawnAttrMask(&attr);
181 } else if (POSIX_SPAWN_SETPGROUP == flag) {
182 ret = TestSpawnAttrGroup(&attr);
183 } else if (POSIX_SPAWN_SETSCHEDPARAM == flag) {
184 ret = TestSpawnAttrPrio(&attr);
185 } else if (POSIX_SPAWN_SETSCHEDULER == flag) {
186 ret = TestSpawnAttrPol(&attr);
187 }
188 ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
189
190 ret = posix_spawn(&pid, "/bin/tftp", NULL, &attr, argv1, NULL);
191 ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
192
193 ret = posix_spawnattr_destroy(&attr);
194 ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
195
196 ret = waitpid(pid, &status, 0);
197 ICUNIT_GOTO_EQUAL(ret, pid, ret, EXIT);
198
199 return 0;
200 EXIT:
201 return 1;
202 }
203
TestCase(void)204 static int TestCase(void)
205 {
206 int ret;
207
208 ret = TestSpawnAttr(POSIX_SPAWN_RESETIDS);
209 ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
210
211 ret = TestSpawnAttr(POSIX_SPAWN_SETPGROUP);
212 ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
213
214 ret = TestSpawnAttr(POSIX_SPAWN_SETSIGDEF);
215 ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
216
217 ret = TestSpawnAttr(POSIX_SPAWN_SETSIGMASK);
218 ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
219
220 ret = TestSpawnAttr(POSIX_SPAWN_SETSCHEDPARAM);
221 ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
222
223 ret = TestSpawnAttr(POSIX_SPAWN_SETSCHEDULER);
224 ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
225
226 return 0;
227 EXIT:
228 return 1;
229 }
230
ItTestProcess058(void)231 void ItTestProcess058(void)
232 {
233 TEST_ADD_CASE("IT_POSIX_PROCESS_058", TestCase, TEST_POSIX, TEST_MEM, TEST_LEVEL0, TEST_FUNCTION);
234 }