xref: /openbmc/qemu/util/osdep.c (revision 9d779187)
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 
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 
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 
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 
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 
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 
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 
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  */
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 
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 
189 static int qemu_parse_fdset(const char *param)
190 {
191     return qemu_parse_fd(param);
192 }
193 
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 
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 
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 
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 
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 
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 
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
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 
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 
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 
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 
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  */
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  */
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  */
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  */
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 
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 
530 void qemu_set_hw_version(const char *version)
531 {
532     hw_version = version;
533 }
534 
535 const char *qemu_hw_version(void)
536 {
537     return hw_version;
538 }
539 
540 #ifdef _WIN32
541 static void socket_cleanup(void)
542 {
543     WSACleanup();
544 }
545 #endif
546 
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
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
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
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  */
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