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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
|
/*
* FreeBSD sysctl() and sysarch() system call emulation
*
* Copyright (c) 2013-15 Stacey D. Son
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <http://www.gnu.org/licenses/>.
*/
#include "qemu/osdep.h"
#include "qemu.h"
#include "target_arch_sysarch.h"
#include <sys/sysctl.h>
/*
* Length for the fixed length types.
* 0 means variable length for strings and structures
* Compare with sys/kern_sysctl.c ctl_size
* Note: Not all types appear to be used in-tree.
*/
static const int guest_ctl_size[CTLTYPE + 1] = {
[CTLTYPE_INT] = sizeof(abi_int),
[CTLTYPE_UINT] = sizeof(abi_uint),
[CTLTYPE_LONG] = sizeof(abi_long),
[CTLTYPE_ULONG] = sizeof(abi_ulong),
[CTLTYPE_S8] = sizeof(int8_t),
[CTLTYPE_S16] = sizeof(int16_t),
[CTLTYPE_S32] = sizeof(int32_t),
[CTLTYPE_S64] = sizeof(int64_t),
[CTLTYPE_U8] = sizeof(uint8_t),
[CTLTYPE_U16] = sizeof(uint16_t),
[CTLTYPE_U32] = sizeof(uint32_t),
[CTLTYPE_U64] = sizeof(uint64_t),
};
static const int host_ctl_size[CTLTYPE + 1] = {
[CTLTYPE_INT] = sizeof(int),
[CTLTYPE_UINT] = sizeof(u_int),
[CTLTYPE_LONG] = sizeof(long),
[CTLTYPE_ULONG] = sizeof(u_long),
[CTLTYPE_S8] = sizeof(int8_t),
[CTLTYPE_S16] = sizeof(int16_t),
[CTLTYPE_S32] = sizeof(int32_t),
[CTLTYPE_S64] = sizeof(int64_t),
[CTLTYPE_U8] = sizeof(uint8_t),
[CTLTYPE_U16] = sizeof(uint16_t),
[CTLTYPE_U32] = sizeof(uint32_t),
[CTLTYPE_U64] = sizeof(uint64_t),
};
#ifdef TARGET_ABI32
/*
* Limit the amount of available memory to be most of the 32-bit address
* space. 0x100c000 was arrived at through trial and error as a good
* definition of 'most'.
*/
static const abi_ulong guest_max_mem = UINT32_MAX - 0x100c000 + 1;
static abi_ulong G_GNUC_UNUSED cap_memory(uint64_t mem)
{
return MIN(guest_max_mem, mem);
}
#endif
static abi_ulong G_GNUC_UNUSED scale_to_guest_pages(uint64_t pages)
{
/* Scale pages from host to guest */
pages = muldiv64(pages, qemu_real_host_page_size(), TARGET_PAGE_SIZE);
#ifdef TARGET_ABI32
/* cap pages if need be */
pages = MIN(pages, guest_max_mem / (abi_ulong)TARGET_PAGE_SIZE);
#endif
return pages;
}
#ifdef TARGET_ABI32
/* Used only for TARGET_ABI32 */
static abi_long h2g_long_sat(long l)
{
if (l > INT32_MAX) {
l = INT32_MAX;
} else if (l < INT32_MIN) {
l = INT32_MIN;
}
return l;
}
static abi_ulong h2g_ulong_sat(u_long ul)
{
return MIN(ul, UINT32_MAX);
}
#endif
/*
* placeholder until bsd-user downstream upstreams this with its thread support
*/
#define bsd_get_ncpu() 1
/*
* This uses the undocumented oidfmt interface to find the kind of a requested
* sysctl, see /sys/kern/kern_sysctl.c:sysctl_sysctl_oidfmt() (compare to
* src/sbin/sysctl/sysctl.c)
*/
static int G_GNUC_UNUSED oidfmt(int *oid, int len, char *fmt, uint32_t *kind)
{
int qoid[CTL_MAXNAME + 2];
uint8_t buf[BUFSIZ];
int i;
size_t j;
qoid[0] = CTL_SYSCTL;
qoid[1] = CTL_SYSCTL_OIDFMT;
memcpy(qoid + 2, oid, len * sizeof(int));
j = sizeof(buf);
i = sysctl(qoid, len + 2, buf, &j, 0, 0);
if (i) {
return i;
}
if (kind) {
*kind = *(uint32_t *)buf;
}
if (fmt) {
strcpy(fmt, (char *)(buf + sizeof(uint32_t)));
}
return 0;
}
/*
* Convert the old value from host to guest.
*
* For LONG and ULONG on ABI32, we need to 'down convert' the 8 byte quantities
* to 4 bytes. The caller setup a buffer in host memory to get this data from
* the kernel and pass it to us. We do the down conversion and adjust the length
* so the caller knows what to write as the returned length into the target when
* it copies the down converted values into the target.
*
* For normal integral types, we just need to byte swap. No size changes.
*
* For strings and node data, there's no conversion needed.
*
* For opaque data, per sysctl OID converts take care of it.
*/
static void G_GNUC_UNUSED h2g_old_sysctl(void *holdp, size_t *holdlen, uint32_t kind)
{
size_t len;
int hlen, glen;
uint8_t *hp, *gp;
/*
* Although rare, we can have arrays of sysctl. Both sysctl_old_ddb in
* kern_sysctl.c and show_var in sbin/sysctl/sysctl.c have code that loops
* this way. *holdlen has been set by the kernel to the host's length.
* Only LONG and ULONG on ABI32 have different sizes: see below.
*/
gp = hp = (uint8_t *)holdp;
len = 0;
hlen = host_ctl_size[kind & CTLTYPE];
glen = guest_ctl_size[kind & CTLTYPE];
/*
* hlen == 0 for CTLTYPE_STRING and CTLTYPE_NODE, which need no conversion
* as well as CTLTYPE_OPAQUE, which needs special converters.
*/
if (hlen == 0) {
return;
}
while (len < *holdlen) {
if (hlen == glen) {
switch (hlen) {
case 1:
/* Nothing needed: no byteswapping and assigning in place */
break;
case 2:
*(uint16_t *)gp = tswap16(*(uint16_t *)hp);
break;
case 4:
*(uint32_t *)gp = tswap32(*(uint32_t *)hp);
break;
case 8:
*(uint64_t *)gp = tswap64(*(uint64_t *)hp);
break;
default:
g_assert_not_reached();
}
} else {
#ifdef TARGET_ABI32
/*
* Saturating assignment for the only two types that differ between
* 32-bit and 64-bit machines. All other integral types have the
* same, fixed size and will be converted w/o loss of precision
* in the above switch.
*/
switch (kind & CTLTYPE) {
case CTLTYPE_LONG:
*(abi_long *)gp = tswap32(h2g_long_sat(*(long *)hp));
break;
case CTLTYPE_ULONG:
*(abi_ulong *)gp = tswap32(h2g_ulong_sat(*(u_long *)hp));
break;
default:
g_assert_not_reached();
}
#else
g_assert_not_reached();
#endif
}
gp += glen;
hp += hlen;
len += hlen;
}
#ifdef TARGET_ABI32
if (hlen != glen) {
*holdlen = (*holdlen / hlen) * glen;
}
#endif
}
/* sysarch() is architecture dependent. */
abi_long do_freebsd_sysarch(void *cpu_env, abi_long arg1, abi_long arg2)
{
return do_freebsd_arch_sysarch(cpu_env, arg1, arg2);
}
|
