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;
35 static const int NUMMAX = 16;
36
TestSpawnAttrGroup(posix_spawnattr_t * attr)37 static int TestSpawnAttrGroup(posix_spawnattr_t *attr)
38 {
39 pid_t val = -1;
40 pid_t pid = getpgrp();
41 int ret;
42 posix_spawnattr_getpgroup(attr, &val);
43 ICUNIT_GOTO_EQUAL(val, 0, val, EXIT);
44
45 val = getpgid(getpid());
46 ret = posix_spawnattr_setpgroup(attr, val);
47 ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
48
49 val = -1;
50
51 posix_spawnattr_getpgroup(attr, &val);
52 ICUNIT_GOTO_EQUAL(val, pid, val, EXIT);
53 return 0;
54 EXIT:
55 return 1;
56 }
57
TestSpawnAttrPrio(posix_spawnattr_t * attr)58 static int TestSpawnAttrPrio(posix_spawnattr_t *attr)
59 {
60 struct sched_param val = { -1 };
61 struct sched_param val1 = { -1 };
62 int ret;
63 posix_spawnattr_getschedparam(attr, &val);
64 ICUNIT_GOTO_EQUAL(val.sched_priority, 0, ret, EXIT);
65
66 val.sched_priority = HIGH_PRIORITY;
67 ret = posix_spawnattr_setschedparam(attr, &val);
68 ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
69
70 posix_spawnattr_getschedparam(attr, &val1);
71 ICUNIT_GOTO_EQUAL(val1.sched_priority, HIGH_PRIORITY, ret, EXIT);
72
73 return 0;
74 EXIT:
75 return 1;
76 }
77
TestSpawnAttrPol(posix_spawnattr_t * attr)78 static int TestSpawnAttrPol(posix_spawnattr_t *attr)
79 {
80 int val = -1;
81 int ret;
82
83 posix_spawnattr_getschedpolicy(attr, &val);
84 ICUNIT_GOTO_EQUAL(val, 0, val, EXIT);
85
86 val = SCHED_RR;
87 ret = posix_spawnattr_setschedpolicy(attr, val);
88 ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
89
90 val = -1;
91
92 posix_spawnattr_getschedpolicy(attr, &val);
93 ICUNIT_GOTO_EQUAL(val, SCHED_RR, val, EXIT);
94
95 ret = TestSpawnAttrPrio(attr);
96 ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
97
98 return 0;
99 EXIT:
100 return 1;
101 }
102
TestSpawnAttr(short flag)103 static int TestSpawnAttr(short flag)
104 {
105 pid_t pid;
106 posix_spawnattr_t attr;
107 int status = 1;
108 char *argv1[] = {"xxx", NULL};
109 char temp[NUMMAX] = {0};
110 char temp1[NUMMAX] = {0};
111 short iflag = -1;
112 int ret;
113 int fd;
114
115 ret = posix_spawnattr_init(&attr);
116 ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
117
118 posix_spawnattr_getflags(&attr, &iflag);
119 ICUNIT_GOTO_EQUAL(iflag, 0, iflag, EXIT);
120
121 ret = posix_spawnattr_setflags(&attr, flag);
122 ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
123
124 iflag = -1;
125
126 posix_spawnattr_getflags(&attr, &iflag);
127 ICUNIT_GOTO_EQUAL(iflag, flag, iflag, EXIT);
128
129 if (POSIX_SPAWN_SETPGROUP == flag) {
130 ret = TestSpawnAttrGroup(&attr);
131 argv1[0] = "group";
132 } else if (POSIX_SPAWN_SETSCHEDPARAM == flag) {
133 ret = TestSpawnAttrPrio(&attr);
134 argv1[0] = "prio";
135 } else if (POSIX_SPAWN_SETSCHEDULER == flag) {
136 ret = TestSpawnAttrPol(&attr);
137 argv1[0] = "pol";
138 } else if (POSIX_SPAWN_RESETIDS == flag) {
139 argv1[0] = "ids";
140 }
141 ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
142
143 ret = posix_spawnp(&pid, "/storage/test_spawn", NULL, &attr, argv1, NULL);
144 ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
145
146 ret = waitpid(pid, &status, 0);
147 ICUNIT_GOTO_EQUAL(ret, pid, ret, EXIT);
148
149 status = WEXITSTATUS(status);
150 ICUNIT_GOTO_EQUAL(status, 0, status, EXIT);
151
152 fd = open("/storage/testspawnattr.txt", O_RDWR | O_CREAT, 0644); // 0644, open config
153 ret = read(fd, temp, NUMMAX);
154 ICUNIT_GOTO_EQUAL(ret, NUMMAX, ret, EXIT1);
155
156 if (POSIX_SPAWN_SETPGROUP == flag) {
157 (void)sprintf_s(temp1, NUMMAX, "pgid = %d", attr.__pgrp);
158 } else if (POSIX_SPAWN_SETSCHEDPARAM == flag) {
159 (void)sprintf_s(temp1, NUMMAX, "prio = %d", attr.__prio);
160 } else if (POSIX_SPAWN_SETSCHEDULER == flag) {
161 (void)sprintf_s(temp1, NUMMAX, "pol = %d", attr.__pol);
162 } else if (POSIX_SPAWN_RESETIDS == flag) {
163 (void)sprintf_s(temp1, NUMMAX, "uid = %d", getuid());
164 }
165 ret = strncmp(temp, temp1, strlen(temp));
166 ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT1);
167
168 close(fd);
169 unlink("/storage/testspawnattr.txt");
170 return 0;
171 EXIT1:
172 close(fd);
173 unlink("/storage/testspawnattr.txt");
174 EXIT:
175 return 1;
176 }
177
TestCase(void)178 static int TestCase(void)
179 {
180 int ret;
181
182 ret = TestSpawnAttr(POSIX_SPAWN_RESETIDS);
183 ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
184
185 ret = TestSpawnAttr(POSIX_SPAWN_SETSCHEDPARAM);
186 ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
187
188 ret = TestSpawnAttr(POSIX_SPAWN_SETSCHEDULER);
189 ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
190
191 ret = TestSpawnAttr(POSIX_SPAWN_SETPGROUP);
192 ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
193
194 return 0;
195 EXIT:
196 return 1;
197 }
198
ItTestProcess067(void)199 void ItTestProcess067(void)
200 {
201 TEST_ADD_CASE("IT_POSIX_PROCESS_067", TestCase, TEST_POSIX, TEST_MEM, TEST_LEVEL0, TEST_FUNCTION);
202 }