haiku.git

/*
 * Copyright 2013, Paweł Dziepak, pdziepak@quarnos.org.
 * Copyright 2002-2008, Axel Dörfler, axeld@pinc-software.de.
 * Distributed under the terms of the MIT License.
 */


#include <OS.h>

#include <string.h>

#include <algorithm>

#include <syscalls.h>
#include <system_info.h>


#if __HAIKU_BEOS_COMPATIBLE


#define LEGACY_B_CPU_X86			15

#define LEGACY_B_AT_CLONE_PLATFORM	2

typedef struct {
	bigtime_t	active_time;	/* usec of doing useful work since boot */
} legacy_cpu_info;

typedef struct {
	int32			id[2];				/* unique machine ID */
	bigtime_t		boot_time;			/* time of boot (usecs since 1/1/1970) */

	int32			cpu_count;			/* number of cpus */
	int32			cpu_type;			/* type of cpu */
	int32			cpu_revision;		/* revision # of cpu */
	legacy_cpu_info	cpu_infos[8];		/* info about individual cpus */
	int64			cpu_clock_speed;	/* processor clock speed (Hz) */
	int64			bus_clock_speed;	/* bus clock speed (Hz) */
	int32			platform_type;	/* type of machine we're on */

	int32			max_pages;			/* total # of accessible pages */
	int32			used_pages;			/* # of accessible pages in use */
	int32			page_faults;		/* # of page faults */
	int32			max_sems;
	int32			used_sems;
	int32			max_ports;
	int32			used_ports;
	int32			max_threads;
	int32			used_threads;
	int32			max_teams;
	int32			used_teams;

	char			kernel_name[256];
	char			kernel_build_date[32];
	char			kernel_build_time[32];
	int64			kernel_version;

	bigtime_t		_busy_wait_time;	/* reserved for whatever */

	int32			cached_pages;
	uint32			abi;				/* the system API */
	int32			ignored_pages;		/* # of ignored/inaccessible pages */
	int32			pad;
} legacy_system_info;


extern "C" status_t
_get_system_info(legacy_system_info* info, size_t size)
{
	if (info == NULL || size != sizeof(legacy_system_info))
		return B_BAD_VALUE;
	memset(info, 0, sizeof(legacy_system_info));

	system_info systemInfo;
	status_t error = _kern_get_system_info(&systemInfo);
	if (error != B_OK)
		return error;

	cpu_info cpuInfos[8];
	error = _kern_get_cpu_info(0, std::min(systemInfo.cpu_count, uint32(8)),
			cpuInfos);
	if (error != B_OK)
		return error;

	info->boot_time = systemInfo.boot_time;
	info->cpu_count = std::min(systemInfo.cpu_count, uint32(8));
	for (int32 i = 0; i < info->cpu_count; i++)
		info->cpu_infos[i].active_time = cpuInfos[i].active_time;

	info->platform_type = LEGACY_B_AT_CLONE_PLATFORM;
	info->cpu_type = LEGACY_B_CPU_X86;

	uint32 topologyNodeCount = 0;
	cpu_topology_node_info* topology = NULL;
	error = get_cpu_topology_info(NULL, &topologyNodeCount);
	if (error != B_OK)
		return B_OK;
	if (topologyNodeCount != 0) {
		topology = new(std::nothrow) cpu_topology_node_info[topologyNodeCount];
		if (topology == NULL)
			return B_NO_MEMORY;
	}
	error = get_cpu_topology_info(topology, &topologyNodeCount);
	if (error != B_OK) {
		delete[] topology;
		return error;
	}

	for (uint32 i = 0; i < topologyNodeCount; i++) {
		if (topology[i].type == B_TOPOLOGY_CORE) {
			info->cpu_clock_speed = topology[i].data.core.default_frequency;
			break;
		}
	}
	info->bus_clock_speed = info->cpu_clock_speed;
	delete[] topology;

	info->max_pages = std::min(systemInfo.max_pages, uint64(INT32_MAX));
	info->used_pages = std::min(systemInfo.used_pages, uint64(INT32_MAX));
	info->cached_pages = std::min(systemInfo.cached_pages, uint64(INT32_MAX));
	info->ignored_pages = std::min(systemInfo.ignored_pages, uint64(INT32_MAX));
	info->page_faults = std::min(systemInfo.page_faults, uint32(INT32_MAX));
	info->max_sems = std::min(systemInfo.max_sems, uint32(INT32_MAX));
	info->used_sems = std::min(systemInfo.used_sems, uint32(INT32_MAX));
	info->max_ports = std::min(systemInfo.max_ports, uint32(INT32_MAX));
	info->used_ports = std::min(systemInfo.used_ports, uint32(INT32_MAX));
	info->max_threads = std::min(systemInfo.max_threads, uint32(INT32_MAX));
	info->used_threads = std::min(systemInfo.used_threads, uint32(INT32_MAX));
	info->max_teams = std::min(systemInfo.max_teams, uint32(INT32_MAX));
	info->used_teams = std::min(systemInfo.used_teams, uint32(INT32_MAX));

	strlcpy(info->kernel_name, systemInfo.kernel_name,
		sizeof(info->kernel_name));
	strlcpy(info->kernel_build_date, systemInfo.kernel_build_date,
		sizeof(info->kernel_build_date));
	strlcpy(info->kernel_build_time, systemInfo.kernel_build_time,
		sizeof(info->kernel_build_time));
	info->kernel_version = systemInfo.kernel_version;

	info->abi = systemInfo.abi;

	return B_OK;
}


#endif	// __HAIKU_BEOS_COMPATIBLE


status_t
__get_system_info(system_info* info)
{
	return _kern_get_system_info(info);
}


typedef struct {
	bigtime_t	active_time;
	bool		enabled;
} beta2_cpu_info;


extern "C" status_t
__get_cpu_info(uint32 firstCPU, uint32 cpuCount, beta2_cpu_info* beta2_info)
{
	cpu_info info;
	status_t err = _get_cpu_info_etc(firstCPU, cpuCount, &info, sizeof(info));
	if (err == B_OK) {
		beta2_info->active_time = info.active_time;
		beta2_info->enabled = info.enabled;
	}
	return err;
}


status_t
_get_cpu_info_etc(uint32 firstCPU, uint32 cpuCount, cpu_info* info,
	size_t size)
{
	if (info == NULL || size != sizeof(cpu_info))
		return B_BAD_VALUE;
	return _kern_get_cpu_info(firstCPU, cpuCount, info);
}


status_t
__get_cpu_topology_info(cpu_topology_node_info* topologyInfos,
	uint32* topologyInfoCount)
{
	return _kern_get_cpu_topology_info(topologyInfos, topologyInfoCount);
}


status_t
__start_watching_system(int32 object, uint32 flags, port_id port, int32 token)
{
	return _kern_start_watching_system(object, flags, port, token);
}


status_t
__stop_watching_system(int32 object, uint32 flags, port_id port, int32 token)
{
	return _kern_stop_watching_system(object, flags, port, token);
}


int32
is_computer_on(void)
{
	return _kern_is_computer_on();
}


double
is_computer_on_fire(void)
{
	return 0.63739;
}


B_DEFINE_WEAK_ALIAS(__get_system_info, get_system_info);
B_DEFINE_WEAK_ALIAS(__get_cpu_info, get_cpu_info);
B_DEFINE_WEAK_ALIAS(__get_cpu_topology_info, get_cpu_topology_info);