linux-user/uaccess.c

   1 /* User memory access */
   2 #include "qemu/osdep.h"
   3 #include "qemu/cutils.h"
   4
   5 #include "qemu.h"
   6
   7 void *lock_user(int type, abi_ulong guest_addr, long len, int copy)
   8 {
   9     if (!access_ok_untagged(type, guest_addr, len)) {
  10         return NULL;
  11     }
  12 #ifdef DEBUG_REMAP
  13     {
  14         void *addr;
  15         addr = g_malloc(len);
  16         if (copy) {
  17             memcpy(addr, g2h(guest_addr), len);
  18         } else {
  19             memset(addr, 0, len);
  20         }
  21         return addr;
  22     }
  23 #else
  24     return g2h_untagged(guest_addr);
  25 #endif
  26 }
  27
  28 #ifdef DEBUG_REMAP
  29 void unlock_user(void *host_ptr, abi_ulong guest_addr, long len);
  30 {
  31     if (!host_ptr) {
  32         return;
  33     }
  34     if (host_ptr == g2h_untagged(guest_addr)) {
  35         return;
  36     }
  37     if (len > 0) {
  38         memcpy(g2h_untagged(guest_addr), host_ptr, len);
  39     }
  40     g_free(host_ptr);
  41 }
  42 #endif
  43
  44 void *lock_user_string(abi_ulong guest_addr)
  45 {
  46     abi_long len = target_strlen(guest_addr);
  47     if (len < 0) {
  48         return NULL;
  49     }
  50     return lock_user(VERIFY_READ, guest_addr, (long)(len + 1), 1);
  51 }
  52
  53 /* copy_from_user() and copy_to_user() are usually used to copy data
  54  * buffers between the target and host.  These internally perform
  55  * locking/unlocking of the memory.
  56  */
  57 abi_long copy_from_user(void *hptr, abi_ulong gaddr, size_t len)
  58 {
  59     abi_long ret = 0;
  60     void *ghptr;
  61
  62     if ((ghptr = lock_user(VERIFY_READ, gaddr, len, 1))) {
  63         memcpy(hptr, ghptr, len);
  64         unlock_user(ghptr, gaddr, 0);
  65     } else
  66         ret = -TARGET_EFAULT;
  67
  68     return ret;
  69 }
  70
  71
  72 abi_long copy_to_user(abi_ulong gaddr, void *hptr, size_t len)
  73 {
  74     abi_long ret = 0;
  75     void *ghptr;
  76
  77     if ((ghptr = lock_user(VERIFY_WRITE, gaddr, len, 0))) {
  78         memcpy(ghptr, hptr, len);
  79         unlock_user(ghptr, gaddr, len);
  80     } else
  81         ret = -TARGET_EFAULT;
  82
  83     return ret;
  84 }
  85
  86 /* Return the length of a string in target memory or -TARGET_EFAULT if
  87    access error  */
  88 abi_long target_strlen(abi_ulong guest_addr1)
  89 {
  90     uint8_t *ptr;
  91     abi_ulong guest_addr;
  92     int max_len, len;
  93
  94     guest_addr = guest_addr1;
  95     for(;;) {
  96         max_len = TARGET_PAGE_SIZE - (guest_addr & ~TARGET_PAGE_MASK);
  97         ptr = lock_user(VERIFY_READ, guest_addr, max_len, 1);
  98         if (!ptr)
  99             return -TARGET_EFAULT;
 100         len = qemu_strnlen((const char *)ptr, max_len);
 101         unlock_user(ptr, guest_addr, 0);
 102         guest_addr += len;
 103         /* we don't allow wrapping or integer overflow */
 104         if (guest_addr == 0 ||
 105             (guest_addr - guest_addr1) > 0x7fffffff)
 106             return -TARGET_EFAULT;
 107         if (len != max_len)
 108             break;
 109     }
 110     return guest_addr - guest_addr1;
 111 }