]>
Commit | Line | Data |
---|---|---|
3b3c1694 LA |
1 | /* |
2 | * Unified Hosting Interface syscalls. | |
3 | * | |
4 | * Copyright (c) 2015 Imagination Technologies | |
5 | * | |
6 | * This library is free software; you can redistribute it and/or | |
7 | * modify it under the terms of the GNU Lesser General Public | |
8 | * License as published by the Free Software Foundation; either | |
9 | * version 2 of the License, or (at your option) any later version. | |
10 | * | |
11 | * This library is distributed in the hope that it will be useful, | |
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
14 | * Lesser General Public License for more details. | |
15 | * | |
16 | * You should have received a copy of the GNU Lesser General Public | |
17 | * License along with this library; if not, see <http://www.gnu.org/licenses/>. | |
18 | */ | |
19 | ||
c684822a | 20 | #include "qemu/osdep.h" |
3b3c1694 LA |
21 | #include "cpu.h" |
22 | #include "exec/helper-proto.h" | |
23 | #include "exec/softmmu-semi.h" | |
24 | #include "exec/semihost.h" | |
25 | ||
26 | typedef enum UHIOp { | |
27 | UHI_exit = 1, | |
28 | UHI_open = 2, | |
29 | UHI_close = 3, | |
30 | UHI_read = 4, | |
31 | UHI_write = 5, | |
32 | UHI_lseek = 6, | |
33 | UHI_unlink = 7, | |
34 | UHI_fstat = 8, | |
35 | UHI_argc = 9, | |
36 | UHI_argnlen = 10, | |
37 | UHI_argn = 11, | |
38 | UHI_plog = 13, | |
39 | UHI_assert = 14, | |
40 | UHI_pread = 19, | |
41 | UHI_pwrite = 20, | |
42 | UHI_link = 22 | |
43 | } UHIOp; | |
44 | ||
45 | typedef struct UHIStat { | |
46 | int16_t uhi_st_dev; | |
47 | uint16_t uhi_st_ino; | |
48 | uint32_t uhi_st_mode; | |
49 | uint16_t uhi_st_nlink; | |
50 | uint16_t uhi_st_uid; | |
51 | uint16_t uhi_st_gid; | |
52 | int16_t uhi_st_rdev; | |
53 | uint64_t uhi_st_size; | |
54 | uint64_t uhi_st_atime; | |
55 | uint64_t uhi_st_spare1; | |
56 | uint64_t uhi_st_mtime; | |
57 | uint64_t uhi_st_spare2; | |
58 | uint64_t uhi_st_ctime; | |
59 | uint64_t uhi_st_spare3; | |
60 | uint64_t uhi_st_blksize; | |
61 | uint64_t uhi_st_blocks; | |
62 | uint64_t uhi_st_spare4[2]; | |
63 | } UHIStat; | |
64 | ||
65 | enum UHIOpenFlags { | |
66 | UHIOpen_RDONLY = 0x0, | |
67 | UHIOpen_WRONLY = 0x1, | |
68 | UHIOpen_RDWR = 0x2, | |
69 | UHIOpen_APPEND = 0x8, | |
70 | UHIOpen_CREAT = 0x200, | |
71 | UHIOpen_TRUNC = 0x400, | |
72 | UHIOpen_EXCL = 0x800 | |
73 | }; | |
74 | ||
2c44b19c LA |
75 | /* Errno values taken from asm-mips/errno.h */ |
76 | static uint16_t host_to_mips_errno[] = { | |
77 | [ENAMETOOLONG] = 78, | |
78 | #ifdef EOVERFLOW | |
79 | [EOVERFLOW] = 79, | |
80 | #endif | |
81 | #ifdef ELOOP | |
82 | [ELOOP] = 90, | |
83 | #endif | |
84 | }; | |
85 | ||
86 | static int errno_mips(int err) | |
87 | { | |
88 | if (err < 0 || err >= ARRAY_SIZE(host_to_mips_errno)) { | |
89 | return EINVAL; | |
90 | } else if (host_to_mips_errno[err]) { | |
91 | return host_to_mips_errno[err]; | |
92 | } else { | |
93 | return err; | |
94 | } | |
95 | } | |
96 | ||
3b3c1694 LA |
97 | static int copy_stat_to_target(CPUMIPSState *env, const struct stat *src, |
98 | target_ulong vaddr) | |
99 | { | |
100 | hwaddr len = sizeof(struct UHIStat); | |
101 | UHIStat *dst = lock_user(VERIFY_WRITE, vaddr, len, 0); | |
102 | if (!dst) { | |
103 | errno = EFAULT; | |
104 | return -1; | |
105 | } | |
106 | ||
107 | dst->uhi_st_dev = tswap16(src->st_dev); | |
108 | dst->uhi_st_ino = tswap16(src->st_ino); | |
109 | dst->uhi_st_mode = tswap32(src->st_mode); | |
110 | dst->uhi_st_nlink = tswap16(src->st_nlink); | |
111 | dst->uhi_st_uid = tswap16(src->st_uid); | |
112 | dst->uhi_st_gid = tswap16(src->st_gid); | |
113 | dst->uhi_st_rdev = tswap16(src->st_rdev); | |
114 | dst->uhi_st_size = tswap64(src->st_size); | |
115 | dst->uhi_st_atime = tswap64(src->st_atime); | |
116 | dst->uhi_st_mtime = tswap64(src->st_mtime); | |
117 | dst->uhi_st_ctime = tswap64(src->st_ctime); | |
118 | #ifdef _WIN32 | |
119 | dst->uhi_st_blksize = 0; | |
120 | dst->uhi_st_blocks = 0; | |
121 | #else | |
122 | dst->uhi_st_blksize = tswap64(src->st_blksize); | |
123 | dst->uhi_st_blocks = tswap64(src->st_blocks); | |
124 | #endif | |
125 | unlock_user(dst, vaddr, len); | |
126 | return 0; | |
127 | } | |
128 | ||
129 | static int get_open_flags(target_ulong target_flags) | |
130 | { | |
131 | int open_flags = 0; | |
132 | ||
133 | if (target_flags & UHIOpen_RDWR) { | |
134 | open_flags |= O_RDWR; | |
135 | } else if (target_flags & UHIOpen_WRONLY) { | |
136 | open_flags |= O_WRONLY; | |
137 | } else { | |
138 | open_flags |= O_RDONLY; | |
139 | } | |
140 | ||
141 | open_flags |= (target_flags & UHIOpen_APPEND) ? O_APPEND : 0; | |
142 | open_flags |= (target_flags & UHIOpen_CREAT) ? O_CREAT : 0; | |
143 | open_flags |= (target_flags & UHIOpen_TRUNC) ? O_TRUNC : 0; | |
144 | open_flags |= (target_flags & UHIOpen_EXCL) ? O_EXCL : 0; | |
145 | ||
146 | return open_flags; | |
147 | } | |
148 | ||
149 | static int write_to_file(CPUMIPSState *env, target_ulong fd, target_ulong vaddr, | |
150 | target_ulong len, target_ulong offset) | |
151 | { | |
152 | int num_of_bytes; | |
153 | void *dst = lock_user(VERIFY_READ, vaddr, len, 1); | |
154 | if (!dst) { | |
155 | errno = EFAULT; | |
156 | return -1; | |
157 | } | |
158 | ||
159 | if (offset) { | |
160 | #ifdef _WIN32 | |
161 | num_of_bytes = 0; | |
162 | #else | |
163 | num_of_bytes = pwrite(fd, dst, len, offset); | |
164 | #endif | |
165 | } else { | |
166 | num_of_bytes = write(fd, dst, len); | |
167 | } | |
168 | ||
169 | unlock_user(dst, vaddr, 0); | |
170 | return num_of_bytes; | |
171 | } | |
172 | ||
173 | static int read_from_file(CPUMIPSState *env, target_ulong fd, | |
174 | target_ulong vaddr, target_ulong len, | |
175 | target_ulong offset) | |
176 | { | |
177 | int num_of_bytes; | |
178 | void *dst = lock_user(VERIFY_WRITE, vaddr, len, 0); | |
179 | if (!dst) { | |
180 | errno = EFAULT; | |
181 | return -1; | |
182 | } | |
183 | ||
184 | if (offset) { | |
185 | #ifdef _WIN32 | |
186 | num_of_bytes = 0; | |
187 | #else | |
188 | num_of_bytes = pread(fd, dst, len, offset); | |
189 | #endif | |
190 | } else { | |
191 | num_of_bytes = read(fd, dst, len); | |
192 | } | |
193 | ||
194 | unlock_user(dst, vaddr, len); | |
195 | return num_of_bytes; | |
196 | } | |
197 | ||
198 | static int copy_argn_to_target(CPUMIPSState *env, int arg_num, | |
199 | target_ulong vaddr) | |
200 | { | |
201 | int strsize = strlen(semihosting_get_arg(arg_num)) + 1; | |
202 | char *dst = lock_user(VERIFY_WRITE, vaddr, strsize, 0); | |
203 | if (!dst) { | |
204 | return -1; | |
205 | } | |
206 | ||
207 | strcpy(dst, semihosting_get_arg(arg_num)); | |
208 | ||
209 | unlock_user(dst, vaddr, strsize); | |
210 | return 0; | |
211 | } | |
212 | ||
213 | #define GET_TARGET_STRING(p, addr) \ | |
214 | do { \ | |
215 | p = lock_user_string(addr); \ | |
216 | if (!p) { \ | |
217 | gpr[2] = -1; \ | |
218 | gpr[3] = EFAULT; \ | |
219 | goto uhi_done; \ | |
220 | } \ | |
221 | } while (0) | |
222 | ||
26e7e982 LA |
223 | #define GET_TARGET_STRINGS_2(p, addr, p2, addr2) \ |
224 | do { \ | |
225 | p = lock_user_string(addr); \ | |
226 | if (!p) { \ | |
227 | gpr[2] = -1; \ | |
228 | gpr[3] = EFAULT; \ | |
229 | goto uhi_done; \ | |
230 | } \ | |
231 | p2 = lock_user_string(addr2); \ | |
232 | if (!p2) { \ | |
233 | unlock_user(p, addr, 0); \ | |
234 | gpr[2] = -1; \ | |
235 | gpr[3] = EFAULT; \ | |
236 | goto uhi_done; \ | |
237 | } \ | |
238 | } while (0) | |
239 | ||
3b3c1694 LA |
240 | #define FREE_TARGET_STRING(p, gpr) \ |
241 | do { \ | |
242 | unlock_user(p, gpr, 0); \ | |
243 | } while (0) | |
244 | ||
245 | void helper_do_semihosting(CPUMIPSState *env) | |
246 | { | |
247 | target_ulong *gpr = env->active_tc.gpr; | |
248 | const UHIOp op = gpr[25]; | |
249 | char *p, *p2; | |
250 | ||
251 | switch (op) { | |
252 | case UHI_exit: | |
253 | qemu_log("UHI(%d): exit(%d)\n", op, (int)gpr[4]); | |
254 | exit(gpr[4]); | |
255 | case UHI_open: | |
256 | GET_TARGET_STRING(p, gpr[4]); | |
257 | if (!strcmp("/dev/stdin", p)) { | |
258 | gpr[2] = 0; | |
259 | } else if (!strcmp("/dev/stdout", p)) { | |
260 | gpr[2] = 1; | |
261 | } else if (!strcmp("/dev/stderr", p)) { | |
262 | gpr[2] = 2; | |
263 | } else { | |
264 | gpr[2] = open(p, get_open_flags(gpr[5]), gpr[6]); | |
2c44b19c | 265 | gpr[3] = errno_mips(errno); |
3b3c1694 LA |
266 | } |
267 | FREE_TARGET_STRING(p, gpr[4]); | |
268 | break; | |
269 | case UHI_close: | |
270 | if (gpr[4] < 3) { | |
271 | /* ignore closing stdin/stdout/stderr */ | |
272 | gpr[2] = 0; | |
273 | goto uhi_done; | |
274 | } | |
275 | gpr[2] = close(gpr[4]); | |
2c44b19c | 276 | gpr[3] = errno_mips(errno); |
3b3c1694 LA |
277 | break; |
278 | case UHI_read: | |
279 | gpr[2] = read_from_file(env, gpr[4], gpr[5], gpr[6], 0); | |
2c44b19c | 280 | gpr[3] = errno_mips(errno); |
3b3c1694 LA |
281 | break; |
282 | case UHI_write: | |
283 | gpr[2] = write_to_file(env, gpr[4], gpr[5], gpr[6], 0); | |
2c44b19c | 284 | gpr[3] = errno_mips(errno); |
3b3c1694 LA |
285 | break; |
286 | case UHI_lseek: | |
287 | gpr[2] = lseek(gpr[4], gpr[5], gpr[6]); | |
2c44b19c | 288 | gpr[3] = errno_mips(errno); |
3b3c1694 LA |
289 | break; |
290 | case UHI_unlink: | |
291 | GET_TARGET_STRING(p, gpr[4]); | |
292 | gpr[2] = remove(p); | |
2c44b19c | 293 | gpr[3] = errno_mips(errno); |
3b3c1694 LA |
294 | FREE_TARGET_STRING(p, gpr[4]); |
295 | break; | |
296 | case UHI_fstat: | |
297 | { | |
298 | struct stat sbuf; | |
299 | memset(&sbuf, 0, sizeof(sbuf)); | |
300 | gpr[2] = fstat(gpr[4], &sbuf); | |
2c44b19c | 301 | gpr[3] = errno_mips(errno); |
3b3c1694 LA |
302 | if (gpr[2]) { |
303 | goto uhi_done; | |
304 | } | |
305 | gpr[2] = copy_stat_to_target(env, &sbuf, gpr[5]); | |
2c44b19c | 306 | gpr[3] = errno_mips(errno); |
3b3c1694 LA |
307 | } |
308 | break; | |
309 | case UHI_argc: | |
310 | gpr[2] = semihosting_get_argc(); | |
311 | break; | |
312 | case UHI_argnlen: | |
313 | if (gpr[4] >= semihosting_get_argc()) { | |
314 | gpr[2] = -1; | |
315 | goto uhi_done; | |
316 | } | |
317 | gpr[2] = strlen(semihosting_get_arg(gpr[4])); | |
318 | break; | |
319 | case UHI_argn: | |
320 | if (gpr[4] >= semihosting_get_argc()) { | |
321 | gpr[2] = -1; | |
322 | goto uhi_done; | |
323 | } | |
324 | gpr[2] = copy_argn_to_target(env, gpr[4], gpr[5]); | |
325 | break; | |
326 | case UHI_plog: | |
327 | GET_TARGET_STRING(p, gpr[4]); | |
328 | p2 = strstr(p, "%d"); | |
329 | if (p2) { | |
330 | int char_num = p2 - p; | |
331 | char *buf = g_malloc(char_num + 1); | |
332 | strncpy(buf, p, char_num); | |
333 | buf[char_num] = '\0'; | |
334 | gpr[2] = printf("%s%d%s", buf, (int)gpr[5], p2 + 2); | |
335 | g_free(buf); | |
336 | } else { | |
337 | gpr[2] = printf("%s", p); | |
338 | } | |
339 | FREE_TARGET_STRING(p, gpr[4]); | |
340 | break; | |
341 | case UHI_assert: | |
26e7e982 | 342 | GET_TARGET_STRINGS_2(p, gpr[4], p2, gpr[5]); |
3b3c1694 LA |
343 | printf("assertion '"); |
344 | printf("\"%s\"", p); | |
345 | printf("': file \"%s\", line %d\n", p2, (int)gpr[6]); | |
346 | FREE_TARGET_STRING(p2, gpr[5]); | |
347 | FREE_TARGET_STRING(p, gpr[4]); | |
348 | abort(); | |
349 | break; | |
350 | case UHI_pread: | |
351 | gpr[2] = read_from_file(env, gpr[4], gpr[5], gpr[6], gpr[7]); | |
2c44b19c | 352 | gpr[3] = errno_mips(errno); |
3b3c1694 LA |
353 | break; |
354 | case UHI_pwrite: | |
355 | gpr[2] = write_to_file(env, gpr[4], gpr[5], gpr[6], gpr[7]); | |
2c44b19c | 356 | gpr[3] = errno_mips(errno); |
3b3c1694 LA |
357 | break; |
358 | #ifndef _WIN32 | |
359 | case UHI_link: | |
26e7e982 | 360 | GET_TARGET_STRINGS_2(p, gpr[4], p2, gpr[5]); |
3b3c1694 | 361 | gpr[2] = link(p, p2); |
2c44b19c | 362 | gpr[3] = errno_mips(errno); |
3b3c1694 LA |
363 | FREE_TARGET_STRING(p2, gpr[5]); |
364 | FREE_TARGET_STRING(p, gpr[4]); | |
365 | break; | |
366 | #endif | |
367 | default: | |
368 | fprintf(stderr, "Unknown UHI operation %d\n", op); | |
369 | abort(); | |
370 | } | |
371 | uhi_done: | |
372 | return; | |
373 | } |