1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
/* The kernel call implemented in this file:
* m_type: SYS_VUMAP
*
* The parameters for this kernel call are:
* m_lsys_krn_sys_vumap.endpt (grant owner, or SELF for local addresses)
* m_lsys_krn_sys_vumap.vaddr (address of virtual (input) vector)
* m_lsys_krn_sys_vumap.vcount (number of elements in virtual vector)
* m_lsys_krn_sys_vumap.offset (offset into first entry of input vector)
* m_lsys_krn_sys_vumap.access (safecopy access requested for input)
* m_lsys_krn_sys_vumap.paddr (address of physical (output) vector)
* m_lsys_krn_sys_vumap.pmax (maximum number of physical vector elements)
* m_krn_lsys_sys_vumap.pcount (upon return: number of elements filled)
*/
#include "kernel/system.h"
#include <assert.h>
/*===========================================================================*
* do_vumap *
*===========================================================================*/
int do_vumap(struct proc *caller, message *m_ptr)
{
/* Map a vector of grants or local virtual addresses to physical addresses.
* Designed to be used by drivers to perform an efficient lookup of physical
* addresses for the purpose of direct DMA from/to a remote process.
*/
endpoint_t endpt, source, granter;
struct proc *procp;
struct vumap_vir vvec[MAPVEC_NR];
struct vumap_phys pvec[MAPVEC_NR];
vir_bytes vaddr, paddr, vir_addr;
phys_bytes phys_addr;
int i, r, proc_nr, vcount, pcount, pmax, access;
size_t size, chunk, offset;
endpt = caller->p_endpoint;
/* Retrieve and check input parameters. */
source = m_ptr->m_lsys_krn_sys_vumap.endpt;
vaddr = m_ptr->m_lsys_krn_sys_vumap.vaddr;
vcount = m_ptr->m_lsys_krn_sys_vumap.vcount;
offset = m_ptr->m_lsys_krn_sys_vumap.offset;
access = m_ptr->m_lsys_krn_sys_vumap.access;
paddr = m_ptr->m_lsys_krn_sys_vumap.paddr;
pmax = m_ptr->m_lsys_krn_sys_vumap.pmax;
if (vcount <= 0 || pmax <= 0)
return EINVAL;
if (vcount > MAPVEC_NR) vcount = MAPVEC_NR;
if (pmax > MAPVEC_NR) pmax = MAPVEC_NR;
/* Convert access to safecopy access flags. */
switch (access) {
case VUA_READ: access = CPF_READ; break;
case VUA_WRITE: access = CPF_WRITE; break;
case VUA_READ|VUA_WRITE: access = CPF_READ|CPF_WRITE; break;
default: return EINVAL;
}
/* Copy in the vector of virtual addresses. */
size = vcount * sizeof(vvec[0]);
if (data_copy(endpt, vaddr, KERNEL, (vir_bytes) vvec, size) != OK)
return EFAULT;
pcount = 0;
/* Go through the input entries, one at a time. Stop early in case the output
* vector has filled up.
*/
for (i = 0; i < vcount && pcount < pmax; i++) {
size = vvec[i].vv_size;
if (size <= offset)
return EINVAL;
size -= offset;
if (source != SELF) {
r = verify_grant(source, endpt, vvec[i].vv_grant, size, access,
offset, &vir_addr, &granter, NULL);
if (r != OK)
return r;
} else {
vir_addr = vvec[i].vv_addr + offset;
granter = endpt;
}
okendpt(granter, &proc_nr);
procp = proc_addr(proc_nr);
/* Each virtual range is made up of one or more physical ranges. */
while (size > 0 && pcount < pmax) {
chunk = vm_lookup_range(procp, vir_addr, &phys_addr, size);
if (!chunk) {
/* Try to get the memory allocated, unless the memory
* is supposed to be there to be read from.
*/
if (access & CPF_READ)
return EFAULT;
/* This call may suspend the current call, or return an
* error for a previous invocation.
*/
return vm_check_range(caller, procp, vir_addr, size, 1);
}
pvec[pcount].vp_addr = phys_addr;
pvec[pcount].vp_size = chunk;
pcount++;
vir_addr += chunk;
size -= chunk;
}
offset = 0;
}
/* Copy out the resulting vector of physical addresses. */
assert(pcount > 0);
size = pcount * sizeof(pvec[0]);
r = data_copy_vmcheck(caller, KERNEL, (vir_bytes) pvec, endpt, paddr, size);
if (r == OK)
m_ptr->m_krn_lsys_sys_vumap.pcount = pcount;
return r;
}
|
