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 

   287 struct tm *localtime_r(const time_t *timep, struct tm *result)

   288 {

   289     *result = *localtime(timep);

   290     return result;

   291 }

   292 

   293 struct tm *gmtime_r(const time_t *timep, struct tm *result)

   294 {

   295     *result = *gmtime(timep);

   296     return result;

   297 }

   298 #endif /* _WIN32 */

   299 

   300 

   301 #ifdef _WIN32

   302 void socket_set_nonblock(int fd)

   303 {

   304     unsigned long opt = 1;

   305     ioctlsocket(fd, FIONBIO, &opt);

   306 }

   307 

   308 int inet_aton(const char *cp, struct in_addr *ia)

   309 {

   310     uint32_t addr = inet_addr(cp);

   311     if (addr == 0xffffffff)

   312 	return 0;

   313     ia->s_addr = addr;

   314     return 1;

   315 }

   316 #else

   317 void socket_set_nonblock(int fd)

   318 {

   319     int f;

   320     f = fcntl(fd, F_GETFL);

   321     fcntl(fd, F_SETFL, f | O_NONBLOCK);

   322 }

   323 #endif