shim_mmap.c 4.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177
  1. /* -*- mode:c; c-file-style:"k&r"; c-basic-offset: 4; tab-width:4; indent-tabs-mode:nil; mode:auto-fill; fill-column:78; -*- */
  2. /* vim: set ts=4 sw=4 et tw=78 fo=cqt wm=0: */
  3. /* Copyright (C) 2014 Stony Brook University
  4. This file is part of Graphene Library OS.
  5. Graphene Library OS is free software: you can redistribute it and/or
  6. modify it under the terms of the GNU Lesser General Public License
  7. as published by the Free Software Foundation, either version 3 of the
  8. License, or (at your option) any later version.
  9. Graphene Library OS is distributed in the hope that it will be useful,
  10. but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12. GNU Lesser General Public License for more details.
  13. You should have received a copy of the GNU Lesser General Public License
  14. along with this program. If not, see <http://www.gnu.org/licenses/>. */
  15. /*
  16. * shim_mmap.c
  17. *
  18. * Implementation of system call "mmap", "munmap" and "mprotect".
  19. */
  20. #include <shim_internal.h>
  21. #include <shim_table.h>
  22. #include <shim_handle.h>
  23. #include <shim_vma.h>
  24. #include <shim_fs.h>
  25. #include <shim_profile.h>
  26. #include <pal.h>
  27. #include <pal_error.h>
  28. #include <sys/mman.h>
  29. #include <errno.h>
  30. DEFINE_PROFILE_OCCURENCE(mmap, memory);
  31. void * shim_do_mmap (void * addr, size_t length, int prot, int flags, int fd,
  32. off_t offset)
  33. {
  34. struct shim_handle * hdl = NULL;
  35. long ret = -ENOMEM;
  36. bool reserved = false;
  37. if (addr + length < addr) {
  38. return (void *) -EINVAL;
  39. }
  40. assert(!(flags & (VMA_UNMAPPED|VMA_TAINTED)));
  41. if (flags & MAP_32BIT)
  42. return (void *) -ENOSYS;
  43. int pal_alloc_type = 0;
  44. if ((flags & MAP_FIXED) || addr) {
  45. struct shim_vma * tmp = NULL;
  46. if (!lookup_overlap_vma(addr, length, &tmp)) {
  47. debug("mmap: allowing overlapping MAP_FIXED allocation at %p with length %lu\n",
  48. addr, length);
  49. if (!(flags & MAP_FIXED))
  50. addr = NULL;
  51. }
  52. }
  53. if (!addr) {
  54. addr = get_unmapped_vma(ALIGN_UP(length), flags);
  55. if (addr) {
  56. reserved = true;
  57. // Approximate check only, to help root out bugs.
  58. void * cur_stack = current_stack();
  59. assert(cur_stack < addr || cur_stack > addr + length);
  60. }
  61. }
  62. void * mapped = ALIGN_DOWN((void *) addr);
  63. void * mapped_end = ALIGN_UP((void *) addr + length);
  64. addr = mapped;
  65. length = mapped_end - mapped;
  66. if (flags & MAP_ANONYMOUS) {
  67. addr = (void *) DkVirtualMemoryAlloc(addr, length, pal_alloc_type,
  68. PAL_PROT(prot, 0));
  69. if (!addr) {
  70. ret = (PAL_NATIVE_ERRNO == PAL_ERROR_DENIED) ? -EPERM : -PAL_ERRNO;
  71. goto free_reserved;
  72. }
  73. ADD_PROFILE_OCCURENCE(mmap, length);
  74. } else {
  75. if (fd < 0) {
  76. ret = -EINVAL;
  77. goto free_reserved;
  78. }
  79. hdl = get_fd_handle(fd, NULL, NULL);
  80. if (!hdl) {
  81. ret = -EBADF;
  82. goto free_reserved;
  83. }
  84. if (!hdl->fs || !hdl->fs->fs_ops || !hdl->fs->fs_ops->mmap) {
  85. put_handle(hdl);
  86. ret = -ENODEV;
  87. goto free_reserved;
  88. }
  89. if ((ret = hdl->fs->fs_ops->mmap(hdl, &addr, length, PAL_PROT(prot, flags),
  90. flags, offset)) < 0) {
  91. put_handle(hdl);
  92. goto free_reserved;
  93. }
  94. }
  95. if (addr != mapped) {
  96. mapped = ALIGN_DOWN((void *) addr);
  97. mapped_end = ALIGN_UP((void *) addr + length);
  98. }
  99. ret = bkeep_mmap((void *) mapped, mapped_end - mapped, prot,
  100. flags, hdl, offset, NULL);
  101. assert(!ret);
  102. if (hdl)
  103. put_handle(hdl);
  104. return addr;
  105. free_reserved:
  106. if (reserved)
  107. bkeep_munmap((void *) mapped, mapped_end - mapped, &flags);
  108. return (void *) ret;
  109. }
  110. int shim_do_mprotect (void * addr, size_t len, int prot)
  111. {
  112. uintptr_t mapped = ALIGN_DOWN((uintptr_t) addr);
  113. uintptr_t mapped_end = ALIGN_UP((uintptr_t) addr + len);
  114. int flags = 0;
  115. if (bkeep_mprotect((void *) mapped, mapped_end - mapped, prot, &flags) < 0)
  116. return -EACCES;
  117. if (!DkVirtualMemoryProtect((void *) mapped, mapped_end - mapped, prot))
  118. return -PAL_ERRNO;
  119. return 0;
  120. }
  121. int shim_do_munmap (void * addr, size_t len)
  122. {
  123. struct shim_vma * tmp = NULL;
  124. if (lookup_overlap_vma(addr, len, &tmp) < 0) {
  125. debug("can't find addr %p - %p in map, quit unmapping\n",
  126. addr, addr + len);
  127. /* Really not an error */
  128. return -EFAULT;
  129. }
  130. uintptr_t mapped = ALIGN_DOWN((uintptr_t) addr);
  131. uintptr_t mapped_end = ALIGN_UP((uintptr_t) addr + len);
  132. int flags = 0;
  133. if (bkeep_munmap((void *) mapped, mapped_end - mapped, &flags) < 0)
  134. return -EACCES;
  135. DkVirtualMemoryFree((void *) mapped, mapped_end - mapped);
  136. return 0;
  137. }