xref: /minix/minix/servers/vm/mmap.c (revision 83133719) 
1 
2 #define _SYSTEM 1
3 
4 #include <minix/callnr.h>
5 #include <minix/com.h>
6 #include <minix/config.h>
7 #include <minix/const.h>
8 #include <minix/ds.h>
9 #include <minix/endpoint.h>
10 #include <minix/minlib.h>
11 #include <minix/type.h>
12 #include <minix/ipc.h>
13 #include <minix/sysutil.h>
14 #include <minix/syslib.h>
15 #include <minix/safecopies.h>
16 #include <minix/bitmap.h>
17 #include <minix/debug.h>
18 
19 #include <machine/vmparam.h>
20 
21 #include <sys/mman.h>
22 #include <sys/param.h>
23 
24 #include <errno.h>
25 #include <assert.h>
26 #include <string.h>
27 #include <env.h>
28 #include <stdio.h>
29 #include <fcntl.h>
30 
31 #include "glo.h"
32 #include "proto.h"
33 #include "util.h"
34 #include "region.h"
35 
36 
37 static struct vir_region *mmap_region(struct vmproc *vmp, vir_bytes addr,
38 	u32_t vmm_flags, size_t len, u32_t vrflags,
39 	mem_type_t *mt, int execpriv)
40 {
41 	u32_t mfflags = 0;
42 	struct vir_region *vr = NULL;
43 
44 	if(vmm_flags & MAP_LOWER16M) vrflags |= VR_LOWER16MB;
45 	if(vmm_flags & MAP_LOWER1M)  vrflags |= VR_LOWER1MB;
46 	if(vmm_flags & MAP_ALIGNMENT_64KB) vrflags |= VR_PHYS64K;
47 	if(vmm_flags & MAP_PREALLOC) mfflags |= MF_PREALLOC;
48 	if(vmm_flags & MAP_UNINITIALIZED) {
49 		if(!execpriv) return NULL;
50 		vrflags |= VR_UNINITIALIZED;
51 	}
52 
53 	if(len <= 0) {
54 		return NULL;
55 	}
56 
57 	if(len % VM_PAGE_SIZE)
58 		len += VM_PAGE_SIZE - (len % VM_PAGE_SIZE);
59 
60 	if (addr && (vmm_flags & MAP_FIXED)) {
61 		int r = map_unmap_range(vmp, addr, len);
62 		if(r != OK) {
63 			printf("mmap_region: map_unmap_range failed (%d)\n", r);
64 			return NULL;
65 		}
66 	}
67 
68 	if (addr || (vmm_flags & MAP_FIXED)) {
69 		/* An address is given, first try at that address. */
70 		vr = map_page_region(vmp, addr, 0, len,
71 			vrflags, mfflags, mt);
72 		if(!vr && (vmm_flags & MAP_FIXED))
73 			return NULL;
74 	}
75 
76 	if (!vr) {
77 		/* No address given or address already in use. */
78 		vr = map_page_region(vmp, VM_PAGE_SIZE, VM_DATATOP, len,
79 			vrflags, mfflags, mt);
80 	}
81 
82 	return vr;
83 }
84 
85 static int mmap_file(struct vmproc *vmp,
86 	int vmfd, off_t file_offset, int flags,
87 	ino_t ino, dev_t dev, u64_t filesize, vir_bytes addr, vir_bytes len,
88 	vir_bytes *retaddr, u16_t clearend, int writable, int mayclosefd)
89 {
90 /* VFS has replied to a VMVFSREQ_FDLOOKUP request. */
91 	struct vir_region *vr;
92 	u64_t page_offset;
93 	int result = OK;
94 	u32_t vrflags = 0;
95 
96 	if(writable) vrflags |= VR_WRITABLE;
97 
98 	/* Do some page alignments. */
99 	if((page_offset = (file_offset % VM_PAGE_SIZE))) {
100 		file_offset -= page_offset;
101 		len += page_offset;
102 	}
103 
104 	len = roundup(len, VM_PAGE_SIZE);
105 
106 	/* All numbers should be page-aligned now. */
107 	assert(!(len % VM_PAGE_SIZE));
108 	assert(!(filesize % VM_PAGE_SIZE));
109 	assert(!(file_offset % VM_PAGE_SIZE));
110 
111 #if 0
112 	/* XXX ld.so relies on longer-than-file mapping */
113 	if((u64_t) len + file_offset > filesize) {
114 		printf("VM: truncating mmap dev 0x%x ino %d beyond file size in %d; offset %llu, len %lu, size %llu; ",
115 			dev, ino, vmp->vm_endpoint,
116 			file_offset, len, filesize);
117 		len = filesize - file_offset;
118 		return EINVAL;
119 	}
120 #endif
121 
122 	if(!(vr = mmap_region(vmp, addr, flags, len,
123 		vrflags, &mem_type_mappedfile, 0))) {
124 		result = ENOMEM;
125 	} else {
126 		*retaddr = vr->vaddr + page_offset;
127 		result = OK;
128 
129 		mappedfile_setfile(vmp, vr, vmfd,
130 			file_offset, dev, ino, clearend, 1, mayclosefd);
131 	}
132 
133 	return result;
134 }
135 
136 int do_vfs_mmap(message *m)
137 {
138 	vir_bytes v;
139 	struct vmproc *vmp;
140 	int r, n;
141 	u16_t clearend, flags = 0;
142 
143 	/* It might be disabled */
144 	if(!enable_filemap) return ENXIO;
145 
146 	clearend = m->m_vm_vfs_mmap.clearend;
147 	flags = m->m_vm_vfs_mmap.flags;
148 
149 	if((r=vm_isokendpt(m->m_vm_vfs_mmap.who, &n)) != OK)
150 		panic("bad ep %d from vfs", m->m_vm_vfs_mmap.who);
151 	vmp = &vmproc[n];
152 
153 	return mmap_file(vmp, m->m_vm_vfs_mmap.fd, m->m_vm_vfs_mmap.offset,
154 		MAP_PRIVATE | MAP_FIXED,
155 		m->m_vm_vfs_mmap.ino, m->m_vm_vfs_mmap.dev,
156 		(u64_t) LONG_MAX * VM_PAGE_SIZE,
157 		m->m_vm_vfs_mmap.vaddr, m->m_vm_vfs_mmap.len, &v,
158 		clearend, flags, 0);
159 }
160 
161 static void mmap_file_cont(struct vmproc *vmp, message *replymsg, void *cbarg,
162 	void *origmsg_v)
163 {
164 	message *origmsg = (message *) origmsg_v;
165 	message mmap_reply;
166 	int result;
167 	int writable = 0;
168 	vir_bytes v = (vir_bytes) MAP_FAILED;
169 
170 	if(origmsg->m_mmap.prot & PROT_WRITE)
171 		writable = 1;
172 
173 	if(replymsg->VMV_RESULT != OK) {
174 #if 0   /* Noisy diagnostic for mmap() by ld.so */
175 		printf("VM: VFS reply failed (%d)\n", replymsg->VMV_RESULT);
176 		sys_diagctl_stacktrace(vmp->vm_endpoint);
177 #endif
178 		result = origmsg->VMV_RESULT;
179 	} else {
180 		/* Finish mmap */
181 		result = mmap_file(vmp, replymsg->VMV_FD, origmsg->m_mmap.offset,
182 			origmsg->m_mmap.flags,
183 			replymsg->VMV_INO, replymsg->VMV_DEV,
184 			(u64_t) replymsg->VMV_SIZE_PAGES*PAGE_SIZE,
185 			(vir_bytes) origmsg->m_mmap.addr,
186 			origmsg->m_mmap.len, &v, 0, writable, 1);
187 	}
188 
189 	/* Unblock requesting process. */
190 	memset(&mmap_reply, 0, sizeof(mmap_reply));
191 	mmap_reply.m_type = result;
192 	mmap_reply.m_mmap.retaddr = (void *) v;
193 
194 	if(ipc_send(vmp->vm_endpoint, &mmap_reply) != OK)
195 		panic("VM: mmap_file_cont: ipc_send() failed");
196 }
197 
198 /*===========================================================================*
199  *				do_mmap			     		     *
200  *===========================================================================*/
201 int do_mmap(message *m)
202 {
203 	int r, n;
204 	struct vmproc *vmp;
205 	vir_bytes addr = (vir_bytes) m->m_mmap.addr;
206 	struct vir_region *vr = NULL;
207 	int execpriv = 0;
208 	size_t len = (vir_bytes) m->m_mmap.len;
209 
210 	/* RS and VFS can do slightly more special mmap() things */
211 	if(m->m_source == VFS_PROC_NR || m->m_source == RS_PROC_NR)
212 		execpriv = 1;
213 
214 	if(m->m_mmap.flags & MAP_THIRDPARTY) {
215 		if(!execpriv) return EPERM;
216 		if((r=vm_isokendpt(m->m_mmap.forwhom, &n)) != OK)
217 			return ESRCH;
218 	} else {
219 		/* regular mmap, i.e. for caller */
220 		if((r=vm_isokendpt(m->m_source, &n)) != OK) {
221 			panic("do_mmap: message from strange source: %d",
222 				m->m_source);
223 		}
224 	}
225 
226 	vmp = &vmproc[n];
227 
228 	/* "SUSv3 specifies that mmap() should fail if length is 0" */
229 	if(len <= 0) {
230 		return EINVAL;
231 	}
232 
233 	if(m->m_mmap.fd == -1 || (m->m_mmap.flags & MAP_ANON)) {
234 		/* actual memory in some form */
235 		mem_type_t *mt = NULL;
236 
237 		if(m->m_mmap.fd != -1) {
238 			printf("VM: mmap: fd %d, len 0x%x\n", m->m_mmap.fd, len);
239 			return EINVAL;
240 		}
241 
242 		/* Contiguous phys memory has to be preallocated. */
243 		if((m->m_mmap.flags & (MAP_CONTIG|MAP_PREALLOC)) == MAP_CONTIG) {
244 			return EINVAL;
245 		}
246 
247 		if(m->m_mmap.flags & MAP_CONTIG) {
248 			mt = &mem_type_anon_contig;
249 		} else	mt = &mem_type_anon;
250 
251 		if(!(vr = mmap_region(vmp, addr, m->m_mmap.flags, len,
252 			VR_WRITABLE | VR_ANON, mt, execpriv))) {
253 			return ENOMEM;
254 		}
255 	} else {
256 		/* File mapping might be disabled */
257 		if(!enable_filemap) return ENXIO;
258 
259 		/* For files, we only can't accept writable MAP_SHARED
260 		 * mappings.
261 		 */
262 		if((m->m_mmap.flags & MAP_SHARED) && (m->m_mmap.prot & PROT_WRITE)) {
263 			return ENXIO;
264 		}
265 
266 		if(vfs_request(VMVFSREQ_FDLOOKUP, m->m_mmap.fd, vmp, 0, 0,
267 			mmap_file_cont, NULL, m, sizeof(*m)) != OK) {
268 			printf("VM: vfs_request for mmap failed\n");
269 			return ENXIO;
270 		}
271 
272 		/* request queued; don't reply. */
273 		return SUSPEND;
274 	}
275 
276 	/* Return mapping, as seen from process. */
277 	m->m_mmap.retaddr = (void *) vr->vaddr;
278 
279 	return OK;
280 }
281 
282 /*===========================================================================*
283  *				map_perm_check		     		     *
284  *===========================================================================*/
285 static int map_perm_check(endpoint_t caller, endpoint_t target,
286 	phys_bytes physaddr, phys_bytes len)
287 {
288 	int r;
289 
290 	/* TTY and memory are allowed to do anything.
291 	 * They have to be special cases as they have to be able to do
292 	 * anything; TTY even on behalf of anyone for the TIOCMAPMEM
293 	 * ioctl. MEM just for itself.
294 	 */
295 	if(caller == TTY_PROC_NR)
296 		return OK;
297 	if(caller != target)
298 		return EPERM;
299 	if(caller == MEM_PROC_NR)
300 		return OK;
301 
302 	/* Anyone else needs explicit permission from the kernel (ultimately
303 	 * set by PCI).
304 	 */
305 	r = sys_privquery_mem(caller, physaddr, len);
306 
307 	return r;
308 }
309 
310 /*===========================================================================*
311  *				do_map_phys		     		     *
312  *===========================================================================*/
313 int do_map_phys(message *m)
314 {
315 	int r, n;
316 	struct vmproc *vmp;
317 	endpoint_t target;
318 	struct vir_region *vr;
319 	vir_bytes len;
320 	phys_bytes startaddr;
321 	size_t offset;
322 
323 	target = m->m_lsys_vm_map_phys.ep;
324 	len = m->m_lsys_vm_map_phys.len;
325 
326 	if (len <= 0) return EINVAL;
327 
328 	if(target == SELF)
329 		target = m->m_source;
330 
331 	if((r=vm_isokendpt(target, &n)) != OK)
332 		return EINVAL;
333 
334 	startaddr = (vir_bytes)m->m_lsys_vm_map_phys.phaddr;
335 
336 	/* First check permission, then round range down/up. Caller can't
337 	 * help it if we can't map in lower than page granularity.
338 	 */
339 	if(map_perm_check(m->m_source, target, startaddr, len) != OK) {
340 		printf("VM: unauthorized mapping of 0x%lx by %d\n",
341 			startaddr, m->m_source);
342 		return EPERM;
343 	}
344 
345 	vmp = &vmproc[n];
346 
347 	offset = startaddr % VM_PAGE_SIZE;
348 	len += offset;
349 	startaddr -= offset;
350 
351 	if(len % VM_PAGE_SIZE)
352 		len += VM_PAGE_SIZE - (len % VM_PAGE_SIZE);
353 
354 	if(!(vr = map_page_region(vmp, 0, VM_DATATOP, len,
355 		VR_DIRECT | VR_WRITABLE, 0, &mem_type_directphys))) {
356 		return ENOMEM;
357 	}
358 
359 	phys_setphys(vr, startaddr);
360 
361 	m->m_lsys_vm_map_phys.reply = (void *) (vr->vaddr + offset);
362 
363 	return OK;
364 }
365 
366 /*===========================================================================*
367  *				do_remap		     		     *
368  *===========================================================================*/
369 int do_remap(message *m)
370 {
371 	int dn, sn;
372 	vir_bytes da, sa;
373 	size_t size;
374 	u32_t flags;
375 	struct vir_region *src_region, *vr;
376 	struct vmproc *dvmp, *svmp;
377 	int r;
378 	int readonly;
379 
380 	if(m->m_type == VM_REMAP)
381 		readonly = 0;
382 	else if(m->m_type == VM_REMAP_RO)
383 		readonly = 1;
384 	else panic("do_remap: can't be");
385 
386 	da = (vir_bytes) m->m_lsys_vm_vmremap.dest_addr;
387 	sa = (vir_bytes) m->m_lsys_vm_vmremap.src_addr;
388 	size = m->m_lsys_vm_vmremap.size;
389 
390 	if (size <= 0) return EINVAL;
391 
392 	if ((r = vm_isokendpt((endpoint_t) m->m_lsys_vm_vmremap.destination, &dn)) != OK)
393 		return EINVAL;
394 	if ((r = vm_isokendpt((endpoint_t) m->m_lsys_vm_vmremap.source, &sn)) != OK)
395 		return EINVAL;
396 
397 	dvmp = &vmproc[dn];
398 	svmp = &vmproc[sn];
399 
400 	if (!(src_region = map_lookup(svmp, sa, NULL)))
401 		return EINVAL;
402 
403 	if(src_region->vaddr != sa) {
404 		printf("VM: do_remap: not start of region.\n");
405 		return EFAULT;
406 	}
407 
408 	if (size % VM_PAGE_SIZE)
409 		size += VM_PAGE_SIZE - size % VM_PAGE_SIZE;
410 
411 	if(size != src_region->length) {
412 		printf("VM: do_remap: not size of region.\n");
413 		return EFAULT;
414 	}
415 
416 	flags = VR_SHARED;
417 	if(!readonly)
418 		flags |= VR_WRITABLE;
419 
420 	if(da)
421 		vr = map_page_region(dvmp, da, 0, size, flags, 0,
422 			&mem_type_shared);
423 	else
424 		vr = map_page_region(dvmp, 0, VM_DATATOP, size, flags, 0,
425 			&mem_type_shared);
426 
427 	if(!vr) {
428 		printf("VM: re-map of shared area failed\n");
429 		return ENOMEM;
430 	}
431 
432 	shared_setsource(vr, svmp->vm_endpoint, src_region);
433 
434 	m->m_lsys_vm_vmremap.ret_addr = (void *) vr->vaddr;
435 	return OK;
436 }
437 
438 /*===========================================================================*
439  *				do_get_phys		     		     *
440  *===========================================================================*/
441 int do_get_phys(message *m)
442 {
443 	int r, n;
444 	struct vmproc *vmp;
445 	endpoint_t target;
446 	phys_bytes ret;
447 	vir_bytes addr;
448 
449 	target = m->m_lc_vm_getphys.endpt;
450 	addr = (vir_bytes) m->m_lc_vm_getphys.addr;
451 
452 	if ((r = vm_isokendpt(target, &n)) != OK)
453 		return EINVAL;
454 
455 	vmp = &vmproc[n];
456 
457 	r = map_get_phys(vmp, addr, &ret);
458 
459 	m->m_lc_vm_getphys.ret_addr = (void *) ret;
460 	return r;
461 }
462 
463 /*===========================================================================*
464  *				do_get_refcount		     		     *
465  *===========================================================================*/
466 int do_get_refcount(message *m)
467 {
468 	int r, n;
469 	struct vmproc *vmp;
470 	endpoint_t target;
471 	u8_t cnt;
472 	vir_bytes addr;
473 
474 	target = m->m_lsys_vm_getref.endpt;
475 	addr = (vir_bytes) m->m_lsys_vm_getref.addr;
476 
477 	if ((r = vm_isokendpt(target, &n)) != OK)
478 		return EINVAL;
479 
480 	vmp = &vmproc[n];
481 
482 	r = map_get_ref(vmp, addr, &cnt);
483 
484 	m->m_lsys_vm_getref.retc = cnt;
485 	return r;
486 }
487 
488 /*===========================================================================*
489  *                              do_munmap                                    *
490  *===========================================================================*/
491 int do_munmap(message *m)
492 {
493         int r, n;
494         struct vmproc *vmp;
495         vir_bytes addr, len;
496 	endpoint_t target = SELF;
497 
498 	if(m->m_type == VM_UNMAP_PHYS) {
499 		target = m->m_lsys_vm_unmap_phys.ep;
500 	} else if(m->m_type == VM_SHM_UNMAP) {
501 		target = m->m_lc_vm_shm_unmap.forwhom;
502 	}
503 
504 	if(target == SELF)
505 		target = m->m_source;
506 
507         if((r=vm_isokendpt(target, &n)) != OK) {
508                 panic("do_mmap: message from strange source: %d", m->m_source);
509         }
510 
511         vmp = &vmproc[n];
512 
513 	if(m->m_type == VM_UNMAP_PHYS) {
514 		addr = (vir_bytes) m->m_lsys_vm_unmap_phys.vaddr;
515 	} else if(m->m_type == VM_SHM_UNMAP) {
516 		addr = (vir_bytes) m->m_lc_vm_shm_unmap.addr;
517 	} else	addr = (vir_bytes) m->VMUM_ADDR;
518 
519 	if(addr % VM_PAGE_SIZE)
520 		return EFAULT;
521 
522 	if(m->m_type == VM_UNMAP_PHYS || m->m_type == VM_SHM_UNMAP) {
523 		struct vir_region *vr;
524 	        if(!(vr = map_lookup(vmp, addr, NULL))) {
525 			printf("VM: unmap: address 0x%lx not found in %d\n",
526 	                       addr, target);
527 			sys_diagctl_stacktrace(target);
528 	                return EFAULT;
529 		}
530 		len = vr->length;
531 	} else len = roundup(m->VMUM_LEN, VM_PAGE_SIZE);
532 
533 	return map_unmap_range(vmp, addr, len);
534 }
535 
536