blob: 9472079471bbfbbac8e24632ae5b79444f47e646 [file] [log] [blame]
Jeff Dike5e1f65a2006-09-25 23:33:01 -07001/*
Jeff Dikeba180fd2007-10-16 01:27:00 -07002 * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 * Licensed under the GPL
4 */
5
Jeff Dike8192ab42008-02-04 22:30:53 -08006#include <linux/mm.h>
Al Viro73395a02011-08-18 20:14:10 +01007#include <linux/module.h>
Jeff Dike8192ab42008-02-04 22:30:53 -08008#include <linux/sched.h>
9#include <asm/pgtable.h>
10#include <asm/tlbflush.h>
Al Viro37185b32012-10-08 03:27:32 +010011#include <as-layout.h>
12#include <mem_user.h>
13#include <os.h>
14#include <skas.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015
Jeff Dike1466abf2007-10-16 01:27:12 -070016struct host_vm_change {
17 struct host_vm_op {
18 enum { NONE, MMAP, MUNMAP, MPROTECT } type;
19 union {
20 struct {
21 unsigned long addr;
22 unsigned long len;
23 unsigned int prot;
24 int fd;
25 __u64 offset;
26 } mmap;
27 struct {
28 unsigned long addr;
29 unsigned long len;
30 } munmap;
31 struct {
32 unsigned long addr;
33 unsigned long len;
34 unsigned int prot;
35 } mprotect;
36 } u;
37 } ops[1];
38 int index;
39 struct mm_id *id;
40 void *data;
41 int force;
42};
43
44#define INIT_HVC(mm, force) \
45 ((struct host_vm_change) \
46 { .ops = { { .type = NONE } }, \
47 .id = &mm->context.id, \
48 .data = NULL, \
49 .index = 0, \
50 .force = force })
51
52static int do_ops(struct host_vm_change *hvc, int end,
53 int finished)
54{
55 struct host_vm_op *op;
56 int i, ret = 0;
57
58 for (i = 0; i < end && !ret; i++) {
59 op = &hvc->ops[i];
Jeff Dikec5d4bb12008-02-04 22:31:14 -080060 switch (op->type) {
Jeff Dike1466abf2007-10-16 01:27:12 -070061 case MMAP:
62 ret = map(hvc->id, op->u.mmap.addr, op->u.mmap.len,
63 op->u.mmap.prot, op->u.mmap.fd,
64 op->u.mmap.offset, finished, &hvc->data);
65 break;
66 case MUNMAP:
67 ret = unmap(hvc->id, op->u.munmap.addr,
68 op->u.munmap.len, finished, &hvc->data);
69 break;
70 case MPROTECT:
71 ret = protect(hvc->id, op->u.mprotect.addr,
72 op->u.mprotect.len, op->u.mprotect.prot,
73 finished, &hvc->data);
74 break;
75 default:
76 printk(KERN_ERR "Unknown op type %d in do_ops\n",
77 op->type);
Richard Weinberger62179d42012-04-13 15:54:01 +020078 BUG();
Jeff Dike1466abf2007-10-16 01:27:12 -070079 break;
80 }
81 }
82
83 return ret;
84}
85
Jeff Dikec5600492005-09-03 15:57:36 -070086static int add_mmap(unsigned long virt, unsigned long phys, unsigned long len,
Jeff Dike1466abf2007-10-16 01:27:12 -070087 unsigned int prot, struct host_vm_change *hvc)
Jeff Dikec5600492005-09-03 15:57:36 -070088{
Jeff Dike5e1f65a2006-09-25 23:33:01 -070089 __u64 offset;
Jeff Dikec5600492005-09-03 15:57:36 -070090 struct host_vm_op *last;
Bodo Stroesser07bf7312005-09-03 15:57:50 -070091 int fd, ret = 0;
Jeff Dikec5600492005-09-03 15:57:36 -070092
93 fd = phys_mapping(phys, &offset);
Jeff Dike1466abf2007-10-16 01:27:12 -070094 if (hvc->index != 0) {
95 last = &hvc->ops[hvc->index - 1];
Jeff Dikeba180fd2007-10-16 01:27:00 -070096 if ((last->type == MMAP) &&
Jeff Dikec5600492005-09-03 15:57:36 -070097 (last->u.mmap.addr + last->u.mmap.len == virt) &&
Jeff Dike16dd07b2007-05-06 14:51:48 -070098 (last->u.mmap.prot == prot) && (last->u.mmap.fd == fd) &&
Jeff Dikeba180fd2007-10-16 01:27:00 -070099 (last->u.mmap.offset + last->u.mmap.len == offset)) {
Jeff Dikec5600492005-09-03 15:57:36 -0700100 last->u.mmap.len += len;
Bodo Stroesser07bf7312005-09-03 15:57:50 -0700101 return 0;
Jeff Dikec5600492005-09-03 15:57:36 -0700102 }
103 }
104
Jeff Dike1466abf2007-10-16 01:27:12 -0700105 if (hvc->index == ARRAY_SIZE(hvc->ops)) {
106 ret = do_ops(hvc, ARRAY_SIZE(hvc->ops), 0);
107 hvc->index = 0;
Jeff Dikec5600492005-09-03 15:57:36 -0700108 }
109
Jeff Dike1466abf2007-10-16 01:27:12 -0700110 hvc->ops[hvc->index++] = ((struct host_vm_op)
111 { .type = MMAP,
112 .u = { .mmap = { .addr = virt,
113 .len = len,
114 .prot = prot,
115 .fd = fd,
116 .offset = offset }
Bodo Stroesser07bf7312005-09-03 15:57:50 -0700117 } });
118 return ret;
Jeff Dikec5600492005-09-03 15:57:36 -0700119}
120
121static int add_munmap(unsigned long addr, unsigned long len,
Jeff Dike1466abf2007-10-16 01:27:12 -0700122 struct host_vm_change *hvc)
Jeff Dikec5600492005-09-03 15:57:36 -0700123{
124 struct host_vm_op *last;
Bodo Stroesser07bf7312005-09-03 15:57:50 -0700125 int ret = 0;
Jeff Dikec5600492005-09-03 15:57:36 -0700126
Jeff Dike1466abf2007-10-16 01:27:12 -0700127 if (hvc->index != 0) {
128 last = &hvc->ops[hvc->index - 1];
Jeff Dikeba180fd2007-10-16 01:27:00 -0700129 if ((last->type == MUNMAP) &&
130 (last->u.munmap.addr + last->u.mmap.len == addr)) {
Jeff Dikec5600492005-09-03 15:57:36 -0700131 last->u.munmap.len += len;
Bodo Stroesser07bf7312005-09-03 15:57:50 -0700132 return 0;
Jeff Dikec5600492005-09-03 15:57:36 -0700133 }
134 }
135
Jeff Dike1466abf2007-10-16 01:27:12 -0700136 if (hvc->index == ARRAY_SIZE(hvc->ops)) {
137 ret = do_ops(hvc, ARRAY_SIZE(hvc->ops), 0);
138 hvc->index = 0;
Jeff Dikec5600492005-09-03 15:57:36 -0700139 }
140
Jeff Dike1466abf2007-10-16 01:27:12 -0700141 hvc->ops[hvc->index++] = ((struct host_vm_op)
142 { .type = MUNMAP,
143 .u = { .munmap = { .addr = addr,
144 .len = len } } });
Bodo Stroesser07bf7312005-09-03 15:57:50 -0700145 return ret;
Jeff Dikec5600492005-09-03 15:57:36 -0700146}
147
Jeff Dike16dd07b2007-05-06 14:51:48 -0700148static int add_mprotect(unsigned long addr, unsigned long len,
Jeff Dike1466abf2007-10-16 01:27:12 -0700149 unsigned int prot, struct host_vm_change *hvc)
Jeff Dikec5600492005-09-03 15:57:36 -0700150{
151 struct host_vm_op *last;
Bodo Stroesser07bf7312005-09-03 15:57:50 -0700152 int ret = 0;
Jeff Dikec5600492005-09-03 15:57:36 -0700153
Jeff Dike1466abf2007-10-16 01:27:12 -0700154 if (hvc->index != 0) {
155 last = &hvc->ops[hvc->index - 1];
Jeff Dikeba180fd2007-10-16 01:27:00 -0700156 if ((last->type == MPROTECT) &&
Jeff Dikec5600492005-09-03 15:57:36 -0700157 (last->u.mprotect.addr + last->u.mprotect.len == addr) &&
Jeff Dikeba180fd2007-10-16 01:27:00 -0700158 (last->u.mprotect.prot == prot)) {
Jeff Dikec5600492005-09-03 15:57:36 -0700159 last->u.mprotect.len += len;
Bodo Stroesser07bf7312005-09-03 15:57:50 -0700160 return 0;
Jeff Dikec5600492005-09-03 15:57:36 -0700161 }
162 }
163
Jeff Dike1466abf2007-10-16 01:27:12 -0700164 if (hvc->index == ARRAY_SIZE(hvc->ops)) {
165 ret = do_ops(hvc, ARRAY_SIZE(hvc->ops), 0);
166 hvc->index = 0;
Jeff Dikec5600492005-09-03 15:57:36 -0700167 }
168
Jeff Dike1466abf2007-10-16 01:27:12 -0700169 hvc->ops[hvc->index++] = ((struct host_vm_op)
170 { .type = MPROTECT,
171 .u = { .mprotect = { .addr = addr,
172 .len = len,
173 .prot = prot } } });
Bodo Stroesser07bf7312005-09-03 15:57:50 -0700174 return ret;
Jeff Dikec5600492005-09-03 15:57:36 -0700175}
176
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177#define ADD_ROUND(n, inc) (((n) + (inc)) & ~((inc) - 1))
178
Jeff Dike7f0536f2007-05-06 14:51:30 -0700179static inline int update_pte_range(pmd_t *pmd, unsigned long addr,
Jeff Dike1466abf2007-10-16 01:27:12 -0700180 unsigned long end,
181 struct host_vm_change *hvc)
Jeff Dike7f0536f2007-05-06 14:51:30 -0700182{
183 pte_t *pte;
Jeff Dike16dd07b2007-05-06 14:51:48 -0700184 int r, w, x, prot, ret = 0;
Jeff Dike7f0536f2007-05-06 14:51:30 -0700185
186 pte = pte_offset_kernel(pmd, addr);
187 do {
Jeff Dike39633332008-02-04 22:31:01 -0800188 if ((addr >= STUB_START) && (addr < STUB_END))
189 continue;
190
Jeff Dike7f0536f2007-05-06 14:51:30 -0700191 r = pte_read(*pte);
192 w = pte_write(*pte);
193 x = pte_exec(*pte);
194 if (!pte_young(*pte)) {
195 r = 0;
196 w = 0;
Jeff Dike0b4e2732008-02-04 22:31:07 -0800197 } else if (!pte_dirty(*pte))
Jeff Dike7f0536f2007-05-06 14:51:30 -0700198 w = 0;
Jeff Dike0b4e2732008-02-04 22:31:07 -0800199
Jeff Dike16dd07b2007-05-06 14:51:48 -0700200 prot = ((r ? UM_PROT_READ : 0) | (w ? UM_PROT_WRITE : 0) |
201 (x ? UM_PROT_EXEC : 0));
Jeff Dike1466abf2007-10-16 01:27:12 -0700202 if (hvc->force || pte_newpage(*pte)) {
Jeff Dikeba180fd2007-10-16 01:27:00 -0700203 if (pte_present(*pte))
Jeff Dike7f0536f2007-05-06 14:51:30 -0700204 ret = add_mmap(addr, pte_val(*pte) & PAGE_MASK,
Jeff Dike1466abf2007-10-16 01:27:12 -0700205 PAGE_SIZE, prot, hvc);
Jeff Dike0b4e2732008-02-04 22:31:07 -0800206 else
207 ret = add_munmap(addr, PAGE_SIZE, hvc);
208 } else if (pte_newprot(*pte))
Jeff Dike1466abf2007-10-16 01:27:12 -0700209 ret = add_mprotect(addr, PAGE_SIZE, prot, hvc);
Jeff Dike7f0536f2007-05-06 14:51:30 -0700210 *pte = pte_mkuptodate(*pte);
Jeff Dike909e90d2008-02-04 22:31:06 -0800211 } while (pte++, addr += PAGE_SIZE, ((addr < end) && !ret));
Jeff Dike7f0536f2007-05-06 14:51:30 -0700212 return ret;
213}
214
215static inline int update_pmd_range(pud_t *pud, unsigned long addr,
Jeff Dike1466abf2007-10-16 01:27:12 -0700216 unsigned long end,
217 struct host_vm_change *hvc)
Jeff Dike7f0536f2007-05-06 14:51:30 -0700218{
219 pmd_t *pmd;
220 unsigned long next;
221 int ret = 0;
222
223 pmd = pmd_offset(pud, addr);
224 do {
225 next = pmd_addr_end(addr, end);
Jeff Dikeba180fd2007-10-16 01:27:00 -0700226 if (!pmd_present(*pmd)) {
Jeff Dike1466abf2007-10-16 01:27:12 -0700227 if (hvc->force || pmd_newpage(*pmd)) {
228 ret = add_munmap(addr, next - addr, hvc);
Jeff Dike7f0536f2007-05-06 14:51:30 -0700229 pmd_mkuptodate(*pmd);
230 }
231 }
Jeff Dike1466abf2007-10-16 01:27:12 -0700232 else ret = update_pte_range(pmd, addr, next, hvc);
Jeff Dike909e90d2008-02-04 22:31:06 -0800233 } while (pmd++, addr = next, ((addr < end) && !ret));
Jeff Dike7f0536f2007-05-06 14:51:30 -0700234 return ret;
235}
236
237static inline int update_pud_range(pgd_t *pgd, unsigned long addr,
Jeff Dike1466abf2007-10-16 01:27:12 -0700238 unsigned long end,
239 struct host_vm_change *hvc)
Jeff Dike7f0536f2007-05-06 14:51:30 -0700240{
241 pud_t *pud;
242 unsigned long next;
243 int ret = 0;
244
245 pud = pud_offset(pgd, addr);
246 do {
247 next = pud_addr_end(addr, end);
Jeff Dikeba180fd2007-10-16 01:27:00 -0700248 if (!pud_present(*pud)) {
Jeff Dike1466abf2007-10-16 01:27:12 -0700249 if (hvc->force || pud_newpage(*pud)) {
250 ret = add_munmap(addr, next - addr, hvc);
Jeff Dike7f0536f2007-05-06 14:51:30 -0700251 pud_mkuptodate(*pud);
252 }
253 }
Jeff Dike1466abf2007-10-16 01:27:12 -0700254 else ret = update_pmd_range(pud, addr, next, hvc);
Jeff Dike909e90d2008-02-04 22:31:06 -0800255 } while (pud++, addr = next, ((addr < end) && !ret));
Jeff Dike7f0536f2007-05-06 14:51:30 -0700256 return ret;
257}
258
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259void fix_range_common(struct mm_struct *mm, unsigned long start_addr,
Jeff Dike1466abf2007-10-16 01:27:12 -0700260 unsigned long end_addr, int force)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261{
Jeff Dike7f0536f2007-05-06 14:51:30 -0700262 pgd_t *pgd;
Jeff Dike1466abf2007-10-16 01:27:12 -0700263 struct host_vm_change hvc;
Jeff Dike7f0536f2007-05-06 14:51:30 -0700264 unsigned long addr = start_addr, next;
Jeff Dike1466abf2007-10-16 01:27:12 -0700265 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266
Jeff Dike1466abf2007-10-16 01:27:12 -0700267 hvc = INIT_HVC(mm, force);
Jeff Dike7f0536f2007-05-06 14:51:30 -0700268 pgd = pgd_offset(mm, addr);
269 do {
270 next = pgd_addr_end(addr, end_addr);
Jeff Dikeba180fd2007-10-16 01:27:00 -0700271 if (!pgd_present(*pgd)) {
272 if (force || pgd_newpage(*pgd)) {
Jeff Dike1466abf2007-10-16 01:27:12 -0700273 ret = add_munmap(addr, next - addr, &hvc);
Jeff Dike7f0536f2007-05-06 14:51:30 -0700274 pgd_mkuptodate(*pgd);
Jeff Dike5e1f65a2006-09-25 23:33:01 -0700275 }
Jeff Dike5e1f65a2006-09-25 23:33:01 -0700276 }
Jeff Dike1466abf2007-10-16 01:27:12 -0700277 else ret = update_pud_range(pgd, addr, next, &hvc);
Jeff Dike909e90d2008-02-04 22:31:06 -0800278 } while (pgd++, addr = next, ((addr < end_addr) && !ret));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279
Jeff Dikeba180fd2007-10-16 01:27:00 -0700280 if (!ret)
Jeff Dike1466abf2007-10-16 01:27:12 -0700281 ret = do_ops(&hvc, hvc.index, 1);
Bodo Stroesser07bf7312005-09-03 15:57:50 -0700282
Jeff Dike7f0536f2007-05-06 14:51:30 -0700283 /* This is not an else because ret is modified above */
Jeff Dikeba180fd2007-10-16 01:27:00 -0700284 if (ret) {
285 printk(KERN_ERR "fix_range_common: failed, killing current "
286 "process\n");
Bodo Stroesser07bf7312005-09-03 15:57:50 -0700287 force_sig(SIGKILL, current);
288 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289}
290
Al Viroc75d0532011-08-18 20:07:49 +0100291static int flush_tlb_kernel_range_common(unsigned long start, unsigned long end)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292{
Jeff Dike5e1f65a2006-09-25 23:33:01 -0700293 struct mm_struct *mm;
294 pgd_t *pgd;
295 pud_t *pud;
296 pmd_t *pmd;
297 pte_t *pte;
298 unsigned long addr, last;
299 int updated = 0, err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300
Jeff Dike5e1f65a2006-09-25 23:33:01 -0700301 mm = &init_mm;
Jeff Dikeba180fd2007-10-16 01:27:00 -0700302 for (addr = start; addr < end;) {
Jeff Dike5e1f65a2006-09-25 23:33:01 -0700303 pgd = pgd_offset(mm, addr);
Jeff Dikeba180fd2007-10-16 01:27:00 -0700304 if (!pgd_present(*pgd)) {
Jeff Dike5e1f65a2006-09-25 23:33:01 -0700305 last = ADD_ROUND(addr, PGDIR_SIZE);
Jeff Dikeba180fd2007-10-16 01:27:00 -0700306 if (last > end)
Jeff Dike5e1f65a2006-09-25 23:33:01 -0700307 last = end;
Jeff Dikeba180fd2007-10-16 01:27:00 -0700308 if (pgd_newpage(*pgd)) {
Jeff Dike5e1f65a2006-09-25 23:33:01 -0700309 updated = 1;
310 err = os_unmap_memory((void *) addr,
311 last - addr);
Jeff Dikeba180fd2007-10-16 01:27:00 -0700312 if (err < 0)
Jeff Dike5e1f65a2006-09-25 23:33:01 -0700313 panic("munmap failed, errno = %d\n",
314 -err);
315 }
316 addr = last;
317 continue;
318 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319
Jeff Dike5e1f65a2006-09-25 23:33:01 -0700320 pud = pud_offset(pgd, addr);
Jeff Dikeba180fd2007-10-16 01:27:00 -0700321 if (!pud_present(*pud)) {
Jeff Dike5e1f65a2006-09-25 23:33:01 -0700322 last = ADD_ROUND(addr, PUD_SIZE);
Jeff Dikeba180fd2007-10-16 01:27:00 -0700323 if (last > end)
Jeff Dike5e1f65a2006-09-25 23:33:01 -0700324 last = end;
Jeff Dikeba180fd2007-10-16 01:27:00 -0700325 if (pud_newpage(*pud)) {
Jeff Dike5e1f65a2006-09-25 23:33:01 -0700326 updated = 1;
327 err = os_unmap_memory((void *) addr,
328 last - addr);
Jeff Dikeba180fd2007-10-16 01:27:00 -0700329 if (err < 0)
Jeff Dike5e1f65a2006-09-25 23:33:01 -0700330 panic("munmap failed, errno = %d\n",
331 -err);
332 }
333 addr = last;
334 continue;
335 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336
Jeff Dike5e1f65a2006-09-25 23:33:01 -0700337 pmd = pmd_offset(pud, addr);
Jeff Dikeba180fd2007-10-16 01:27:00 -0700338 if (!pmd_present(*pmd)) {
Jeff Dike5e1f65a2006-09-25 23:33:01 -0700339 last = ADD_ROUND(addr, PMD_SIZE);
Jeff Dikeba180fd2007-10-16 01:27:00 -0700340 if (last > end)
Jeff Dike5e1f65a2006-09-25 23:33:01 -0700341 last = end;
Jeff Dikeba180fd2007-10-16 01:27:00 -0700342 if (pmd_newpage(*pmd)) {
Jeff Dike5e1f65a2006-09-25 23:33:01 -0700343 updated = 1;
344 err = os_unmap_memory((void *) addr,
345 last - addr);
Jeff Dikeba180fd2007-10-16 01:27:00 -0700346 if (err < 0)
Jeff Dike5e1f65a2006-09-25 23:33:01 -0700347 panic("munmap failed, errno = %d\n",
348 -err);
349 }
350 addr = last;
351 continue;
352 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353
Jeff Dike5e1f65a2006-09-25 23:33:01 -0700354 pte = pte_offset_kernel(pmd, addr);
Jeff Dikeba180fd2007-10-16 01:27:00 -0700355 if (!pte_present(*pte) || pte_newpage(*pte)) {
Jeff Dike5e1f65a2006-09-25 23:33:01 -0700356 updated = 1;
357 err = os_unmap_memory((void *) addr,
358 PAGE_SIZE);
Jeff Dikeba180fd2007-10-16 01:27:00 -0700359 if (err < 0)
Jeff Dike5e1f65a2006-09-25 23:33:01 -0700360 panic("munmap failed, errno = %d\n",
361 -err);
Jeff Dikeba180fd2007-10-16 01:27:00 -0700362 if (pte_present(*pte))
Jeff Dike5e1f65a2006-09-25 23:33:01 -0700363 map_memory(addr,
364 pte_val(*pte) & PAGE_MASK,
365 PAGE_SIZE, 1, 1, 1);
366 }
Jeff Dikeba180fd2007-10-16 01:27:00 -0700367 else if (pte_newprot(*pte)) {
Jeff Dike5e1f65a2006-09-25 23:33:01 -0700368 updated = 1;
369 os_protect_memory((void *) addr, PAGE_SIZE, 1, 1, 1);
370 }
371 addr += PAGE_SIZE;
372 }
Jeff Dikeba180fd2007-10-16 01:27:00 -0700373 return updated;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374}
375
Jeff Dike77bf4402007-10-16 01:26:58 -0700376void flush_tlb_page(struct vm_area_struct *vma, unsigned long address)
377{
378 pgd_t *pgd;
379 pud_t *pud;
380 pmd_t *pmd;
381 pte_t *pte;
382 struct mm_struct *mm = vma->vm_mm;
383 void *flush = NULL;
384 int r, w, x, prot, err = 0;
385 struct mm_id *mm_id;
386
387 address &= PAGE_MASK;
388 pgd = pgd_offset(mm, address);
Jeff Dikeba180fd2007-10-16 01:27:00 -0700389 if (!pgd_present(*pgd))
Jeff Dike77bf4402007-10-16 01:26:58 -0700390 goto kill;
391
392 pud = pud_offset(pgd, address);
Jeff Dikeba180fd2007-10-16 01:27:00 -0700393 if (!pud_present(*pud))
Jeff Dike77bf4402007-10-16 01:26:58 -0700394 goto kill;
395
396 pmd = pmd_offset(pud, address);
Jeff Dikeba180fd2007-10-16 01:27:00 -0700397 if (!pmd_present(*pmd))
Jeff Dike77bf4402007-10-16 01:26:58 -0700398 goto kill;
399
400 pte = pte_offset_kernel(pmd, address);
401
402 r = pte_read(*pte);
403 w = pte_write(*pte);
404 x = pte_exec(*pte);
405 if (!pte_young(*pte)) {
406 r = 0;
407 w = 0;
408 } else if (!pte_dirty(*pte)) {
409 w = 0;
410 }
411
Jeff Dike6c738ff2007-10-16 01:27:06 -0700412 mm_id = &mm->context.id;
Jeff Dike77bf4402007-10-16 01:26:58 -0700413 prot = ((r ? UM_PROT_READ : 0) | (w ? UM_PROT_WRITE : 0) |
414 (x ? UM_PROT_EXEC : 0));
Jeff Dikeba180fd2007-10-16 01:27:00 -0700415 if (pte_newpage(*pte)) {
416 if (pte_present(*pte)) {
Jeff Dike77bf4402007-10-16 01:26:58 -0700417 unsigned long long offset;
418 int fd;
419
420 fd = phys_mapping(pte_val(*pte) & PAGE_MASK, &offset);
421 err = map(mm_id, address, PAGE_SIZE, prot, fd, offset,
422 1, &flush);
423 }
424 else err = unmap(mm_id, address, PAGE_SIZE, 1, &flush);
425 }
Jeff Dikeba180fd2007-10-16 01:27:00 -0700426 else if (pte_newprot(*pte))
Jeff Dike77bf4402007-10-16 01:26:58 -0700427 err = protect(mm_id, address, PAGE_SIZE, prot, 1, &flush);
428
Jeff Dikeba180fd2007-10-16 01:27:00 -0700429 if (err)
Jeff Dike77bf4402007-10-16 01:26:58 -0700430 goto kill;
431
432 *pte = pte_mkuptodate(*pte);
433
434 return;
435
436kill:
Jeff Dikeba180fd2007-10-16 01:27:00 -0700437 printk(KERN_ERR "Failed to flush page for address 0x%lx\n", address);
Jeff Dike77bf4402007-10-16 01:26:58 -0700438 force_sig(SIGKILL, current);
439}
440
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441pgd_t *pgd_offset_proc(struct mm_struct *mm, unsigned long address)
442{
Jeff Dikeba180fd2007-10-16 01:27:00 -0700443 return pgd_offset(mm, address);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444}
445
446pud_t *pud_offset_proc(pgd_t *pgd, unsigned long address)
447{
Jeff Dikeba180fd2007-10-16 01:27:00 -0700448 return pud_offset(pgd, address);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449}
450
451pmd_t *pmd_offset_proc(pud_t *pud, unsigned long address)
452{
Jeff Dikeba180fd2007-10-16 01:27:00 -0700453 return pmd_offset(pud, address);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454}
455
456pte_t *pte_offset_proc(pmd_t *pmd, unsigned long address)
457{
Jeff Dikeba180fd2007-10-16 01:27:00 -0700458 return pte_offset_kernel(pmd, address);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459}
460
461pte_t *addr_pte(struct task_struct *task, unsigned long addr)
462{
Jeff Dike5e1f65a2006-09-25 23:33:01 -0700463 pgd_t *pgd = pgd_offset(task->mm, addr);
464 pud_t *pud = pud_offset(pgd, addr);
465 pmd_t *pmd = pmd_offset(pud, addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466
Jeff Dikeba180fd2007-10-16 01:27:00 -0700467 return pte_offset_map(pmd, addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468}
469
Jeff Diked67b5692005-07-07 17:56:49 -0700470void flush_tlb_all(void)
471{
Jeff Dike5e1f65a2006-09-25 23:33:01 -0700472 flush_tlb_mm(current->mm);
Jeff Diked67b5692005-07-07 17:56:49 -0700473}
474
475void flush_tlb_kernel_range(unsigned long start, unsigned long end)
476{
Jeff Dike6aa802c2007-10-16 01:26:56 -0700477 flush_tlb_kernel_range_common(start, end);
Jeff Diked67b5692005-07-07 17:56:49 -0700478}
479
480void flush_tlb_kernel_vm(void)
481{
Jeff Dike6aa802c2007-10-16 01:26:56 -0700482 flush_tlb_kernel_range_common(start_vm, end_vm);
Jeff Diked67b5692005-07-07 17:56:49 -0700483}
484
485void __flush_tlb_one(unsigned long addr)
486{
Jeff Dikeba180fd2007-10-16 01:27:00 -0700487 flush_tlb_kernel_range_common(addr, addr + PAGE_SIZE);
Jeff Dike77bf4402007-10-16 01:26:58 -0700488}
489
Jeff Dike77bf4402007-10-16 01:26:58 -0700490static void fix_range(struct mm_struct *mm, unsigned long start_addr,
491 unsigned long end_addr, int force)
492{
Jeff Dike1466abf2007-10-16 01:27:12 -0700493 fix_range_common(mm, start_addr, end_addr, force);
Jeff Diked67b5692005-07-07 17:56:49 -0700494}
495
496void flush_tlb_range(struct vm_area_struct *vma, unsigned long start,
497 unsigned long end)
498{
Jeff Dikeba180fd2007-10-16 01:27:00 -0700499 if (vma->vm_mm == NULL)
500 flush_tlb_kernel_range_common(start, end);
501 else fix_range(vma->vm_mm, start, end, 0);
Jeff Diked67b5692005-07-07 17:56:49 -0700502}
Al Viro73395a02011-08-18 20:14:10 +0100503EXPORT_SYMBOL(flush_tlb_range);
Jeff Diked67b5692005-07-07 17:56:49 -0700504
Jeff Dike0b4e2732008-02-04 22:31:07 -0800505void flush_tlb_mm_range(struct mm_struct *mm, unsigned long start,
506 unsigned long end)
Jeff Diked67b5692005-07-07 17:56:49 -0700507{
Jeff Dikeba180fd2007-10-16 01:27:00 -0700508 /*
509 * Don't bother flushing if this address space is about to be
510 * destroyed.
511 */
512 if (atomic_read(&mm->mm_users) == 0)
513 return;
Jeff Dike77bf4402007-10-16 01:26:58 -0700514
Jeff Dike0b4e2732008-02-04 22:31:07 -0800515 fix_range(mm, start, end, 0);
516}
517
518void flush_tlb_mm(struct mm_struct *mm)
519{
520 struct vm_area_struct *vma = mm->mmap;
521
522 while (vma != NULL) {
523 fix_range(mm, vma->vm_start, vma->vm_end, 0);
524 vma = vma->vm_next;
525 }
Jeff Diked67b5692005-07-07 17:56:49 -0700526}
527
528void force_flush_all(void)
529{
Jeff Dike77bf4402007-10-16 01:26:58 -0700530 struct mm_struct *mm = current->mm;
531 struct vm_area_struct *vma = mm->mmap;
532
Jeff Dikeba180fd2007-10-16 01:27:00 -0700533 while (vma != NULL) {
Jeff Dike77bf4402007-10-16 01:26:58 -0700534 fix_range(mm, vma->vm_start, vma->vm_end, 1);
535 vma = vma->vm_next;
536 }
Jeff Diked67b5692005-07-07 17:56:49 -0700537}