1 /*
2 * QEMU low level functions
3 *
4 * Copyright (c) 2003 Fabrice Bellard
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24 #include "qemu/osdep.h"
25 #include "qapi/error.h"
26 #include "qemu/cutils.h"
27 #include "qemu/sockets.h"
28 #include "qemu/error-report.h"
29 #include "qemu/madvise.h"
30 #include "qemu/mprotect.h"
31 #include "qemu/hw-version.h"
32 #include "monitor/monitor.h"
33
34 static const char *hw_version = QEMU_HW_VERSION;
35
socket_set_cork(int fd,int v)36 int socket_set_cork(int fd, int v)
37 {
38 #if defined(SOL_TCP) && defined(TCP_CORK)
39 return setsockopt(fd, SOL_TCP, TCP_CORK, &v, sizeof(v));
40 #else
41 return 0;
42 #endif
43 }
44
socket_set_nodelay(int fd)45 int socket_set_nodelay(int fd)
46 {
47 int v = 1;
48 return setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &v, sizeof(v));
49 }
50
qemu_madvise(void * addr,size_t len,int advice)51 int qemu_madvise(void *addr, size_t len, int advice)
52 {
53 if (advice == QEMU_MADV_INVALID) {
54 errno = EINVAL;
55 return -1;
56 }
57 #if defined(CONFIG_MADVISE)
58 return madvise(addr, len, advice);
59 #elif defined(CONFIG_POSIX_MADVISE)
60 int rc = posix_madvise(addr, len, advice);
61 if (rc) {
62 errno = rc;
63 return -1;
64 }
65 return 0;
66 #else
67 errno = ENOSYS;
68 return -1;
69 #endif
70 }
71
qemu_mprotect__osdep(void * addr,size_t size,int prot)72 static int qemu_mprotect__osdep(void *addr, size_t size, int prot)
73 {
74 g_assert(!((uintptr_t)addr & ~qemu_real_host_page_mask()));
75 g_assert(!(size & ~qemu_real_host_page_mask()));
76
77 #ifdef _WIN32
78 DWORD old_protect;
79
80 if (!VirtualProtect(addr, size, prot, &old_protect)) {
81 g_autofree gchar *emsg = g_win32_error_message(GetLastError());
82 error_report("%s: VirtualProtect failed: %s", __func__, emsg);
83 return -1;
84 }
85 return 0;
86 #else
87 if (mprotect(addr, size, prot)) {
88 error_report("%s: mprotect failed: %s", __func__, strerror(errno));
89 return -1;
90 }
91 return 0;
92 #endif
93 }
94
qemu_mprotect_rw(void * addr,size_t size)95 int qemu_mprotect_rw(void *addr, size_t size)
96 {
97 #ifdef _WIN32
98 return qemu_mprotect__osdep(addr, size, PAGE_READWRITE);
99 #else
100 return qemu_mprotect__osdep(addr, size, PROT_READ | PROT_WRITE);
101 #endif
102 }
103
qemu_mprotect_rwx(void * addr,size_t size)104 int qemu_mprotect_rwx(void *addr, size_t size)
105 {
106 #ifdef _WIN32
107 return qemu_mprotect__osdep(addr, size, PAGE_EXECUTE_READWRITE);
108 #else
109 return qemu_mprotect__osdep(addr, size, PROT_READ | PROT_WRITE | PROT_EXEC);
110 #endif
111 }
112
qemu_mprotect_none(void * addr,size_t size)113 int qemu_mprotect_none(void *addr, size_t size)
114 {
115 #ifdef _WIN32
116 return qemu_mprotect__osdep(addr, size, PAGE_NOACCESS);
117 #else
118 return qemu_mprotect__osdep(addr, size, PROT_NONE);
119 #endif
120 }
121
122 #ifndef _WIN32
123
124 static int fcntl_op_setlk = -1;
125 static int fcntl_op_getlk = -1;
126
127 /*
128 * Dups an fd and sets the flags
129 */
qemu_dup_flags(int fd,int flags)130 int qemu_dup_flags(int fd, int flags)
131 {
132 int ret;
133 int serrno;
134 int dup_flags;
135
136 ret = qemu_dup(fd);
137 if (ret == -1) {
138 goto fail;
139 }
140
141 dup_flags = fcntl(ret, F_GETFL);
142 if (dup_flags == -1) {
143 goto fail;
144 }
145
146 if ((flags & O_SYNC) != (dup_flags & O_SYNC)) {
147 errno = EINVAL;
148 goto fail;
149 }
150
151 /* Set/unset flags that we can with fcntl */
152 if (fcntl(ret, F_SETFL, flags) == -1) {
153 goto fail;
154 }
155
156 /* Truncate the file in the cases that open() would truncate it */
157 if (flags & O_TRUNC ||
158 ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))) {
159 if (ftruncate(ret, 0) == -1) {
160 goto fail;
161 }
162 }
163
164 return ret;
165
166 fail:
167 serrno = errno;
168 if (ret != -1) {
169 close(ret);
170 }
171 errno = serrno;
172 return -1;
173 }
174
qemu_dup(int fd)175 int qemu_dup(int fd)
176 {
177 int ret;
178 #ifdef F_DUPFD_CLOEXEC
179 ret = fcntl(fd, F_DUPFD_CLOEXEC, 0);
180 #else
181 ret = dup(fd);
182 if (ret != -1) {
183 qemu_set_cloexec(ret);
184 }
185 #endif
186 return ret;
187 }
188
qemu_parse_fdset(const char * param)189 static int qemu_parse_fdset(const char *param)
190 {
191 return qemu_parse_fd(param);
192 }
193
qemu_probe_lock_ops(void)194 static void qemu_probe_lock_ops(void)
195 {
196 if (fcntl_op_setlk == -1) {
197 #ifdef F_OFD_SETLK
198 int fd;
199 int ret;
200 struct flock fl = {
201 .l_whence = SEEK_SET,
202 .l_start = 0,
203 .l_len = 0,
204 .l_type = F_WRLCK,
205 };
206
207 fd = open("/dev/null", O_RDWR);
208 if (fd < 0) {
209 fprintf(stderr,
210 "Failed to open /dev/null for OFD lock probing: %s\n",
211 strerror(errno));
212 fcntl_op_setlk = F_SETLK;
213 fcntl_op_getlk = F_GETLK;
214 return;
215 }
216 ret = fcntl(fd, F_OFD_GETLK, &fl);
217 close(fd);
218 if (!ret) {
219 fcntl_op_setlk = F_OFD_SETLK;
220 fcntl_op_getlk = F_OFD_GETLK;
221 } else {
222 fcntl_op_setlk = F_SETLK;
223 fcntl_op_getlk = F_GETLK;
224 }
225 #else
226 fcntl_op_setlk = F_SETLK;
227 fcntl_op_getlk = F_GETLK;
228 #endif
229 }
230 }
231
qemu_has_ofd_lock(void)232 bool qemu_has_ofd_lock(void)
233 {
234 qemu_probe_lock_ops();
235 #ifdef F_OFD_SETLK
236 return fcntl_op_setlk == F_OFD_SETLK;
237 #else
238 return false;
239 #endif
240 }
241
qemu_lock_fcntl(int fd,int64_t start,int64_t len,int fl_type)242 static int qemu_lock_fcntl(int fd, int64_t start, int64_t len, int fl_type)
243 {
244 int ret;
245 struct flock fl = {
246 .l_whence = SEEK_SET,
247 .l_start = start,
248 .l_len = len,
249 .l_type = fl_type,
250 };
251 qemu_probe_lock_ops();
252 ret = RETRY_ON_EINTR(fcntl(fd, fcntl_op_setlk, &fl));
253 return ret == -1 ? -errno : 0;
254 }
255
qemu_lock_fd(int fd,int64_t start,int64_t len,bool exclusive)256 int qemu_lock_fd(int fd, int64_t start, int64_t len, bool exclusive)
257 {
258 return qemu_lock_fcntl(fd, start, len, exclusive ? F_WRLCK : F_RDLCK);
259 }
260
qemu_unlock_fd(int fd,int64_t start,int64_t len)261 int qemu_unlock_fd(int fd, int64_t start, int64_t len)
262 {
263 return qemu_lock_fcntl(fd, start, len, F_UNLCK);
264 }
265
qemu_lock_fd_test(int fd,int64_t start,int64_t len,bool exclusive)266 int qemu_lock_fd_test(int fd, int64_t start, int64_t len, bool exclusive)
267 {
268 int ret;
269 struct flock fl = {
270 .l_whence = SEEK_SET,
271 .l_start = start,
272 .l_len = len,
273 .l_type = exclusive ? F_WRLCK : F_RDLCK,
274 };
275 qemu_probe_lock_ops();
276 ret = fcntl(fd, fcntl_op_getlk, &fl);
277 if (ret == -1) {
278 return -errno;
279 } else {
280 return fl.l_type == F_UNLCK ? 0 : -EAGAIN;
281 }
282 }
283 #endif
284
qemu_open_cloexec(const char * name,int flags,mode_t mode)285 static int qemu_open_cloexec(const char *name, int flags, mode_t mode)
286 {
287 int ret;
288 #ifdef O_CLOEXEC
289 ret = open(name, flags | O_CLOEXEC, mode);
290 #else
291 ret = open(name, flags, mode);
292 if (ret >= 0) {
293 qemu_set_cloexec(ret);
294 }
295 #endif
296 return ret;
297 }
298
299 /*
300 * Opens a file with FD_CLOEXEC set
301 */
302 static int
qemu_open_internal(const char * name,int flags,mode_t mode,Error ** errp)303 qemu_open_internal(const char *name, int flags, mode_t mode, Error **errp)
304 {
305 int ret;
306
307 #ifndef _WIN32
308 const char *fdset_id_str;
309
310 /* Attempt dup of fd from fd set */
311 if (strstart(name, "/dev/fdset/", &fdset_id_str)) {
312 int64_t fdset_id;
313 int dupfd;
314
315 fdset_id = qemu_parse_fdset(fdset_id_str);
316 if (fdset_id == -1) {
317 error_setg(errp, "Could not parse fdset %s", name);
318 errno = EINVAL;
319 return -1;
320 }
321
322 dupfd = monitor_fdset_dup_fd_add(fdset_id, flags);
323 if (dupfd == -1) {
324 error_setg_errno(errp, errno, "Could not dup FD for %s flags %x",
325 name, flags);
326 return -1;
327 }
328
329 return dupfd;
330 }
331 #endif
332
333 ret = qemu_open_cloexec(name, flags, mode);
334
335 if (ret == -1) {
336 const char *action = flags & O_CREAT ? "create" : "open";
337 #ifdef O_DIRECT
338 /* Give more helpful error message for O_DIRECT */
339 if (errno == EINVAL && (flags & O_DIRECT)) {
340 ret = open(name, flags & ~O_DIRECT, mode);
341 if (ret != -1) {
342 close(ret);
343 error_setg(errp, "Could not %s '%s': "
344 "filesystem does not support O_DIRECT",
345 action, name);
346 errno = EINVAL; /* restore first open()'s errno */
347 return -1;
348 }
349 }
350 #endif /* O_DIRECT */
351 error_setg_errno(errp, errno, "Could not %s '%s'",
352 action, name);
353 }
354
355 return ret;
356 }
357
358
qemu_open(const char * name,int flags,Error ** errp)359 int qemu_open(const char *name, int flags, Error **errp)
360 {
361 assert(!(flags & O_CREAT));
362
363 return qemu_open_internal(name, flags, 0, errp);
364 }
365
366
qemu_create(const char * name,int flags,mode_t mode,Error ** errp)367 int qemu_create(const char *name, int flags, mode_t mode, Error **errp)
368 {
369 assert(!(flags & O_CREAT));
370
371 return qemu_open_internal(name, flags | O_CREAT, mode, errp);
372 }
373
374
qemu_open_old(const char * name,int flags,...)375 int qemu_open_old(const char *name, int flags, ...)
376 {
377 va_list ap;
378 mode_t mode = 0;
379 int ret;
380
381 va_start(ap, flags);
382 if (flags & O_CREAT) {
383 mode = va_arg(ap, int);
384 }
385 va_end(ap);
386
387 ret = qemu_open_internal(name, flags, mode, NULL);
388
389 #ifdef O_DIRECT
390 if (ret == -1 && errno == EINVAL && (flags & O_DIRECT)) {
391 error_report("file system may not support O_DIRECT");
392 errno = EINVAL; /* in case it was clobbered */
393 }
394 #endif /* O_DIRECT */
395
396 return ret;
397 }
398
qemu_close(int fd)399 int qemu_close(int fd)
400 {
401 int64_t fdset_id;
402
403 /* Close fd that was dup'd from an fdset */
404 fdset_id = monitor_fdset_dup_fd_find(fd);
405 if (fdset_id != -1) {
406 int ret;
407
408 ret = close(fd);
409 if (ret == 0) {
410 monitor_fdset_dup_fd_remove(fd);
411 }
412
413 return ret;
414 }
415
416 return close(fd);
417 }
418
419 /*
420 * Delete a file from the filesystem, unless the filename is /dev/fdset/...
421 *
422 * Returns: On success, zero is returned. On error, -1 is returned,
423 * and errno is set appropriately.
424 */
qemu_unlink(const char * name)425 int qemu_unlink(const char *name)
426 {
427 if (g_str_has_prefix(name, "/dev/fdset/")) {
428 return 0;
429 }
430
431 return unlink(name);
432 }
433
434 /*
435 * A variant of write(2) which handles partial write.
436 *
437 * Return the number of bytes transferred.
438 * Set errno if fewer than `count' bytes are written.
439 *
440 * This function don't work with non-blocking fd's.
441 * Any of the possibilities with non-blocking fd's is bad:
442 * - return a short write (then name is wrong)
443 * - busy wait adding (errno == EAGAIN) to the loop
444 */
qemu_write_full(int fd,const void * buf,size_t count)445 ssize_t qemu_write_full(int fd, const void *buf, size_t count)
446 {
447 ssize_t ret = 0;
448 ssize_t total = 0;
449
450 while (count) {
451 ret = write(fd, buf, count);
452 if (ret < 0) {
453 if (errno == EINTR)
454 continue;
455 break;
456 }
457
458 count -= ret;
459 buf += ret;
460 total += ret;
461 }
462
463 return total;
464 }
465
466 /*
467 * Opens a socket with FD_CLOEXEC set
468 */
qemu_socket(int domain,int type,int protocol)469 int qemu_socket(int domain, int type, int protocol)
470 {
471 int ret;
472
473 #ifdef SOCK_CLOEXEC
474 ret = socket(domain, type | SOCK_CLOEXEC, protocol);
475 if (ret != -1 || errno != EINVAL) {
476 return ret;
477 }
478 #endif
479 ret = socket(domain, type, protocol);
480 if (ret >= 0) {
481 qemu_set_cloexec(ret);
482 }
483
484 return ret;
485 }
486
487 /*
488 * Accept a connection and set FD_CLOEXEC
489 */
qemu_accept(int s,struct sockaddr * addr,socklen_t * addrlen)490 int qemu_accept(int s, struct sockaddr *addr, socklen_t *addrlen)
491 {
492 int ret;
493
494 #ifdef CONFIG_ACCEPT4
495 ret = accept4(s, addr, addrlen, SOCK_CLOEXEC);
496 if (ret != -1 || errno != ENOSYS) {
497 return ret;
498 }
499 #endif
500 ret = accept(s, addr, addrlen);
501 if (ret >= 0) {
502 qemu_set_cloexec(ret);
503 }
504
505 return ret;
506 }
507
qemu_send_full(int s,const void * buf,size_t count)508 ssize_t qemu_send_full(int s, const void *buf, size_t count)
509 {
510 ssize_t ret = 0;
511 ssize_t total = 0;
512
513 while (count) {
514 ret = send(s, buf, count, 0);
515 if (ret < 0) {
516 if (errno == EINTR) {
517 continue;
518 }
519 break;
520 }
521
522 count -= ret;
523 buf += ret;
524 total += ret;
525 }
526
527 return total;
528 }
529
qemu_set_hw_version(const char * version)530 void qemu_set_hw_version(const char *version)
531 {
532 hw_version = version;
533 }
534
qemu_hw_version(void)535 const char *qemu_hw_version(void)
536 {
537 return hw_version;
538 }
539
540 #ifdef _WIN32
socket_cleanup(void)541 static void socket_cleanup(void)
542 {
543 WSACleanup();
544 }
545 #endif
546
socket_init(void)547 int socket_init(void)
548 {
549 #ifdef _WIN32
550 WSADATA Data;
551 int ret, err;
552
553 ret = WSAStartup(MAKEWORD(2, 2), &Data);
554 if (ret != 0) {
555 err = WSAGetLastError();
556 fprintf(stderr, "WSAStartup: %d\n", err);
557 return -1;
558 }
559 atexit(socket_cleanup);
560 #endif
561 return 0;
562 }
563
564
565 #ifndef CONFIG_IOVEC
566 static ssize_t
readv_writev(int fd,const struct iovec * iov,int iov_cnt,bool do_write)567 readv_writev(int fd, const struct iovec *iov, int iov_cnt, bool do_write)
568 {
569 unsigned i = 0;
570 ssize_t ret = 0;
571 ssize_t off = 0;
572 while (i < iov_cnt) {
573 ssize_t r = do_write
574 ? write(fd, iov[i].iov_base + off, iov[i].iov_len - off)
575 : read(fd, iov[i].iov_base + off, iov[i].iov_len - off);
576 if (r > 0) {
577 ret += r;
578 off += r;
579 if (off < iov[i].iov_len) {
580 continue;
581 }
582 } else if (!r) {
583 break;
584 } else if (errno == EINTR) {
585 continue;
586 } else {
587 /* else it is some "other" error,
588 * only return if there was no data processed. */
589 if (ret == 0) {
590 ret = -1;
591 }
592 break;
593 }
594 off = 0;
595 i++;
596 }
597 return ret;
598 }
599
600 ssize_t
readv(int fd,const struct iovec * iov,int iov_cnt)601 readv(int fd, const struct iovec *iov, int iov_cnt)
602 {
603 return readv_writev(fd, iov, iov_cnt, false);
604 }
605
606 ssize_t
writev(int fd,const struct iovec * iov,int iov_cnt)607 writev(int fd, const struct iovec *iov, int iov_cnt)
608 {
609 return readv_writev(fd, iov, iov_cnt, true);
610 }
611 #endif
612
613 /*
614 * Make sure data goes on disk, but if possible do not bother to
615 * write out the inode just for timestamp updates.
616 *
617 * Unfortunately even in 2009 many operating systems do not support
618 * fdatasync and have to fall back to fsync.
619 */
qemu_fdatasync(int fd)620 int qemu_fdatasync(int fd)
621 {
622 #ifdef CONFIG_FDATASYNC
623 return fdatasync(fd);
624 #else
625 return fsync(fd);
626 #endif
627 }
628