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
32 #include "sys/types.h"
33 #include "sys/resource.h"
34 #include "unistd.h"
35 #include "stdio.h"
36 #include "pthread.h"
37 #include "sys/utsname.h"
38 #include "mqueue.h"
39 #include "semaphore.h"
40 #include "los_process_pri.h"
41 #include "los_hw.h"
42
43 /*
44 * Supply some suitable values for constants that may not be present
45 * in all configurations.
46 */
47 #define SC_ENABLE 1
48 #define SC_DISABLE (-1)
49
50 #define CONF_CASE_RETURN(name, val) \
51 case (name): \
52 return (val)
53
uname(struct utsname * name)54 int uname(struct utsname *name)
55 {
56 if (name == NULL) {
57 return -EFAULT;
58 }
59
60 #ifdef LOSCFG_UTS_CONTAINER
61 struct utsname *currentUtsName = OsGetCurrUtsName();
62 if (currentUtsName == NULL) {
63 return -EFAULT;
64 }
65 (VOID)memcpy_s(name, sizeof(struct utsname), currentUtsName, sizeof(struct utsname));
66 #else
67
68 (VOID)strcpy_s(name->sysname, sizeof(name->sysname), KERNEL_NAME);
69 (VOID)strcpy_s(name->nodename, sizeof(name->nodename), KERNEL_NODE_NAME);
70 INT32 ret = sprintf_s(name->version, sizeof(name->version), "%s %u.%u.%u.%u %s %s",
71 KERNEL_NAME, KERNEL_MAJOR, KERNEL_MINOR, KERNEL_PATCH, KERNEL_ITRE, __DATE__, __TIME__);
72 if (ret < 0) {
73 return -EIO;
74 }
75
76 const char *cpuInfo = LOS_CpuInfo();
77 (VOID)strcpy_s(name->machine, sizeof(name->machine), cpuInfo);
78 ret = sprintf_s(name->release, sizeof(name->release), "%u.%u.%u.%u",
79 KERNEL_MAJOR, KERNEL_MINOR, KERNEL_PATCH, KERNEL_ITRE);
80 if (ret < 0) {
81 return -EIO;
82 }
83
84 name->domainname[0] = '\0';
85 #endif
86 return 0;
87 }
88
sysconf(int name)89 long sysconf(int name)
90 {
91 switch (name) {
92 CONF_CASE_RETURN(_SC_AIO_LISTIO_MAX, SC_DISABLE);
93 CONF_CASE_RETURN(_SC_AIO_MAX, SC_DISABLE);
94 CONF_CASE_RETURN(_SC_AIO_PRIO_DELTA_MAX, SC_DISABLE);
95 CONF_CASE_RETURN(_SC_ARG_MAX, ARG_MAX);
96 CONF_CASE_RETURN(_SC_ASYNCHRONOUS_IO, SC_DISABLE);
97 CONF_CASE_RETURN(_SC_CHILD_MAX, CHILD_MAX);
98 CONF_CASE_RETURN(_SC_CLK_TCK, SYS_CLK_TCK);
99 CONF_CASE_RETURN(_SC_DELAYTIMER_MAX, DELAYTIMER_MAX);
100 CONF_CASE_RETURN(_SC_FSYNC, SC_DISABLE);
101 CONF_CASE_RETURN(_SC_GETGR_R_SIZE_MAX, GETGR_R_SIZE_MAX);
102 CONF_CASE_RETURN(_SC_GETPW_R_SIZE_MAX, GETPW_R_SIZE_MAX);
103 CONF_CASE_RETURN(_SC_JOB_CONTROL, SC_DISABLE);
104 CONF_CASE_RETURN(_SC_LOGIN_NAME_MAX, LOGIN_NAME_MAX);
105 CONF_CASE_RETURN(_SC_MAPPED_FILES, SC_DISABLE);
106 CONF_CASE_RETURN(_SC_MEMLOCK, SC_DISABLE);
107 CONF_CASE_RETURN(_SC_MEMLOCK_RANGE, SC_DISABLE);
108 CONF_CASE_RETURN(_SC_MEMORY_PROTECTION, SC_DISABLE);
109 CONF_CASE_RETURN(_SC_MESSAGE_PASSING, SC_DISABLE);
110 #ifdef LOSCFG_BASE_IPC_QUEUE
111 CONF_CASE_RETURN(_SC_MQ_OPEN_MAX, MQ_OPEN_MAX);
112 CONF_CASE_RETURN(_SC_MQ_PRIO_MAX, MQ_PRIO_MAX);
113 #endif
114 CONF_CASE_RETURN(_SC_NGROUPS_MAX, NGROUPS_MAX);
115 CONF_CASE_RETURN(_SC_OPEN_MAX, OPEN_MAX);
116 CONF_CASE_RETURN(_SC_PAGESIZE, 0x1000);
117 CONF_CASE_RETURN(_SC_PRIORITIZED_IO, SC_DISABLE);
118 CONF_CASE_RETURN(_SC_PRIORITY_SCHEDULING, SC_DISABLE);
119 CONF_CASE_RETURN(_SC_REALTIME_SIGNALS, SC_DISABLE);
120 CONF_CASE_RETURN(_SC_RTSIG_MAX, RTSIG_MAX);
121 CONF_CASE_RETURN(_SC_SAVED_IDS, SC_DISABLE);
122
123 #ifdef LOSCFG_BASE_IPC_SEM
124 CONF_CASE_RETURN(_SC_SEMAPHORES, SC_ENABLE);
125 CONF_CASE_RETURN(_SC_SEM_NSEMS_MAX, SEM_NSEMS_MAX);
126 CONF_CASE_RETURN(_SC_SEM_VALUE_MAX, SEM_VALUE_MAX);
127 #endif
128
129 CONF_CASE_RETURN(_SC_SHARED_MEMORY_OBJECTS, SC_DISABLE);
130 CONF_CASE_RETURN(_SC_SIGQUEUE_MAX, SIGQUEUE_MAX);
131 CONF_CASE_RETURN(_SC_STREAM_MAX, STREAM_MAX);
132 CONF_CASE_RETURN(_SC_SYNCHRONIZED_IO, SC_DISABLE);
133 CONF_CASE_RETURN(_SC_THREADS, SC_ENABLE);
134 CONF_CASE_RETURN(_SC_THREAD_ATTR_STACKADDR, SC_ENABLE);
135 CONF_CASE_RETURN(_SC_THREAD_ATTR_STACKSIZE, PTHREAD_ATTR_STACKSIZE);
136 CONF_CASE_RETURN(_SC_THREAD_DESTRUCTOR_ITERATIONS, PTHREAD_DESTRUCTOR_ITERATIONS);
137 CONF_CASE_RETURN(_SC_THREAD_KEYS_MAX, PTHREAD_KEYS_MAX);
138 CONF_CASE_RETURN(_SC_THREAD_PRIO_INHERIT, PTHREAD_PRIO_INHERIT);
139 CONF_CASE_RETURN(_SC_THREAD_PRIO_PROTECT, PTHREAD_PRIO_PROTECT);
140 CONF_CASE_RETURN(_SC_THREAD_PRIORITY_SCHEDULING, PTHREAD_PRIORITY_SCHEDULING);
141 CONF_CASE_RETURN(_SC_THREAD_PROCESS_SHARED, PTHREAD_PROCESS_SHARED);
142 CONF_CASE_RETURN(_SC_THREAD_SAFE_FUNCTIONS, SC_DISABLE);
143 CONF_CASE_RETURN(_SC_THREAD_STACK_MIN, PTHREAD_STACK_MIN);
144 CONF_CASE_RETURN(_SC_THREAD_THREADS_MAX, PTHREAD_THREADS_MAX);
145 CONF_CASE_RETURN(_SC_TIMERS, TIMERS);
146 CONF_CASE_RETURN(_SC_TIMER_MAX, TIMER_MAX);
147 CONF_CASE_RETURN(_SC_TTY_NAME_MAX, TTY_NAME_MAX);
148 CONF_CASE_RETURN(_SC_TZNAME_MAX, TZNAME_MAX);
149 CONF_CASE_RETURN(_SC_VERSION, POSIX_VERSION);
150
151 default:
152 set_errno(EINVAL);
153 return -1;
154 }
155 }
156
getpid(void)157 pid_t getpid(void)
158 {
159 return ((LosTaskCB *)(OsCurrTaskGet()))->taskID;
160 }
161
getrlimit(int resource,struct rlimit * rlim)162 int getrlimit(int resource, struct rlimit *rlim)
163 {
164 unsigned int intSave;
165 LosProcessCB *pcb = OsCurrProcessGet();
166 struct rlimit *resourceLimit = pcb->resourceLimit;
167
168 switch (resource) {
169 case RLIMIT_NOFILE:
170 case RLIMIT_FSIZE:
171 break;
172 default:
173 return -EINVAL;
174 }
175
176 if (resourceLimit == NULL) {
177 rlim->rlim_cur = 0;
178 rlim->rlim_max = 0;
179
180 return 0;
181 }
182
183 SCHEDULER_LOCK(intSave);
184 rlim->rlim_cur = resourceLimit[resource].rlim_cur;
185 rlim->rlim_max = resourceLimit[resource].rlim_max;
186 SCHEDULER_UNLOCK(intSave);
187
188 return 0;
189 }
190
191 #define FSIZE_RLIMIT 0XFFFFFFFF
192 #ifndef NR_OPEN_DEFAULT
193 #define NR_OPEN_DEFAULT 1024
194 #endif
setrlimit(int resource,const struct rlimit * rlim)195 int setrlimit(int resource, const struct rlimit *rlim)
196 {
197 unsigned int intSave;
198 struct rlimit *resourceLimit = NULL;
199 LosProcessCB *pcb = OsCurrProcessGet();
200
201 if (rlim->rlim_cur > rlim->rlim_max) {
202 return -EINVAL;
203 }
204 switch (resource) {
205 case RLIMIT_NOFILE:
206 if (rlim->rlim_max > NR_OPEN_DEFAULT) {
207 return -EPERM;
208 }
209 break;
210 case RLIMIT_FSIZE:
211 if (rlim->rlim_max > FSIZE_RLIMIT) {
212 return -EPERM;
213 }
214 break;
215 default:
216 return -EINVAL;
217 }
218
219 if (pcb->resourceLimit == NULL) {
220 resourceLimit = LOS_MemAlloc((VOID *)m_aucSysMem0, RLIM_NLIMITS * sizeof(struct rlimit));
221 if (resourceLimit == NULL) {
222 return -EINVAL;
223 }
224 }
225
226 SCHEDULER_LOCK(intSave);
227 if (pcb->resourceLimit == NULL) {
228 pcb->resourceLimit = resourceLimit;
229 resourceLimit = NULL;
230 }
231 pcb->resourceLimit[resource].rlim_cur = rlim->rlim_cur;
232 pcb->resourceLimit[resource].rlim_max = rlim->rlim_max;
233 SCHEDULER_UNLOCK(intSave);
234
235 (VOID)LOS_MemFree((VOID *)m_aucSysMem0, resourceLimit);
236 return 0;
237 }
238