fault.c 5.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240
  1. // TODO VM_EXEC flag work-around, cache aliasing
  2. /*
  3. * arch/xtensa/mm/fault.c
  4. *
  5. * This file is subject to the terms and conditions of the GNU General Public
  6. * License. See the file "COPYING" in the main directory of this archive
  7. * for more details.
  8. *
  9. * Copyright (C) 2001 - 2005 Tensilica Inc.
  10. *
  11. * Chris Zankel <chris@zankel.net>
  12. * Joe Taylor <joe@tensilica.com, joetylr@yahoo.com>
  13. */
  14. #include <linux/mm.h>
  15. #include <linux/module.h>
  16. #include <asm/mmu_context.h>
  17. #include <asm/cacheflush.h>
  18. #include <asm/hardirq.h>
  19. #include <asm/uaccess.h>
  20. #include <asm/system.h>
  21. #include <asm/pgalloc.h>
  22. unsigned long asid_cache = ASID_USER_FIRST;
  23. void bad_page_fault(struct pt_regs*, unsigned long, int);
  24. /*
  25. * This routine handles page faults. It determines the address,
  26. * and the problem, and then passes it off to one of the appropriate
  27. * routines.
  28. *
  29. * Note: does not handle Miss and MultiHit.
  30. */
  31. void do_page_fault(struct pt_regs *regs)
  32. {
  33. struct vm_area_struct * vma;
  34. struct mm_struct *mm = current->mm;
  35. unsigned int exccause = regs->exccause;
  36. unsigned int address = regs->excvaddr;
  37. siginfo_t info;
  38. int is_write, is_exec;
  39. int fault;
  40. info.si_code = SEGV_MAPERR;
  41. /* We fault-in kernel-space virtual memory on-demand. The
  42. * 'reference' page table is init_mm.pgd.
  43. */
  44. if (address >= TASK_SIZE && !user_mode(regs))
  45. goto vmalloc_fault;
  46. /* If we're in an interrupt or have no user
  47. * context, we must not take the fault..
  48. */
  49. if (in_atomic() || !mm) {
  50. bad_page_fault(regs, address, SIGSEGV);
  51. return;
  52. }
  53. is_write = (exccause == EXCCAUSE_STORE_CACHE_ATTRIBUTE) ? 1 : 0;
  54. is_exec = (exccause == EXCCAUSE_ITLB_PRIVILEGE ||
  55. exccause == EXCCAUSE_ITLB_MISS ||
  56. exccause == EXCCAUSE_FETCH_CACHE_ATTRIBUTE) ? 1 : 0;
  57. #if 0
  58. printk("[%s:%d:%08x:%d:%08x:%s%s]\n", current->comm, current->pid,
  59. address, exccause, regs->pc, is_write? "w":"", is_exec? "x":"");
  60. #endif
  61. down_read(&mm->mmap_sem);
  62. vma = find_vma(mm, address);
  63. if (!vma)
  64. goto bad_area;
  65. if (vma->vm_start <= address)
  66. goto good_area;
  67. if (!(vma->vm_flags & VM_GROWSDOWN))
  68. goto bad_area;
  69. if (expand_stack(vma, address))
  70. goto bad_area;
  71. /* Ok, we have a good vm_area for this memory access, so
  72. * we can handle it..
  73. */
  74. good_area:
  75. info.si_code = SEGV_ACCERR;
  76. if (is_write) {
  77. if (!(vma->vm_flags & VM_WRITE))
  78. goto bad_area;
  79. } else if (is_exec) {
  80. if (!(vma->vm_flags & VM_EXEC))
  81. goto bad_area;
  82. } else /* Allow read even from write-only pages. */
  83. if (!(vma->vm_flags & (VM_READ | VM_WRITE)))
  84. goto bad_area;
  85. /* If for any reason at all we couldn't handle the fault,
  86. * make sure we exit gracefully rather than endlessly redo
  87. * the fault.
  88. */
  89. survive:
  90. fault = handle_mm_fault(mm, vma, address, is_write);
  91. if (unlikely(fault & VM_FAULT_ERROR)) {
  92. if (fault & VM_FAULT_OOM)
  93. goto out_of_memory;
  94. else if (fault & VM_FAULT_SIGBUS)
  95. goto do_sigbus;
  96. BUG();
  97. }
  98. if (fault & VM_FAULT_MAJOR)
  99. current->maj_flt++;
  100. else
  101. current->min_flt++;
  102. up_read(&mm->mmap_sem);
  103. return;
  104. /* Something tried to access memory that isn't in our memory map..
  105. * Fix it, but check if it's kernel or user first..
  106. */
  107. bad_area:
  108. up_read(&mm->mmap_sem);
  109. if (user_mode(regs)) {
  110. current->thread.bad_vaddr = address;
  111. current->thread.error_code = is_write;
  112. info.si_signo = SIGSEGV;
  113. info.si_errno = 0;
  114. /* info.si_code has been set above */
  115. info.si_addr = (void *) address;
  116. force_sig_info(SIGSEGV, &info, current);
  117. return;
  118. }
  119. bad_page_fault(regs, address, SIGSEGV);
  120. return;
  121. /* We ran out of memory, or some other thing happened to us that made
  122. * us unable to handle the page fault gracefully.
  123. */
  124. out_of_memory:
  125. up_read(&mm->mmap_sem);
  126. if (is_init(current)) {
  127. yield();
  128. down_read(&mm->mmap_sem);
  129. goto survive;
  130. }
  131. printk("VM: killing process %s\n", current->comm);
  132. if (user_mode(regs))
  133. do_exit(SIGKILL);
  134. bad_page_fault(regs, address, SIGKILL);
  135. return;
  136. do_sigbus:
  137. up_read(&mm->mmap_sem);
  138. /* Send a sigbus, regardless of whether we were in kernel
  139. * or user mode.
  140. */
  141. current->thread.bad_vaddr = address;
  142. info.si_code = SIGBUS;
  143. info.si_errno = 0;
  144. info.si_code = BUS_ADRERR;
  145. info.si_addr = (void *) address;
  146. force_sig_info(SIGBUS, &info, current);
  147. /* Kernel mode? Handle exceptions or die */
  148. if (!user_mode(regs))
  149. bad_page_fault(regs, address, SIGBUS);
  150. vmalloc_fault:
  151. {
  152. /* Synchronize this task's top level page-table
  153. * with the 'reference' page table.
  154. */
  155. struct mm_struct *act_mm = current->active_mm;
  156. int index = pgd_index(address);
  157. pgd_t *pgd, *pgd_k;
  158. pmd_t *pmd, *pmd_k;
  159. pte_t *pte_k;
  160. if (act_mm == NULL)
  161. goto bad_page_fault;
  162. pgd = act_mm->pgd + index;
  163. pgd_k = init_mm.pgd + index;
  164. if (!pgd_present(*pgd_k))
  165. goto bad_page_fault;
  166. pgd_val(*pgd) = pgd_val(*pgd_k);
  167. pmd = pmd_offset(pgd, address);
  168. pmd_k = pmd_offset(pgd_k, address);
  169. if (!pmd_present(*pmd) || !pmd_present(*pmd_k))
  170. goto bad_page_fault;
  171. pmd_val(*pmd) = pmd_val(*pmd_k);
  172. pte_k = pte_offset_kernel(pmd_k, address);
  173. if (!pte_present(*pte_k))
  174. goto bad_page_fault;
  175. return;
  176. }
  177. bad_page_fault:
  178. bad_page_fault(regs, address, SIGKILL);
  179. return;
  180. }
  181. void
  182. bad_page_fault(struct pt_regs *regs, unsigned long address, int sig)
  183. {
  184. extern void die(const char*, struct pt_regs*, long);
  185. const struct exception_table_entry *entry;
  186. /* Are we prepared to handle this kernel fault? */
  187. if ((entry = search_exception_tables(regs->pc)) != NULL) {
  188. #if 1
  189. printk(KERN_DEBUG "%s: Exception at pc=%#010lx (%lx)\n",
  190. current->comm, regs->pc, entry->fixup);
  191. #endif
  192. current->thread.bad_uaddr = address;
  193. regs->pc = entry->fixup;
  194. return;
  195. }
  196. /* Oops. The kernel tried to access some bad page. We'll have to
  197. * terminate things with extreme prejudice.
  198. */
  199. printk(KERN_ALERT "Unable to handle kernel paging request at virtual "
  200. "address %08lx\n pc = %08lx, ra = %08lx\n",
  201. address, regs->pc, regs->areg[0]);
  202. die("Oops", regs, sig);
  203. do_exit(sig);
  204. }