bsd-user/bsd-proc.h

   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 #ifdef TARGET_GPROF
  36     _mcleanup();
  37 #endif
  38     gdb_exit(arg1);
  39     qemu_plugin_user_exit();
  40     _exit(arg1);
  41
  42     return 0;
  43 }
  44
  45 /* getgroups(2) */
  46 static inline abi_long do_bsd_getgroups(abi_long gidsetsize, abi_long arg2)
  47 {
  48     abi_long ret;
  49     uint32_t *target_grouplist;
  50     g_autofree gid_t *grouplist;
  51     int i;
  52
  53     grouplist = g_try_new(gid_t, gidsetsize);
  54     ret = get_errno(getgroups(gidsetsize, grouplist));
  55     if (gidsetsize != 0) {
  56         if (!is_error(ret)) {
  57             target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * 2, 0);
  58             if (!target_grouplist) {
  59                 return -TARGET_EFAULT;
  60             }
  61             for (i = 0; i < ret; i++) {
  62                 target_grouplist[i] = tswap32(grouplist[i]);
  63             }
  64             unlock_user(target_grouplist, arg2, gidsetsize * 2);
  65         }
  66     }
  67     return ret;
  68 }
  69
  70 /* setgroups(2) */
  71 static inline abi_long do_bsd_setgroups(abi_long gidsetsize, abi_long arg2)
  72 {
  73     uint32_t *target_grouplist;
  74     g_autofree gid_t *grouplist;
  75     int i;
  76
  77     grouplist = g_try_new(gid_t, gidsetsize);
  78     target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * 2, 1);
  79     if (!target_grouplist) {
  80         return -TARGET_EFAULT;
  81     }
  82     for (i = 0; i < gidsetsize; i++) {
  83         grouplist[i] = tswap32(target_grouplist[i]);
  84     }
  85     unlock_user(target_grouplist, arg2, 0);
  86     return get_errno(setgroups(gidsetsize, grouplist));
  87 }
  88
  89 /* umask(2) */
  90 static inline abi_long do_bsd_umask(abi_long arg1)
  91 {
  92     return get_errno(umask(arg1));
  93 }
  94
  95 /* setlogin(2) */
  96 static inline abi_long do_bsd_setlogin(abi_long arg1)
  97 {
  98     abi_long ret;
  99     void *p;
 100
 101     p = lock_user_string(arg1);
 102     if (p == NULL) {
 103         return -TARGET_EFAULT;
 104     }
 105     ret = get_errno(setlogin(p));
 106     unlock_user(p, arg1, 0);
 107
 108     return ret;
 109 }
 110
 111 /* getlogin(2) */
 112 static inline abi_long do_bsd_getlogin(abi_long arg1, abi_long arg2)
 113 {
 114     abi_long ret;
 115     void *p;
 116
 117     p = lock_user(VERIFY_WRITE, arg1, arg2, 0);
 118     if (p == NULL) {
 119         return -TARGET_EFAULT;
 120     }
 121     ret = get_errno(_getlogin(p, arg2));
 122     unlock_user(p, arg1, arg2);
 123
 124     return ret;
 125 }
 126
 127 /* getrusage(2) */
 128 static inline abi_long do_bsd_getrusage(abi_long who, abi_ulong target_addr)
 129 {
 130     abi_long ret;
 131     struct rusage rusage;
 132
 133     ret = get_errno(getrusage(who, &rusage));
 134     if (!is_error(ret)) {
 135         host_to_target_rusage(target_addr, &rusage);
 136     }
 137     return ret;
 138 }
 139
 140 /* getrlimit(2) */
 141 static inline abi_long do_bsd_getrlimit(abi_long arg1, abi_ulong arg2)
 142 {
 143     abi_long ret;
 144     int resource = target_to_host_resource(arg1);
 145     struct target_rlimit *target_rlim;
 146     struct rlimit rlim;
 147
 148     switch (resource) {
 149     case RLIMIT_STACK:
 150         rlim.rlim_cur = target_dflssiz;
 151         rlim.rlim_max = target_maxssiz;
 152         ret = 0;
 153         break;
 154
 155     case RLIMIT_DATA:
 156         rlim.rlim_cur = target_dfldsiz;
 157         rlim.rlim_max = target_maxdsiz;
 158         ret = 0;
 159         break;
 160
 161     default:
 162         ret = get_errno(getrlimit(resource, &rlim));
 163         break;
 164     }
 165     if (!is_error(ret)) {
 166         if (!lock_user_struct(VERIFY_WRITE, target_rlim, arg2, 0)) {
 167             return -TARGET_EFAULT;
 168         }
 169         target_rlim->rlim_cur = host_to_target_rlim(rlim.rlim_cur);
 170         target_rlim->rlim_max = host_to_target_rlim(rlim.rlim_max);
 171         unlock_user_struct(target_rlim, arg2, 1);
 172     }
 173     return ret;
 174 }
 175
 176 /* setrlimit(2) */
 177 static inline abi_long do_bsd_setrlimit(abi_long arg1, abi_ulong arg2)
 178 {
 179     abi_long ret;
 180     int resource = target_to_host_resource(arg1);
 181     struct target_rlimit *target_rlim;
 182     struct rlimit rlim;
 183
 184     if (RLIMIT_STACK == resource) {
 185         /* XXX We should, maybe, allow the stack size to shrink */
 186         ret = -TARGET_EPERM;
 187     } else {
 188         if (!lock_user_struct(VERIFY_READ, target_rlim, arg2, 1)) {
 189             return -TARGET_EFAULT;
 190         }
 191         rlim.rlim_cur = target_to_host_rlim(target_rlim->rlim_cur);
 192         rlim.rlim_max = target_to_host_rlim(target_rlim->rlim_max);
 193         unlock_user_struct(target_rlim, arg2, 0);
 194         ret = get_errno(setrlimit(resource, &rlim));
 195     }
 196     return ret;
 197 }
 198
 199 /* getpid(2) */
 200 static inline abi_long do_bsd_getpid(void)
 201 {
 202     return get_errno(getpid());
 203 }
 204
 205 /* getppid(2) */
 206 static inline abi_long do_bsd_getppid(void)
 207 {
 208     return get_errno(getppid());
 209 }
 210
 211 /* getuid(2) */
 212 static inline abi_long do_bsd_getuid(void)
 213 {
 214     return get_errno(getuid());
 215 }
 216
 217 /* geteuid(2) */
 218 static inline abi_long do_bsd_geteuid(void)
 219 {
 220     return get_errno(geteuid());
 221 }
 222
 223 /* getgid(2) */
 224 static inline abi_long do_bsd_getgid(void)
 225 {
 226     return get_errno(getgid());
 227 }
 228
 229 /* getegid(2) */
 230 static inline abi_long do_bsd_getegid(void)
 231 {
 232     return get_errno(getegid());
 233 }
 234
 235 /* setuid(2) */
 236 static inline abi_long do_bsd_setuid(abi_long arg1)
 237 {
 238     return get_errno(setuid(arg1));
 239 }
 240
 241 /* seteuid(2) */
 242 static inline abi_long do_bsd_seteuid(abi_long arg1)
 243 {
 244     return get_errno(seteuid(arg1));
 245 }
 246
 247 /* setgid(2) */
 248 static inline abi_long do_bsd_setgid(abi_long arg1)
 249 {
 250     return get_errno(setgid(arg1));
 251 }
 252
 253 /* setegid(2) */
 254 static inline abi_long do_bsd_setegid(abi_long arg1)
 255 {
 256     return get_errno(setegid(arg1));
 257 }
 258
 259 /* getpgid(2) */
 260 static inline abi_long do_bsd_getpgid(pid_t pid)
 261 {
 262     return get_errno(getpgid(pid));
 263 }
 264
 265 /* setpgid(2) */
 266 static inline abi_long do_bsd_setpgid(int pid, int pgrp)
 267 {
 268     return get_errno(setpgid(pid, pgrp));
 269 }
 270
 271 /* getpgrp(2) */
 272 static inline abi_long do_bsd_getpgrp(void)
 273 {
 274     return get_errno(getpgrp());
 275 }
 276
 277 /* setreuid(2) */
 278 static inline abi_long do_bsd_setreuid(abi_long arg1, abi_long arg2)
 279 {
 280     return get_errno(setreuid(arg1, arg2));
 281 }
 282
 283 /* setregid(2) */
 284 static inline abi_long do_bsd_setregid(abi_long arg1, abi_long arg2)
 285 {
 286     return get_errno(setregid(arg1, arg2));
 287 }
 288
 289 /* setresgid(2) */
 290 static inline abi_long do_bsd_setresgid(gid_t rgid, gid_t egid, gid_t sgid)
 291 {
 292     return get_errno(setresgid(rgid, egid, sgid));
 293 }
 294
 295 /* setresuid(2) */
 296 static inline abi_long do_bsd_setresuid(uid_t ruid, uid_t euid, uid_t suid)
 297 {
 298     return get_errno(setresuid(ruid, euid, suid));
 299 }
 300
 301 /* getresuid(2) */
 302 static inline abi_long do_bsd_getresuid(abi_ulong arg1, abi_ulong arg2,
 303         abi_ulong arg3)
 304 {
 305     abi_long ret;
 306     uid_t ruid, euid, suid;
 307
 308     ret = get_errno(getresuid(&ruid, &euid, &suid));
 309     if (is_error(ret)) {
 310             return ret;
 311     }
 312     if (put_user_s32(ruid, arg1)) {
 313         return -TARGET_EFAULT;
 314     }
 315     if (put_user_s32(euid, arg2)) {
 316         return -TARGET_EFAULT;
 317     }
 318     if (put_user_s32(suid, arg3)) {
 319         return -TARGET_EFAULT;
 320     }
 321     return ret;
 322 }
 323
 324 /* getresgid(2) */
 325 static inline abi_long do_bsd_getresgid(abi_ulong arg1, abi_ulong arg2,
 326                                         abi_ulong arg3)
 327 {
 328     abi_long ret;
 329     uid_t ruid, euid, suid;
 330
 331     ret = get_errno(getresgid(&ruid, &euid, &suid));
 332     if (is_error(ret)) {
 333             return ret;
 334     }
 335     if (put_user_s32(ruid, arg1)) {
 336         return -TARGET_EFAULT;
 337     }
 338     if (put_user_s32(euid, arg2)) {
 339         return -TARGET_EFAULT;
 340     }
 341     if (put_user_s32(suid, arg3)) {
 342         return -TARGET_EFAULT;
 343     }
 344     return ret;
 345 }
 346
 347 /* getsid(2) */
 348 static inline abi_long do_bsd_getsid(abi_long arg1)
 349 {
 350     return get_errno(getsid(arg1));
 351 }
 352
 353 /* setsid(2) */
 354 static inline abi_long do_bsd_setsid(void)
 355 {
 356     return get_errno(setsid());
 357 }
 358
 359 /* issetugid(2) */
 360 static inline abi_long do_bsd_issetugid(void)
 361 {
 362     return get_errno(issetugid());
 363 }
 364
 365 /* profil(2) */
 366 static inline abi_long do_bsd_profil(abi_long arg1, abi_long arg2,
 367                                      abi_long arg3, abi_long arg4)
 368 {
 369     return -TARGET_ENOSYS;
 370 }
 371
 372 /* ktrace(2) */
 373 static inline abi_long do_bsd_ktrace(abi_long arg1, abi_long arg2,
 374                                      abi_long arg3, abi_long arg4)
 375 {
 376     return -TARGET_ENOSYS;
 377 }
 378
 379 /* utrace(2) */
 380 static inline abi_long do_bsd_utrace(abi_long arg1, abi_long arg2)
 381 {
 382     return -TARGET_ENOSYS;
 383 }
 384
 385
 386 /* ptrace(2) */
 387 static inline abi_long do_bsd_ptrace(abi_long arg1, abi_long arg2,
 388         abi_long arg3, abi_long arg4)
 389 {
 390     return -TARGET_ENOSYS;
 391 }
 392
 393 /* getpriority(2) */
 394 static inline abi_long do_bsd_getpriority(abi_long which, abi_long who)
 395 {
 396     abi_long ret;
 397     /*
 398      * Note that negative values are valid for getpriority, so we must
 399      * differentiate based on errno settings.
 400      */
 401     errno = 0;
 402     ret = getpriority(which, who);
 403     if (ret == -1 && errno != 0) {
 404         return -host_to_target_errno(errno);
 405     }
 406
 407     return ret;
 408 }
 409
 410 /* setpriority(2) */
 411 static inline abi_long do_bsd_setpriority(abi_long which, abi_long who,
 412                                           abi_long prio)
 413 {
 414     return get_errno(setpriority(which, who, prio));
 415 }
 416
 417 #endif /* !BSD_PROC_H_ */