/arch/um/kernel/skas/mmu.c

http://github.com/mirrors/linux · C · 167 lines · 124 code · 31 blank · 12 comment · 24 complexity · b3dbcd27e5fdae102e0f35b0beb41467 MD5 · raw file

  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Copyright (C) 2015 Thomas Meyer (thomas@m3y3r.de)
  4. * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
  5. */
  6. #include <linux/mm.h>
  7. #include <linux/sched/signal.h>
  8. #include <linux/slab.h>
  9. #include <asm/pgalloc.h>
  10. #include <asm/pgtable.h>
  11. #include <asm/sections.h>
  12. #include <as-layout.h>
  13. #include <os.h>
  14. #include <skas.h>
  15. static int init_stub_pte(struct mm_struct *mm, unsigned long proc,
  16. unsigned long kernel)
  17. {
  18. pgd_t *pgd;
  19. p4d_t *p4d;
  20. pud_t *pud;
  21. pmd_t *pmd;
  22. pte_t *pte;
  23. pgd = pgd_offset(mm, proc);
  24. p4d = p4d_alloc(mm, pgd, proc);
  25. if (!p4d)
  26. goto out;
  27. pud = pud_alloc(mm, p4d, proc);
  28. if (!pud)
  29. goto out_pud;
  30. pmd = pmd_alloc(mm, pud, proc);
  31. if (!pmd)
  32. goto out_pmd;
  33. pte = pte_alloc_map(mm, pmd, proc);
  34. if (!pte)
  35. goto out_pte;
  36. *pte = mk_pte(virt_to_page(kernel), __pgprot(_PAGE_PRESENT));
  37. *pte = pte_mkread(*pte);
  38. return 0;
  39. out_pte:
  40. pmd_free(mm, pmd);
  41. out_pmd:
  42. pud_free(mm, pud);
  43. out_pud:
  44. p4d_free(mm, p4d);
  45. out:
  46. return -ENOMEM;
  47. }
  48. int init_new_context(struct task_struct *task, struct mm_struct *mm)
  49. {
  50. struct mm_context *from_mm = NULL;
  51. struct mm_context *to_mm = &mm->context;
  52. unsigned long stack = 0;
  53. int ret = -ENOMEM;
  54. stack = get_zeroed_page(GFP_KERNEL);
  55. if (stack == 0)
  56. goto out;
  57. to_mm->id.stack = stack;
  58. if (current->mm != NULL && current->mm != &init_mm)
  59. from_mm = &current->mm->context;
  60. block_signals_trace();
  61. if (from_mm)
  62. to_mm->id.u.pid = copy_context_skas0(stack,
  63. from_mm->id.u.pid);
  64. else to_mm->id.u.pid = start_userspace(stack);
  65. unblock_signals_trace();
  66. if (to_mm->id.u.pid < 0) {
  67. ret = to_mm->id.u.pid;
  68. goto out_free;
  69. }
  70. ret = init_new_ldt(to_mm, from_mm);
  71. if (ret < 0) {
  72. printk(KERN_ERR "init_new_context_skas - init_ldt"
  73. " failed, errno = %d\n", ret);
  74. goto out_free;
  75. }
  76. return 0;
  77. out_free:
  78. if (to_mm->id.stack != 0)
  79. free_page(to_mm->id.stack);
  80. out:
  81. return ret;
  82. }
  83. void uml_setup_stubs(struct mm_struct *mm)
  84. {
  85. int err, ret;
  86. ret = init_stub_pte(mm, STUB_CODE,
  87. (unsigned long) __syscall_stub_start);
  88. if (ret)
  89. goto out;
  90. ret = init_stub_pte(mm, STUB_DATA, mm->context.id.stack);
  91. if (ret)
  92. goto out;
  93. mm->context.stub_pages[0] = virt_to_page(__syscall_stub_start);
  94. mm->context.stub_pages[1] = virt_to_page(mm->context.id.stack);
  95. /* dup_mmap already holds mmap_sem */
  96. err = install_special_mapping(mm, STUB_START, STUB_END - STUB_START,
  97. VM_READ | VM_MAYREAD | VM_EXEC |
  98. VM_MAYEXEC | VM_DONTCOPY | VM_PFNMAP,
  99. mm->context.stub_pages);
  100. if (err) {
  101. printk(KERN_ERR "install_special_mapping returned %d\n", err);
  102. goto out;
  103. }
  104. return;
  105. out:
  106. force_sigsegv(SIGSEGV);
  107. }
  108. void arch_exit_mmap(struct mm_struct *mm)
  109. {
  110. pte_t *pte;
  111. pte = virt_to_pte(mm, STUB_CODE);
  112. if (pte != NULL)
  113. pte_clear(mm, STUB_CODE, pte);
  114. pte = virt_to_pte(mm, STUB_DATA);
  115. if (pte == NULL)
  116. return;
  117. pte_clear(mm, STUB_DATA, pte);
  118. }
  119. void destroy_context(struct mm_struct *mm)
  120. {
  121. struct mm_context *mmu = &mm->context;
  122. /*
  123. * If init_new_context wasn't called, this will be
  124. * zero, resulting in a kill(0), which will result in the
  125. * whole UML suddenly dying. Also, cover negative and
  126. * 1 cases, since they shouldn't happen either.
  127. */
  128. if (mmu->id.u.pid < 2) {
  129. printk(KERN_ERR "corrupt mm_context - pid = %d\n",
  130. mmu->id.u.pid);
  131. return;
  132. }
  133. os_kill_ptraced_process(mmu->id.u.pid, 1);
  134. free_page(mmu->id.stack);
  135. free_ldt(mmu);
  136. }