path: root/tizen/src/util/osutil-linux.c

/*
 * Emulator
 *
 * Copyright (C) 2012 - 2014 Samsung Electronics Co., Ltd. All rights reserved.
 *
 * Contact:
 * SeokYeon Hwang <syeon.hwang@samsung.com>
 * MunKyu Im <munkyu.im@samsung.com>
 * GiWoong Kim <giwoong.kim@samsung.com>
 * YeongKyoon Lee <yeongkyoon.lee@samsung.com>
 * HyunJun Son
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 * Contributors:
 * - S-Core Co., Ltd
 *
 */

/**
  @file     osutil-linux.c
  @brief    Collection of utilities for linux
 */

#include <png.h>
#include <string.h>
#include <unistd.h>
#include <sys/shm.h>
#include <sys/ipc.h>
#include <linux/version.h>
#include <sys/utsname.h>
#include <sys/sysinfo.h>

#include "qemu/sockets.h"
#include "qemu/error-report.h"

#include "osutil.h"
#include "emulator.h"
#include "emul_state.h"
#include "net_helper.h"
#include "emulator_options.h"

#ifndef CONFIG_LINUX
#error
#endif

#include "debug_ch.h"
MULTI_DEBUG_CHANNEL(emulator, osutil);

static int g_shmid;
static char *g_shared_memory;

void check_vm_lock_os(void)
{
    int shm_id;
    void *shm_addr;
    uint32_t port;
    int val;
    struct shmid_ds shm_info;

    for (port = 26100; port < 26200; port += 10) {
        shm_id = shmget((key_t)port, 0, 0);
        if (shm_id != -1) {
            shm_addr = shmat(shm_id, (void *)0, 0);
            if ((void *)-1 == shm_addr) {
                ERR("error occured at shmat()\n");
                break;
            }

            val = shmctl(shm_id, IPC_STAT, &shm_info);
            if (val != -1) {
                INFO("count of process that use shared memory: %d\n",
                    shm_info.shm_nattch);
                if ((shm_info.shm_nattch > 0) &&
                    g_strcmp0(get_drive_image_file(), (char *)shm_addr) == 0) {
                    int ret = 0;
                    if ((ret = check_port_bind_listen(port + 1)) > 0) {
                        shmdt(shm_addr);
                        closesocket(ret);
                        continue;
                    }
                    shmdt(shm_addr);
                    // FIXME: VM lock logic should be refactored ASAP.
#if 0
                    error_report("Can not execute this VM. "
                            "The same name is running now.");
                    exit(1);
#endif
                } else {
                    shmdt(shm_addr);
                }
            }
        }
    }
}

static void remove_vm_lock_os(void)
{
    if (shmctl(g_shmid, IPC_RMID, 0) == -1) {
        ERR("shmctl failed\n");
        perror("osutil-linux: ");
    }
}

static void notify_remove_lock(Notifier *notifier, void *data)
{
    remove_vm_lock_os();
}

static Notifier remove_lock = { .notify = notify_remove_lock };

void make_vm_lock_os(void)
{
    int base_port;

    check_vm_lock_os();

    base_port = get_vm_base_port();

    g_shmid = shmget((key_t)base_port, getpagesize(), 0666|IPC_CREAT);
    if (g_shmid == -1) {
        ERR("shmget failed\n");
        perror("osutil-linux: ");
        return;
    }

    g_shared_memory = shmat(g_shmid, (char *)0x00, 0);
    if (g_shared_memory == (void *)-1) {
        ERR("shmat failed\n");
        perror("osutil-linux: ");
        return;
    }

    g_sprintf(g_shared_memory, "%s", get_drive_image_file());
    INFO("shared memory key: %d value: %s\n",
        base_port, (char *)g_shared_memory);

    if (shmdt(g_shared_memory) == -1) {
        ERR("shmdt failed\n");
        perror("osutil-linux: ");
    }

    emulator_add_exit_notifier(&remove_lock);
}

void set_bin_path_os(char const *const exec_argv)
{
    char link_path[PATH_MAX] = { 0, };
    char bin_path_os[PATH_MAX] = { 0, };
    char *file_name = NULL;

    ssize_t len = readlink("/proc/self/exe", link_path, sizeof(link_path) - 1);

    if (len < 0 || len > (sizeof(link_path) - 1)) {
        perror("set_bin_path error : ");
        return;
    }

    link_path[len] = '\0';

    file_name = g_strrstr(link_path, "/");
    g_strlcpy(bin_path_os, link_path, strlen(link_path) - strlen(file_name) + 1);

    g_strlcat(bin_path_os, "/", PATH_MAX);

    bin_path = g_strdup(bin_path_os);
}

int get_number_of_processors(void)
{
    int num_processors = 0;

    num_processors = sysconf(_SC_NPROCESSORS_ONLN);
    if (num_processors < 1) {
        num_processors = 1;
    }
    TRACE("Number of processors : %d\n", num_processors);

    return num_processors;
}

void print_system_info_os(void)
{
    INFO("* Linux\n");

    INFO("* LibPNG Version : %s\n", PNG_LIBPNG_VER_STRING);

    /* depends on building */
    INFO("* QEMU build machine linux kernel version : %d.%d.%d\n",
        LINUX_VERSION_CODE >> 16,
        (LINUX_VERSION_CODE >> 8) & 0xff,
        LINUX_VERSION_CODE & 0xff);

     /* depends on launching */
    struct utsname host_uname_buf;
    if (uname(&host_uname_buf) == 0) {
        INFO("* Host machine uname : %s %s %s %s %s\n",
            host_uname_buf.sysname, host_uname_buf.nodename,
            host_uname_buf.release, host_uname_buf.version,
            host_uname_buf.machine);
    }

    struct sysinfo sys_info;
    if (sysinfo(&sys_info) == 0) {
        INFO("* Total Ram : %llu kB, Free: %llu kB\n",
            sys_info.totalram * (unsigned long long)sys_info.mem_unit / 1024,
            sys_info.freeram * (unsigned long long)sys_info.mem_unit / 1024);
    }

    /* get linux distribution information */
    INFO("* Linux distribution infomation :\n");
    char const *const lsb_release_cmd = "lsb_release -d -r -c";
    gchar *buffer = NULL;
    gint buffer_size = strlen(lsb_release_cmd) + 1;

    buffer = g_malloc(buffer_size);

    g_snprintf(buffer, buffer_size, "%s", lsb_release_cmd);

    if (system(buffer) < 0) {
        INFO("system function command '%s' \
                returns error !", buffer);
    }
    g_free(buffer);

    /* pci device description */
    INFO("* Host PCI devices :\n");
    char const *const lspci_cmd = "lspci";
    buffer_size = strlen(lspci_cmd) + 1;

    buffer = g_malloc(buffer_size);

    g_snprintf(buffer, buffer_size, "%s", lspci_cmd);

    fflush(stdout);
    if (system(buffer) < 0) {
        INFO("system function command '%s' \
                returns error !", buffer);
    }
    g_free(buffer);
}

bool make_sdcard_lock_os(char *sdcard)
{
    return make_sdcard_lock_posix(sdcard);
}


int remove_sdcard_lock_os(char *sdcard)
{
    return remove_sdcard_lock_posix(sdcard);
}