File:  [Qemu by Fabrice Bellard] / qemu / osdep.c
Revision 1.1.1.5 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 16:50:49 2018 UTC (3 years, 1 month ago) by root
Branches: qemu, MAIN
CVS tags: qemu0105, qemu0104, qemu0103, qemu0102, qemu0101, qemu0100, HEAD
qemu 0.10.0

    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 <stdlib.h>
   25: #include <stdio.h>
   26: #include <stdarg.h>
   27: #include <string.h>
   28: #include <errno.h>
   29: #include <unistd.h>
   30: #include <fcntl.h>
   31: #ifdef HOST_SOLARIS
   32: #include <sys/types.h>
   33: #include <sys/statvfs.h>
   34: #endif
   35: 
   36: #include "qemu-common.h"
   37: #include "sysemu.h"
   38: 
   39: #ifdef _WIN32
   40: #define WIN32_LEAN_AND_MEAN
   41: #include <windows.h>
   42: #elif defined(_BSD)
   43: #include <stdlib.h>
   44: #else
   45: #include <malloc.h>
   46: #endif
   47: 
   48: #include "qemu_socket.h"
   49: 
   50: #if defined(_WIN32)
   51: void *qemu_memalign(size_t alignment, size_t size)
   52: {
   53:     return VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE);
   54: }
   55: 
   56: void *qemu_vmalloc(size_t size)
   57: {
   58:     /* FIXME: this is not exactly optimal solution since VirtualAlloc
   59:        has 64Kb granularity, but at least it guarantees us that the
   60:        memory is page aligned. */
   61:     return VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE);
   62: }
   63: 
   64: void qemu_vfree(void *ptr)
   65: {
   66:     VirtualFree(ptr, 0, MEM_RELEASE);
   67: }
   68: 
   69: #else
   70: 
   71: #if defined(USE_KQEMU)
   72: 
   73: #ifdef __OpenBSD__
   74: #include <sys/param.h>
   75: #include <sys/types.h>
   76: #include <sys/mount.h>
   77: #else
   78: #ifndef __FreeBSD__
   79: #include <sys/vfs.h>
   80: #endif
   81: #endif
   82: 
   83: #include <sys/mman.h>
   84: #include <fcntl.h>
   85: 
   86: static void *kqemu_vmalloc(size_t size)
   87: {
   88:     static int phys_ram_fd = -1;
   89:     static int phys_ram_size = 0;
   90:     void *ptr;
   91: 
   92: /* no need (?) for a dummy file on OpenBSD/FreeBSD */
   93: #if defined(__OpenBSD__) || defined(__FreeBSD__)
   94:     int map_anon = MAP_ANON;
   95: #else
   96:     int map_anon = 0;
   97:     const char *tmpdir;
   98:     char phys_ram_file[1024];
   99: #ifdef HOST_SOLARIS
  100:     struct statvfs stfs;
  101: #else
  102:     struct statfs stfs;
  103: #endif
  104: 
  105:     if (phys_ram_fd < 0) {
  106:         tmpdir = getenv("QEMU_TMPDIR");
  107:         if (!tmpdir)
  108: #ifdef HOST_SOLARIS
  109:             tmpdir = "/tmp";
  110:         if (statvfs(tmpdir, &stfs) == 0) {
  111: #else
  112:             tmpdir = "/dev/shm";
  113:         if (statfs(tmpdir, &stfs) == 0) {
  114: #endif
  115:             int64_t free_space;
  116:             int ram_mb;
  117: 
  118:             free_space = (int64_t)stfs.f_bavail * stfs.f_bsize;
  119:             if ((ram_size + 8192 * 1024) >= free_space) {
  120:                 ram_mb = (ram_size / (1024 * 1024));
  121:                 fprintf(stderr,
  122:                         "You do not have enough space in '%s' for the %d MB of QEMU virtual RAM.\n",
  123:                         tmpdir, ram_mb);
  124:                 if (strcmp(tmpdir, "/dev/shm") == 0) {
  125:                     fprintf(stderr, "To have more space available provided you have enough RAM and swap, do as root:\n"
  126:                             "mount -o remount,size=%dm /dev/shm\n",
  127:                             ram_mb + 16);
  128:                 } else {
  129:                     fprintf(stderr,
  130:                             "Use the '-m' option of QEMU to diminish the amount of virtual RAM or use the\n"
  131:                             "QEMU_TMPDIR environment variable to set another directory where the QEMU\n"
  132:                             "temporary RAM file will be opened.\n");
  133:                 }
  134:                 fprintf(stderr, "Or disable the accelerator module with -no-kqemu\n");
  135:                 exit(1);
  136:             }
  137:         }
  138:         snprintf(phys_ram_file, sizeof(phys_ram_file), "%s/qemuXXXXXX",
  139:                  tmpdir);
  140:         phys_ram_fd = mkstemp(phys_ram_file);
  141:         if (phys_ram_fd < 0) {
  142:             fprintf(stderr,
  143:                     "warning: could not create temporary file in '%s'.\n"
  144:                     "Use QEMU_TMPDIR to select a directory in a tmpfs filesystem.\n"
  145:                     "Using '/tmp' as fallback.\n",
  146:                     tmpdir);
  147:             snprintf(phys_ram_file, sizeof(phys_ram_file), "%s/qemuXXXXXX",
  148:                      "/tmp");
  149:             phys_ram_fd = mkstemp(phys_ram_file);
  150:             if (phys_ram_fd < 0) {
  151:                 fprintf(stderr, "Could not create temporary memory file '%s'\n",
  152:                         phys_ram_file);
  153:                 exit(1);
  154:             }
  155:         }
  156:         unlink(phys_ram_file);
  157:     }
  158:     size = (size + 4095) & ~4095;
  159:     ftruncate(phys_ram_fd, phys_ram_size + size);
  160: #endif /* !(__OpenBSD__ || __FreeBSD__) */
  161:     ptr = mmap(NULL,
  162:                size,
  163:                PROT_WRITE | PROT_READ, map_anon | MAP_SHARED,
  164:                phys_ram_fd, phys_ram_size);
  165:     if (ptr == MAP_FAILED) {
  166:         fprintf(stderr, "Could not map physical memory\n");
  167:         exit(1);
  168:     }
  169:     phys_ram_size += size;
  170:     return ptr;
  171: }
  172: 
  173: static void kqemu_vfree(void *ptr)
  174: {
  175:     /* may be useful some day, but currently we do not need to free */
  176: }
  177: 
  178: #endif
  179: 
  180: void *qemu_memalign(size_t alignment, size_t size)
  181: {
  182: #if defined(_POSIX_C_SOURCE)
  183:     int ret;
  184:     void *ptr;
  185:     ret = posix_memalign(&ptr, alignment, size);
  186:     if (ret != 0)
  187:         return NULL;
  188:     return ptr;
  189: #elif defined(_BSD)
  190:     return valloc(size);
  191: #else
  192:     return memalign(alignment, size);
  193: #endif
  194: }
  195: 
  196: /* alloc shared memory pages */
  197: void *qemu_vmalloc(size_t size)
  198: {
  199: #if defined(USE_KQEMU)
  200:     if (kqemu_allowed)
  201:         return kqemu_vmalloc(size);
  202: #endif
  203:     return qemu_memalign(getpagesize(), size);
  204: }
  205: 
  206: void qemu_vfree(void *ptr)
  207: {
  208: #if defined(USE_KQEMU)
  209:     if (kqemu_allowed)
  210:         kqemu_vfree(ptr);
  211: #endif
  212:     free(ptr);
  213: }
  214: 
  215: #endif
  216: 
  217: int qemu_create_pidfile(const char *filename)
  218: {
  219:     char buffer[128];
  220:     int len;
  221: #ifndef _WIN32
  222:     int fd;
  223: 
  224:     fd = open(filename, O_RDWR | O_CREAT, 0600);
  225:     if (fd == -1)
  226:         return -1;
  227: 
  228:     if (lockf(fd, F_TLOCK, 0) == -1)
  229:         return -1;
  230: 
  231:     len = snprintf(buffer, sizeof(buffer), "%ld\n", (long)getpid());
  232:     if (write(fd, buffer, len) != len)
  233:         return -1;
  234: #else
  235:     HANDLE file;
  236:     DWORD flags;
  237:     OVERLAPPED overlap;
  238:     BOOL ret;
  239: 
  240:     /* Open for writing with no sharing. */
  241:     file = CreateFile(filename, GENERIC_WRITE, 0, NULL,
  242: 		      OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
  243: 
  244:     if (file == INVALID_HANDLE_VALUE)
  245:       return -1;
  246: 
  247:     flags = LOCKFILE_EXCLUSIVE_LOCK | LOCKFILE_FAIL_IMMEDIATELY;
  248:     overlap.hEvent = 0;
  249:     /* Lock 1 byte. */
  250:     ret = LockFileEx(file, flags, 0, 0, 1, &overlap);
  251:     if (ret == 0)
  252:       return -1;
  253: 
  254:     /* Write PID to file. */
  255:     len = snprintf(buffer, sizeof(buffer), "%ld\n", (long)getpid());
  256:     ret = WriteFileEx(file, (LPCVOID)buffer, (DWORD)len,
  257: 		      &overlap, NULL);
  258:     if (ret == 0)
  259:       return -1;
  260: #endif
  261:     return 0;
  262: }
  263: 
  264: #ifdef _WIN32
  265: 
  266: /* Offset between 1/1/1601 and 1/1/1970 in 100 nanosec units */
  267: #define _W32_FT_OFFSET (116444736000000000ULL)
  268: 
  269: int qemu_gettimeofday(qemu_timeval *tp)
  270: {
  271:   union {
  272:     unsigned long long ns100; /*time since 1 Jan 1601 in 100ns units */
  273:     FILETIME ft;
  274:   }  _now;
  275: 
  276:   if(tp)
  277:     {
  278:       GetSystemTimeAsFileTime (&_now.ft);
  279:       tp->tv_usec=(long)((_now.ns100 / 10ULL) % 1000000ULL );
  280:       tp->tv_sec= (long)((_now.ns100 - _W32_FT_OFFSET) / 10000000ULL);
  281:     }
  282:   /* Always return 0 as per Open Group Base Specifications Issue 6.
  283:      Do not set errno on error.  */
  284:   return 0;
  285: }
  286: #endif /* _WIN32 */
  287: 
  288: 
  289: #ifdef _WIN32
  290: void socket_set_nonblock(int fd)
  291: {
  292:     unsigned long opt = 1;
  293:     ioctlsocket(fd, FIONBIO, &opt);
  294: }
  295: 
  296: int inet_aton(const char *cp, struct in_addr *ia)
  297: {
  298:     uint32_t addr = inet_addr(cp);
  299:     if (addr == 0xffffffff)
  300: 	return 0;
  301:     ia->s_addr = addr;
  302:     return 1;
  303: }
  304: #else
  305: void socket_set_nonblock(int fd)
  306: {
  307:     int f;
  308:     f = fcntl(fd, F_GETFL);
  309:     fcntl(fd, F_SETFL, f | O_NONBLOCK);
  310: }
  311: #endif

unix.superglobalmegacorp.com