bsd-user/syscall.c

   1 /*
   2  *  BSD syscalls
   3  *
   4  *  Copyright (c) 2003 - 2008 Fabrice Bellard
   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 #include "qemu/osdep.h"
  20 #include "qemu/cutils.h"
  21 #include "qemu/path.h"
  22 #include <sys/syscall.h>
  23 #include <sys/param.h>
  24 #include <sys/sysctl.h>
  25 #include <utime.h>
  26
  27 #include "qemu.h"
  28 #include "qemu-common.h"
  29
  30 //#define DEBUG
  31
  32 static abi_ulong target_brk;
  33 static abi_ulong target_original_brk;
  34
  35 static inline abi_long get_errno(abi_long ret)
  36 {
  37     if (ret == -1)
  38         /* XXX need to translate host -> target errnos here */
  39         return -(errno);
  40     else
  41         return ret;
  42 }
  43
  44 #define target_to_host_bitmask(x, tbl) (x)
  45
  46 static inline int is_error(abi_long ret)
  47 {
  48     return (abi_ulong)ret >= (abi_ulong)(-4096);
  49 }
  50
  51 void target_set_brk(abi_ulong new_brk)
  52 {
  53     target_original_brk = target_brk = HOST_PAGE_ALIGN(new_brk);
  54 }
  55
  56 /* do_obreak() must return target errnos. */
  57 static abi_long do_obreak(abi_ulong new_brk)
  58 {
  59     abi_ulong brk_page;
  60     abi_long mapped_addr;
  61     int new_alloc_size;
  62
  63     if (!new_brk)
  64         return 0;
  65     if (new_brk < target_original_brk)
  66         return -TARGET_EINVAL;
  67
  68     brk_page = HOST_PAGE_ALIGN(target_brk);
  69
  70     /* If the new brk is less than this, set it and we're done... */
  71     if (new_brk < brk_page) {
  72         target_brk = new_brk;
  73         return 0;
  74     }
  75
  76     /* We need to allocate more memory after the brk... */
  77     new_alloc_size = HOST_PAGE_ALIGN(new_brk - brk_page + 1);
  78     mapped_addr = get_errno(target_mmap(brk_page, new_alloc_size,
  79                                         PROT_READ|PROT_WRITE,
  80                                         MAP_ANON|MAP_FIXED|MAP_PRIVATE, -1, 0));
  81
  82     if (!is_error(mapped_addr))
  83         target_brk = new_brk;
  84     else
  85         return mapped_addr;
  86
  87     return 0;
  88 }
  89
  90 #if defined(TARGET_I386)
  91 static abi_long do_freebsd_sysarch(CPUX86State *env, int op, abi_ulong parms)
  92 {
  93     abi_long ret = 0;
  94     abi_ulong val;
  95     int idx;
  96
  97     switch(op) {
  98 #ifdef TARGET_ABI32
  99     case TARGET_FREEBSD_I386_SET_GSBASE:
 100     case TARGET_FREEBSD_I386_SET_FSBASE:
 101         if (op == TARGET_FREEBSD_I386_SET_GSBASE)
 102 #else
 103     case TARGET_FREEBSD_AMD64_SET_GSBASE:
 104     case TARGET_FREEBSD_AMD64_SET_FSBASE:
 105         if (op == TARGET_FREEBSD_AMD64_SET_GSBASE)
 106 #endif
 107             idx = R_GS;
 108         else
 109             idx = R_FS;
 110         if (get_user(val, parms, abi_ulong))
 111             return -TARGET_EFAULT;
 112         cpu_x86_load_seg(env, idx, 0);
 113         env->segs[idx].base = val;
 114         break;
 115 #ifdef TARGET_ABI32
 116     case TARGET_FREEBSD_I386_GET_GSBASE:
 117     case TARGET_FREEBSD_I386_GET_FSBASE:
 118         if (op == TARGET_FREEBSD_I386_GET_GSBASE)
 119 #else
 120     case TARGET_FREEBSD_AMD64_GET_GSBASE:
 121     case TARGET_FREEBSD_AMD64_GET_FSBASE:
 122         if (op == TARGET_FREEBSD_AMD64_GET_GSBASE)
 123 #endif
 124             idx = R_GS;
 125         else
 126             idx = R_FS;
 127         val = env->segs[idx].base;
 128         if (put_user(val, parms, abi_ulong))
 129             return -TARGET_EFAULT;
 130         break;
 131     /* XXX handle the others... */
 132     default:
 133         ret = -TARGET_EINVAL;
 134         break;
 135     }
 136     return ret;
 137 }
 138 #endif
 139
 140 #ifdef TARGET_SPARC
 141 static abi_long do_freebsd_sysarch(void *env, int op, abi_ulong parms)
 142 {
 143     /* XXX handle
 144      * TARGET_FREEBSD_SPARC_UTRAP_INSTALL,
 145      * TARGET_FREEBSD_SPARC_SIGTRAMP_INSTALL
 146      */
 147     return -TARGET_EINVAL;
 148 }
 149 #endif
 150
 151 #ifdef __FreeBSD__
 152 /*
 153  * XXX this uses the undocumented oidfmt interface to find the kind of
 154  * a requested sysctl, see /sys/kern/kern_sysctl.c:sysctl_sysctl_oidfmt()
 155  * (this is mostly copied from src/sbin/sysctl/sysctl.c)
 156  */
 157 static int
 158 oidfmt(int *oid, int len, char *fmt, uint32_t *kind)
 159 {
 160     int qoid[CTL_MAXNAME+2];
 161     uint8_t buf[BUFSIZ];
 162     int i;
 163     size_t j;
 164
 165     qoid[0] = 0;
 166     qoid[1] = 4;
 167     memcpy(qoid + 2, oid, len * sizeof(int));
 168
 169     j = sizeof(buf);
 170     i = sysctl(qoid, len + 2, buf, &j, 0, 0);
 171     if (i)
 172         return i;
 173
 174     if (kind)
 175         *kind = *(uint32_t *)buf;
 176
 177     if (fmt)
 178         strcpy(fmt, (char *)(buf + sizeof(uint32_t)));
 179     return (0);
 180 }
 181
 182 /*
 183  * try and convert sysctl return data for the target.
 184  * XXX doesn't handle CTLTYPE_OPAQUE and CTLTYPE_STRUCT.
 185  */
 186 static int sysctl_oldcvt(void *holdp, size_t holdlen, uint32_t kind)
 187 {
 188     switch (kind & CTLTYPE) {
 189     case CTLTYPE_INT:
 190     case CTLTYPE_UINT:
 191         *(uint32_t *)holdp = tswap32(*(uint32_t *)holdp);
 192         break;
 193 #ifdef TARGET_ABI32
 194     case CTLTYPE_LONG:
 195     case CTLTYPE_ULONG:
 196         *(uint32_t *)holdp = tswap32(*(long *)holdp);
 197         break;
 198 #else
 199     case CTLTYPE_LONG:
 200         *(uint64_t *)holdp = tswap64(*(long *)holdp);
 201     case CTLTYPE_ULONG:
 202         *(uint64_t *)holdp = tswap64(*(unsigned long *)holdp);
 203         break;
 204 #endif
 205 #ifdef CTLTYPE_U64
 206     case CTLTYPE_S64:
 207     case CTLTYPE_U64:
 208 #else
 209     case CTLTYPE_QUAD:
 210 #endif
 211         *(uint64_t *)holdp = tswap64(*(uint64_t *)holdp);
 212         break;
 213     case CTLTYPE_STRING:
 214         break;
 215     default:
 216         /* XXX unhandled */
 217         return -1;
 218     }
 219     return 0;
 220 }
 221
 222 /* XXX this needs to be emulated on non-FreeBSD hosts... */
 223 static abi_long do_freebsd_sysctl(abi_ulong namep, int32_t namelen, abi_ulong oldp,
 224                           abi_ulong oldlenp, abi_ulong newp, abi_ulong newlen)
 225 {
 226     abi_long ret;
 227     void *hnamep, *holdp, *hnewp = NULL;
 228     size_t holdlen;
 229     abi_ulong oldlen = 0;
 230     int32_t *snamep = g_malloc(sizeof(int32_t) * namelen), *p, *q, i;
 231     uint32_t kind = 0;
 232
 233     if (oldlenp)
 234         get_user_ual(oldlen, oldlenp);
 235     if (!(hnamep = lock_user(VERIFY_READ, namep, namelen, 1)))
 236         return -TARGET_EFAULT;
 237     if (newp && !(hnewp = lock_user(VERIFY_READ, newp, newlen, 1)))
 238         return -TARGET_EFAULT;
 239     if (!(holdp = lock_user(VERIFY_WRITE, oldp, oldlen, 0)))
 240         return -TARGET_EFAULT;
 241     holdlen = oldlen;
 242     for (p = hnamep, q = snamep, i = 0; i < namelen; p++, i++)
 243        *q++ = tswap32(*p);
 244     oidfmt(snamep, namelen, NULL, &kind);
 245     /* XXX swap hnewp */
 246     ret = get_errno(sysctl(snamep, namelen, holdp, &holdlen, hnewp, newlen));
 247     if (!ret)
 248         sysctl_oldcvt(holdp, holdlen, kind);
 249     put_user_ual(holdlen, oldlenp);
 250     unlock_user(hnamep, namep, 0);
 251     unlock_user(holdp, oldp, holdlen);
 252     if (hnewp)
 253         unlock_user(hnewp, newp, 0);
 254     g_free(snamep);
 255     return ret;
 256 }
 257 #endif
 258
 259 /* FIXME
 260  * lock_iovec()/unlock_iovec() have a return code of 0 for success where
 261  * other lock functions have a return code of 0 for failure.
 262  */
 263 static abi_long lock_iovec(int type, struct iovec *vec, abi_ulong target_addr,
 264                            int count, int copy)
 265 {
 266     struct target_iovec *target_vec;
 267     abi_ulong base;
 268     int i;
 269
 270     target_vec = lock_user(VERIFY_READ, target_addr, count * sizeof(struct target_iovec), 1);
 271     if (!target_vec)
 272         return -TARGET_EFAULT;
 273     for(i = 0;i < count; i++) {
 274         base = tswapl(target_vec[i].iov_base);
 275         vec[i].iov_len = tswapl(target_vec[i].iov_len);
 276         if (vec[i].iov_len != 0) {
 277             vec[i].iov_base = lock_user(type, base, vec[i].iov_len, copy);
 278             /* Don't check lock_user return value. We must call writev even
 279                if a element has invalid base address. */
 280         } else {
 281             /* zero length pointer is ignored */
 282             vec[i].iov_base = NULL;
 283         }
 284     }
 285     unlock_user (target_vec, target_addr, 0);
 286     return 0;
 287 }
 288
 289 static abi_long unlock_iovec(struct iovec *vec, abi_ulong target_addr,
 290                              int count, int copy)
 291 {
 292     struct target_iovec *target_vec;
 293     abi_ulong base;
 294     int i;
 295
 296     target_vec = lock_user(VERIFY_READ, target_addr, count * sizeof(struct target_iovec), 1);
 297     if (!target_vec)
 298         return -TARGET_EFAULT;
 299     for(i = 0;i < count; i++) {
 300         if (target_vec[i].iov_base) {
 301             base = tswapl(target_vec[i].iov_base);
 302             unlock_user(vec[i].iov_base, base, copy ? vec[i].iov_len : 0);
 303         }
 304     }
 305     unlock_user (target_vec, target_addr, 0);
 306
 307     return 0;
 308 }
 309
 310 /* do_syscall() should always have a single exit point at the end so
 311    that actions, such as logging of syscall results, can be performed.
 312    All errnos that do_syscall() returns must be -TARGET_<errcode>. */
 313 abi_long do_freebsd_syscall(void *cpu_env, int num, abi_long arg1,
 314                             abi_long arg2, abi_long arg3, abi_long arg4,
 315                             abi_long arg5, abi_long arg6, abi_long arg7,
 316                             abi_long arg8)
 317 {
 318     CPUState *cpu = ENV_GET_CPU(cpu_env);
 319     abi_long ret;
 320     void *p;
 321
 322 #ifdef DEBUG
 323     gemu_log("freebsd syscall %d\n", num);
 324 #endif
 325     trace_guest_user_syscall(cpu, num, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
 326     if(do_strace)
 327         print_freebsd_syscall(num, arg1, arg2, arg3, arg4, arg5, arg6);
 328
 329     switch(num) {
 330     case TARGET_FREEBSD_NR_exit:
 331 #ifdef TARGET_GPROF
 332         _mcleanup();
 333 #endif
 334         gdb_exit(cpu_env, arg1);
 335         /* XXX: should free thread stack and CPU env */
 336         _exit(arg1);
 337         ret = 0; /* avoid warning */
 338         break;
 339     case TARGET_FREEBSD_NR_read:
 340         if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
 341             goto efault;
 342         ret = get_errno(read(arg1, p, arg3));
 343         unlock_user(p, arg2, ret);
 344         break;
 345     case TARGET_FREEBSD_NR_write:
 346         if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
 347             goto efault;
 348         ret = get_errno(write(arg1, p, arg3));
 349         unlock_user(p, arg2, 0);
 350         break;
 351     case TARGET_FREEBSD_NR_writev:
 352         {
 353             int count = arg3;
 354             struct iovec *vec;
 355
 356             vec = alloca(count * sizeof(struct iovec));
 357             if (lock_iovec(VERIFY_READ, vec, arg2, count, 1) < 0)
 358                 goto efault;
 359             ret = get_errno(writev(arg1, vec, count));
 360             unlock_iovec(vec, arg2, count, 0);
 361         }
 362         break;
 363     case TARGET_FREEBSD_NR_open:
 364         if (!(p = lock_user_string(arg1)))
 365             goto efault;
 366         ret = get_errno(open(path(p),
 367                              target_to_host_bitmask(arg2, fcntl_flags_tbl),
 368                              arg3));
 369         unlock_user(p, arg1, 0);
 370         break;
 371     case TARGET_FREEBSD_NR_mmap:
 372         ret = get_errno(target_mmap(arg1, arg2, arg3,
 373                                     target_to_host_bitmask(arg4, mmap_flags_tbl),
 374                                     arg5,
 375                                     arg6));
 376         break;
 377     case TARGET_FREEBSD_NR_mprotect:
 378         ret = get_errno(target_mprotect(arg1, arg2, arg3));
 379         break;
 380     case TARGET_FREEBSD_NR_break:
 381         ret = do_obreak(arg1);
 382         break;
 383 #ifdef __FreeBSD__
 384     case TARGET_FREEBSD_NR___sysctl:
 385         ret = do_freebsd_sysctl(arg1, arg2, arg3, arg4, arg5, arg6);
 386         break;
 387 #endif
 388     case TARGET_FREEBSD_NR_sysarch:
 389         ret = do_freebsd_sysarch(cpu_env, arg1, arg2);
 390         break;
 391     case TARGET_FREEBSD_NR_syscall:
 392     case TARGET_FREEBSD_NR___syscall:
 393         ret = do_freebsd_syscall(cpu_env,arg1 & 0xffff,arg2,arg3,arg4,arg5,arg6,arg7,arg8,0);
 394         break;
 395     default:
 396         ret = get_errno(syscall(num, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8));
 397         break;
 398     }
 399  fail:
 400 #ifdef DEBUG
 401     gemu_log(" = %ld\n", ret);
 402 #endif
 403     if (do_strace)
 404         print_freebsd_syscall_ret(num, ret);
 405     trace_guest_user_syscall_ret(cpu, num, ret);
 406     return ret;
 407  efault:
 408     ret = -TARGET_EFAULT;
 409     goto fail;
 410 }
 411
 412 abi_long do_netbsd_syscall(void *cpu_env, int num, abi_long arg1,
 413                            abi_long arg2, abi_long arg3, abi_long arg4,
 414                            abi_long arg5, abi_long arg6)
 415 {
 416     CPUState *cpu = ENV_GET_CPU(cpu_env);
 417     abi_long ret;
 418     void *p;
 419
 420 #ifdef DEBUG
 421     gemu_log("netbsd syscall %d\n", num);
 422 #endif
 423     trace_guest_user_syscall(cpu, num, arg1, arg2, arg3, arg4, arg5, arg6, 0, 0);
 424     if(do_strace)
 425         print_netbsd_syscall(num, arg1, arg2, arg3, arg4, arg5, arg6);
 426
 427     switch(num) {
 428     case TARGET_NETBSD_NR_exit:
 429 #ifdef TARGET_GPROF
 430         _mcleanup();
 431 #endif
 432         gdb_exit(cpu_env, arg1);
 433         /* XXX: should free thread stack and CPU env */
 434         _exit(arg1);
 435         ret = 0; /* avoid warning */
 436         break;
 437     case TARGET_NETBSD_NR_read:
 438         if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
 439             goto efault;
 440         ret = get_errno(read(arg1, p, arg3));
 441         unlock_user(p, arg2, ret);
 442         break;
 443     case TARGET_NETBSD_NR_write:
 444         if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
 445             goto efault;
 446         ret = get_errno(write(arg1, p, arg3));
 447         unlock_user(p, arg2, 0);
 448         break;
 449     case TARGET_NETBSD_NR_open:
 450         if (!(p = lock_user_string(arg1)))
 451             goto efault;
 452         ret = get_errno(open(path(p),
 453                              target_to_host_bitmask(arg2, fcntl_flags_tbl),
 454                              arg3));
 455         unlock_user(p, arg1, 0);
 456         break;
 457     case TARGET_NETBSD_NR_mmap:
 458         ret = get_errno(target_mmap(arg1, arg2, arg3,
 459                                     target_to_host_bitmask(arg4, mmap_flags_tbl),
 460                                     arg5,
 461                                     arg6));
 462         break;
 463     case TARGET_NETBSD_NR_mprotect:
 464         ret = get_errno(target_mprotect(arg1, arg2, arg3));
 465         break;
 466     case TARGET_NETBSD_NR_syscall:
 467     case TARGET_NETBSD_NR___syscall:
 468         ret = do_netbsd_syscall(cpu_env,arg1 & 0xffff,arg2,arg3,arg4,arg5,arg6,0);
 469         break;
 470     default:
 471         ret = syscall(num, arg1, arg2, arg3, arg4, arg5, arg6);
 472         break;
 473     }
 474  fail:
 475 #ifdef DEBUG
 476     gemu_log(" = %ld\n", ret);
 477 #endif
 478     if (do_strace)
 479         print_netbsd_syscall_ret(num, ret);
 480     trace_guest_user_syscall_ret(cpu, num, ret);
 481     return ret;
 482  efault:
 483     ret = -TARGET_EFAULT;
 484     goto fail;
 485 }
 486
 487 abi_long do_openbsd_syscall(void *cpu_env, int num, abi_long arg1,
 488                             abi_long arg2, abi_long arg3, abi_long arg4,
 489                             abi_long arg5, abi_long arg6)
 490 {
 491     CPUState *cpu = ENV_GET_CPU(cpu_env);
 492     abi_long ret;
 493     void *p;
 494
 495 #ifdef DEBUG
 496     gemu_log("openbsd syscall %d\n", num);
 497 #endif
 498     trace_guest_user_syscall(cpu, num, arg1, arg2, arg3, arg4, arg5, arg6, 0, 0);
 499     if(do_strace)
 500         print_openbsd_syscall(num, arg1, arg2, arg3, arg4, arg5, arg6);
 501
 502     switch(num) {
 503     case TARGET_OPENBSD_NR_exit:
 504 #ifdef TARGET_GPROF
 505         _mcleanup();
 506 #endif
 507         gdb_exit(cpu_env, arg1);
 508         /* XXX: should free thread stack and CPU env */
 509         _exit(arg1);
 510         ret = 0; /* avoid warning */
 511         break;
 512     case TARGET_OPENBSD_NR_read:
 513         if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
 514             goto efault;
 515         ret = get_errno(read(arg1, p, arg3));
 516         unlock_user(p, arg2, ret);
 517         break;
 518     case TARGET_OPENBSD_NR_write:
 519         if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
 520             goto efault;
 521         ret = get_errno(write(arg1, p, arg3));
 522         unlock_user(p, arg2, 0);
 523         break;
 524     case TARGET_OPENBSD_NR_open:
 525         if (!(p = lock_user_string(arg1)))
 526             goto efault;
 527         ret = get_errno(open(path(p),
 528                              target_to_host_bitmask(arg2, fcntl_flags_tbl),
 529                              arg3));
 530         unlock_user(p, arg1, 0);
 531         break;
 532     case TARGET_OPENBSD_NR_mmap:
 533         ret = get_errno(target_mmap(arg1, arg2, arg3,
 534                                     target_to_host_bitmask(arg4, mmap_flags_tbl),
 535                                     arg5,
 536                                     arg6));
 537         break;
 538     case TARGET_OPENBSD_NR_mprotect:
 539         ret = get_errno(target_mprotect(arg1, arg2, arg3));
 540         break;
 541     case TARGET_OPENBSD_NR_syscall:
 542     case TARGET_OPENBSD_NR___syscall:
 543         ret = do_openbsd_syscall(cpu_env,arg1 & 0xffff,arg2,arg3,arg4,arg5,arg6,0);
 544         break;
 545     default:
 546         ret = syscall(num, arg1, arg2, arg3, arg4, arg5, arg6);
 547         break;
 548     }
 549  fail:
 550 #ifdef DEBUG
 551     gemu_log(" = %ld\n", ret);
 552 #endif
 553     if (do_strace)
 554         print_openbsd_syscall_ret(num, ret);
 555     trace_guest_user_syscall_ret(cpu, num, ret);
 556     return ret;
 557  efault:
 558     ret = -TARGET_EFAULT;
 559     goto fail;
 560 }
 561
 562 void syscall_init(void)
 563 {
 564 }