xref: /qemu/bsd-user/bsd-proc.h (revision b49f4755) 
1 /*
2  *  process related system call shims and definitions
3  *
4  *  Copyright (c) 2013-2014 Stacey D. Son
5  *
6  *  This program is free software; you can redistribute it and/or modify
7  *  it under the terms of the GNU General Public License as published by
8  *  the Free Software Foundation; either version 2 of the License, or
9  *  (at your option) any later version.
10  *
11  *  This program is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *  GNU General Public License for more details.
15  *
16  *  You should have received a copy of the GNU General Public License
17  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19 
20 #ifndef BSD_PROC_H_
21 #define BSD_PROC_H_
22 
23 #include <sys/resource.h>
24 
25 #include "qemu-bsd.h"
26 #include "gdbstub/syscalls.h"
27 #include "qemu/plugin.h"
28 
29 extern int _getlogin(char*, int);
30 int bsd_get_ncpu(void);
31 
32 /* exit(2) */
33 static inline abi_long do_bsd_exit(void *cpu_env, abi_long arg1)
34 {
35     gdb_exit(arg1);
36     qemu_plugin_user_exit();
37     _exit(arg1);
38 
39     return 0;
40 }
41 
42 /* getgroups(2) */
43 static inline abi_long do_bsd_getgroups(abi_long gidsetsize, abi_long arg2)
44 {
45     abi_long ret;
46     uint32_t *target_grouplist;
47     g_autofree gid_t *grouplist;
48     int i;
49 
50     grouplist = g_try_new(gid_t, gidsetsize);
51     ret = get_errno(getgroups(gidsetsize, grouplist));
52     if (gidsetsize != 0) {
53         if (!is_error(ret)) {
54             target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * 2, 0);
55             if (!target_grouplist) {
56                 return -TARGET_EFAULT;
57             }
58             for (i = 0; i < ret; i++) {
59                 target_grouplist[i] = tswap32(grouplist[i]);
60             }
61             unlock_user(target_grouplist, arg2, gidsetsize * 2);
62         }
63     }
64     return ret;
65 }
66 
67 /* setgroups(2) */
68 static inline abi_long do_bsd_setgroups(abi_long gidsetsize, abi_long arg2)
69 {
70     uint32_t *target_grouplist;
71     g_autofree gid_t *grouplist;
72     int i;
73 
74     grouplist = g_try_new(gid_t, gidsetsize);
75     target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * 2, 1);
76     if (!target_grouplist) {
77         return -TARGET_EFAULT;
78     }
79     for (i = 0; i < gidsetsize; i++) {
80         grouplist[i] = tswap32(target_grouplist[i]);
81     }
82     unlock_user(target_grouplist, arg2, 0);
83     return get_errno(setgroups(gidsetsize, grouplist));
84 }
85 
86 /* umask(2) */
87 static inline abi_long do_bsd_umask(abi_long arg1)
88 {
89     return get_errno(umask(arg1));
90 }
91 
92 /* setlogin(2) */
93 static inline abi_long do_bsd_setlogin(abi_long arg1)
94 {
95     abi_long ret;
96     void *p;
97 
98     p = lock_user_string(arg1);
99     if (p == NULL) {
100         return -TARGET_EFAULT;
101     }
102     ret = get_errno(setlogin(p));
103     unlock_user(p, arg1, 0);
104 
105     return ret;
106 }
107 
108 /* getlogin(2) */
109 static inline abi_long do_bsd_getlogin(abi_long arg1, abi_long arg2)
110 {
111     abi_long ret;
112     void *p;
113 
114     p = lock_user(VERIFY_WRITE, arg1, arg2, 0);
115     if (p == NULL) {
116         return -TARGET_EFAULT;
117     }
118     ret = get_errno(_getlogin(p, arg2));
119     unlock_user(p, arg1, arg2);
120 
121     return ret;
122 }
123 
124 /* getrusage(2) */
125 static inline abi_long do_bsd_getrusage(abi_long who, abi_ulong target_addr)
126 {
127     abi_long ret;
128     struct rusage rusage;
129 
130     ret = get_errno(getrusage(who, &rusage));
131     if (!is_error(ret)) {
132         host_to_target_rusage(target_addr, &rusage);
133     }
134     return ret;
135 }
136 
137 /* getrlimit(2) */
138 static inline abi_long do_bsd_getrlimit(abi_long arg1, abi_ulong arg2)
139 {
140     abi_long ret;
141     int resource = target_to_host_resource(arg1);
142     struct target_rlimit *target_rlim;
143     struct rlimit rlim;
144 
145     switch (resource) {
146     case RLIMIT_STACK:
147         rlim.rlim_cur = target_dflssiz;
148         rlim.rlim_max = target_maxssiz;
149         ret = 0;
150         break;
151 
152     case RLIMIT_DATA:
153         rlim.rlim_cur = target_dfldsiz;
154         rlim.rlim_max = target_maxdsiz;
155         ret = 0;
156         break;
157 
158     default:
159         ret = get_errno(getrlimit(resource, &rlim));
160         break;
161     }
162     if (!is_error(ret)) {
163         if (!lock_user_struct(VERIFY_WRITE, target_rlim, arg2, 0)) {
164             return -TARGET_EFAULT;
165         }
166         target_rlim->rlim_cur = host_to_target_rlim(rlim.rlim_cur);
167         target_rlim->rlim_max = host_to_target_rlim(rlim.rlim_max);
168         unlock_user_struct(target_rlim, arg2, 1);
169     }
170     return ret;
171 }
172 
173 /* setrlimit(2) */
174 static inline abi_long do_bsd_setrlimit(abi_long arg1, abi_ulong arg2)
175 {
176     abi_long ret;
177     int resource = target_to_host_resource(arg1);
178     struct target_rlimit *target_rlim;
179     struct rlimit rlim;
180 
181     if (RLIMIT_STACK == resource) {
182         /* XXX We should, maybe, allow the stack size to shrink */
183         ret = -TARGET_EPERM;
184     } else {
185         if (!lock_user_struct(VERIFY_READ, target_rlim, arg2, 1)) {
186             return -TARGET_EFAULT;
187         }
188         rlim.rlim_cur = target_to_host_rlim(target_rlim->rlim_cur);
189         rlim.rlim_max = target_to_host_rlim(target_rlim->rlim_max);
190         unlock_user_struct(target_rlim, arg2, 0);
191         ret = get_errno(setrlimit(resource, &rlim));
192     }
193     return ret;
194 }
195 
196 /* getpid(2) */
197 static inline abi_long do_bsd_getpid(void)
198 {
199     return get_errno(getpid());
200 }
201 
202 /* getppid(2) */
203 static inline abi_long do_bsd_getppid(void)
204 {
205     return get_errno(getppid());
206 }
207 
208 /* getuid(2) */
209 static inline abi_long do_bsd_getuid(void)
210 {
211     return get_errno(getuid());
212 }
213 
214 /* geteuid(2) */
215 static inline abi_long do_bsd_geteuid(void)
216 {
217     return get_errno(geteuid());
218 }
219 
220 /* getgid(2) */
221 static inline abi_long do_bsd_getgid(void)
222 {
223     return get_errno(getgid());
224 }
225 
226 /* getegid(2) */
227 static inline abi_long do_bsd_getegid(void)
228 {
229     return get_errno(getegid());
230 }
231 
232 /* setuid(2) */
233 static inline abi_long do_bsd_setuid(abi_long arg1)
234 {
235     return get_errno(setuid(arg1));
236 }
237 
238 /* seteuid(2) */
239 static inline abi_long do_bsd_seteuid(abi_long arg1)
240 {
241     return get_errno(seteuid(arg1));
242 }
243 
244 /* setgid(2) */
245 static inline abi_long do_bsd_setgid(abi_long arg1)
246 {
247     return get_errno(setgid(arg1));
248 }
249 
250 /* setegid(2) */
251 static inline abi_long do_bsd_setegid(abi_long arg1)
252 {
253     return get_errno(setegid(arg1));
254 }
255 
256 /* getpgid(2) */
257 static inline abi_long do_bsd_getpgid(pid_t pid)
258 {
259     return get_errno(getpgid(pid));
260 }
261 
262 /* setpgid(2) */
263 static inline abi_long do_bsd_setpgid(int pid, int pgrp)
264 {
265     return get_errno(setpgid(pid, pgrp));
266 }
267 
268 /* getpgrp(2) */
269 static inline abi_long do_bsd_getpgrp(void)
270 {
271     return get_errno(getpgrp());
272 }
273 
274 /* setreuid(2) */
275 static inline abi_long do_bsd_setreuid(abi_long arg1, abi_long arg2)
276 {
277     return get_errno(setreuid(arg1, arg2));
278 }
279 
280 /* setregid(2) */
281 static inline abi_long do_bsd_setregid(abi_long arg1, abi_long arg2)
282 {
283     return get_errno(setregid(arg1, arg2));
284 }
285 
286 /* setresgid(2) */
287 static inline abi_long do_bsd_setresgid(gid_t rgid, gid_t egid, gid_t sgid)
288 {
289     return get_errno(setresgid(rgid, egid, sgid));
290 }
291 
292 /* setresuid(2) */
293 static inline abi_long do_bsd_setresuid(uid_t ruid, uid_t euid, uid_t suid)
294 {
295     return get_errno(setresuid(ruid, euid, suid));
296 }
297 
298 /* getresuid(2) */
299 static inline abi_long do_bsd_getresuid(abi_ulong arg1, abi_ulong arg2,
300         abi_ulong arg3)
301 {
302     abi_long ret;
303     uid_t ruid, euid, suid;
304 
305     ret = get_errno(getresuid(&ruid, &euid, &suid));
306     if (is_error(ret)) {
307             return ret;
308     }
309     if (put_user_s32(ruid, arg1)) {
310         return -TARGET_EFAULT;
311     }
312     if (put_user_s32(euid, arg2)) {
313         return -TARGET_EFAULT;
314     }
315     if (put_user_s32(suid, arg3)) {
316         return -TARGET_EFAULT;
317     }
318     return ret;
319 }
320 
321 /* getresgid(2) */
322 static inline abi_long do_bsd_getresgid(abi_ulong arg1, abi_ulong arg2,
323                                         abi_ulong arg3)
324 {
325     abi_long ret;
326     uid_t ruid, euid, suid;
327 
328     ret = get_errno(getresgid(&ruid, &euid, &suid));
329     if (is_error(ret)) {
330             return ret;
331     }
332     if (put_user_s32(ruid, arg1)) {
333         return -TARGET_EFAULT;
334     }
335     if (put_user_s32(euid, arg2)) {
336         return -TARGET_EFAULT;
337     }
338     if (put_user_s32(suid, arg3)) {
339         return -TARGET_EFAULT;
340     }
341     return ret;
342 }
343 
344 /* getsid(2) */
345 static inline abi_long do_bsd_getsid(abi_long arg1)
346 {
347     return get_errno(getsid(arg1));
348 }
349 
350 /* setsid(2) */
351 static inline abi_long do_bsd_setsid(void)
352 {
353     return get_errno(setsid());
354 }
355 
356 /* issetugid(2) */
357 static inline abi_long do_bsd_issetugid(void)
358 {
359     return get_errno(issetugid());
360 }
361 
362 /* profil(2) */
363 static inline abi_long do_bsd_profil(abi_long arg1, abi_long arg2,
364                                      abi_long arg3, abi_long arg4)
365 {
366     return -TARGET_ENOSYS;
367 }
368 
369 /* ktrace(2) */
370 static inline abi_long do_bsd_ktrace(abi_long arg1, abi_long arg2,
371                                      abi_long arg3, abi_long arg4)
372 {
373     return -TARGET_ENOSYS;
374 }
375 
376 /* utrace(2) */
377 static inline abi_long do_bsd_utrace(abi_long arg1, abi_long arg2)
378 {
379     return -TARGET_ENOSYS;
380 }
381 
382 
383 /* ptrace(2) */
384 static inline abi_long do_bsd_ptrace(abi_long arg1, abi_long arg2,
385         abi_long arg3, abi_long arg4)
386 {
387     return -TARGET_ENOSYS;
388 }
389 
390 /* getpriority(2) */
391 static inline abi_long do_bsd_getpriority(abi_long which, abi_long who)
392 {
393     abi_long ret;
394     /*
395      * Note that negative values are valid for getpriority, so we must
396      * differentiate based on errno settings.
397      */
398     errno = 0;
399     ret = getpriority(which, who);
400     if (ret == -1 && errno != 0) {
401         return -host_to_target_errno(errno);
402     }
403 
404     return ret;
405 }
406 
407 /* setpriority(2) */
408 static inline abi_long do_bsd_setpriority(abi_long which, abi_long who,
409                                           abi_long prio)
410 {
411     return get_errno(setpriority(which, who, prio));
412 }
413 
414 #endif /* !BSD_PROC_H_ */
415