char *platform_get_nextopenstep_runtime_os(void)
{
kern_return_t ret;
kernel_version_t string;
char *version = NULL;
int i = 0;
if (!got_os) {
ret = host_kernel_version(host_self(), string);
if (ret != KERN_SUCCESS) {
sprintf(os, "Unknown NextStep or OpenStep version\n");
} else {
version = string;
while (*version != ' ') {
version ++;
}
version++;
while (*version != ' ') {
version ++;
}
version++;
while (version[i] != ':') {
i++;
}
version[i] = 0;
if (version[0] == '4') {
sprintf(os, "OpenStep %s", version);
} else {
sprintf(os, "NextStep %s", version);
}
}
got_os = 1;
}
return os;
}
static int proc_readosfmach3(
struct inode *inode,
struct file *file,
char *buf,
int count)
{
char * page;
int length;
unsigned int ino;
kern_return_t kr;
if (count < 0)
return -EINVAL;
if (!(page = (char*) __get_free_page(GFP_KERNEL)))
return -ENOMEM;
ino = inode->i_ino;
switch (ino)
{
case PROC_OSFMACH3_VERSION:
kr = host_kernel_version(host_port, page);
if (kr != KERN_SUCCESS) {
MACH3_DEBUG(2, kr,
("proc_readosfmach3: host_kernel_version"));
}
length = strlen(page);
break;
case PROC_OSFMACH3_VM_STATISTICS: {
extern struct vm_statistics osfmach3_vm_stats;
osfmach3_update_vm_info();
length = sprintf(page,
"free_count : %d\n"
"active_count : %d\n"
"inactive_count : %d\n"
"wire_count : %d\n"
"zero_fill_count : %d\n"
"reactivations : %d\n"
"pageins : %d\n"
"pageouts : %d\n"
"faults : %d\n"
"cow_faults : %d\n"
"lookups : %d\n"
"hits : %d\n",
osfmach3_vm_stats.free_count,
osfmach3_vm_stats.active_count,
osfmach3_vm_stats.inactive_count,
osfmach3_vm_stats.wire_count,
osfmach3_vm_stats.zero_fill_count,
osfmach3_vm_stats.reactivations,
osfmach3_vm_stats.pageins,
osfmach3_vm_stats.pageouts,
osfmach3_vm_stats.faults,
osfmach3_vm_stats.cow_faults,
osfmach3_vm_stats.lookups,
osfmach3_vm_stats.hits);
break;
}
case PROC_OSFMACH3_HOST_SCHED_INFO: {
struct host_sched_info sched_info;
int count = sizeof(sched_info);
kr = host_info(host_port,
HOST_SCHED_INFO,
(host_info_t)&sched_info,
&count);
if (kr != KERN_SUCCESS) {
MACH3_DEBUG(2, kr,
("proc_readosfmach3: host_info"));
}
length = sprintf(page,
"min_timeout : %d ms\n"
"min_quantum : %d ms\n",
sched_info.min_timeout,
sched_info.min_quantum);
break;
}
case PROC_OSFMACH3_HOST_BASIC_INFO: {
struct host_basic_info basic_info;
int count = sizeof(basic_info);
kr = host_info(host_port,
HOST_BASIC_INFO,
(host_info_t)&basic_info,
&count);
if (kr != KERN_SUCCESS) {
MACH3_DEBUG(2, kr,
("proc_readosfmach3: host_info"));
}
length = sprintf(page,
"max_cpus : %d\n"
"avail_cpus : %d\n"
"memory_size : %d Mb\n",
basic_info.max_cpus,
basic_info.avail_cpus,
basic_info.memory_size / (1024 * 1024));
break;
}
default:
free_page((unsigned long) page);
return -EBADF;
}
if (file->f_pos >= length) {
free_page((unsigned long) page);
return 0;
}
if (count + file->f_pos > length)
count = length - file->f_pos;
/*
* Copy the bytes
*/
memcpy_tofs(buf, page + file->f_pos, count);
free_page((unsigned long) page);
file->f_pos += count; /* Move down the file */
return count; /* all transfered correctly */
}
int main(int argc, char *argv[])
{
kern_return_t ret;
unsigned int size, count;
char *cpu_name, *cpu_subname;
int i;
int mib[2];
size_t len;
uint64_t memsize;
processor_set_name_port_t default_pset;
host_name_port_t host;
struct processor_set_basic_info basic_info;
struct processor_set_load_info load_info;
host = mach_host_self();
ret = host_kernel_version(host, version);
if (ret != KERN_SUCCESS) {
mach_error(argv[0], ret);
exit(EXIT_FAILURE);
}
printf("Mach kernel version:\n\t %s\n", version);
size = sizeof(hi)/sizeof(int);
ret = host_info(host, HOST_BASIC_INFO, (host_info_t)&hi, &size);
if (ret != KERN_SUCCESS) {
mach_error(argv[0], ret);
exit(EXIT_FAILURE);
}
ret = processor_set_default(host, &default_pset);
if (ret != KERN_SUCCESS) {
mach_error(argv[0], ret);
exit(EXIT_FAILURE);
}
count = PROCESSOR_SET_BASIC_INFO_COUNT;
ret = processor_set_info(default_pset, PROCESSOR_SET_BASIC_INFO,
&host, (processor_set_info_t)&basic_info, &count);
if (ret != KERN_SUCCESS) {
mach_error(argv[0], ret);
exit(EXIT_FAILURE);
}
count = PROCESSOR_SET_LOAD_INFO_COUNT;
ret = processor_set_statistics(default_pset, PROCESSOR_SET_LOAD_INFO,
(processor_set_info_t)&load_info, &count);
if (ret != KERN_SUCCESS) {
mach_error(argv[0], ret);
exit(EXIT_FAILURE);
}
mib[0] = CTL_HW;
mib[1] = HW_MEMSIZE;
len = sizeof(memsize);
memsize = 0L;
if(sysctl(mib, 2, &memsize, &len, NULL, 0 ) == -1)
{
perror("sysctl");
exit(EXIT_FAILURE);
}
if (hi.max_cpus > 1)
printf("Kernel configured for up to %d processors.\n",
hi.max_cpus);
else
printf("Kernel configured for a single processor only.\n");
printf("%d processor%s physically available.\n", hi.physical_cpu,
(hi.physical_cpu > 1) ? "s are" : " is");
printf("%d processor%s logically available.\n", hi.logical_cpu,
(hi.logical_cpu > 1) ? "s are" : " is");
printf("Processor type:");
slot_name(hi.cpu_type, hi.cpu_subtype, &cpu_name, &cpu_subname);
printf(" %s (%s)\n", cpu_name, cpu_subname);
printf("Processor%s active:", (hi.avail_cpus > 1) ? "s" : "");
for (i = 0; i < hi.avail_cpus; i++)
printf(" %d", i);
printf("\n");
if (((float)memsize / (1024.0 * 1024.0)) >= 1024.0)
printf("Primary memory available: %.2f gigabytes\n",
(float)memsize/(1024.0*1024.0*1024.0));
else
printf("Primary memory available: %.2f megabytes\n",
(float)memsize/(1024.0*1024.0));
printf("Default processor set: %d tasks, %d threads, %d processors\n",
load_info.task_count, load_info.thread_count, basic_info.processor_count);
printf("Load average: %d.%02d, Mach factor: %d.%02d\n",
load_info.load_average/LOAD_SCALE,
(load_info.load_average%LOAD_SCALE)/10,
load_info.mach_factor/LOAD_SCALE,
(load_info.mach_factor%LOAD_SCALE)/10);
exit(0);
}
/*
* This function will send a single Mach message in an attempt
* to obtain the kernel version. Once it has the reply from Mach,
* it will iterate the string and obtain a release number, system
* name, and kernel version string.
*
* This is trying to be as efficient as possible, but will probably
* end up being a very gnarly hack with no real value whatsoever.
*/
void detectOpSysVersion(void)
{
kern_return_t kret;
kernel_version_t kver;
kret = host_kernel_version(host_self(), kver);
if (kret != KERN_SUCCESS) {
mach_error("host_kernel_version() failed.", kret);
} else {
int idx = 0, len = 0;
/* Copy the kernel version to a string */
strcpy(version, kver);
len = strlen(version);
/* Remove trailing \n, if it exists */
if (version[len -1] == '\n')
version[len - 1] = '\0';
/* This is the slowest part of the whole thing... */
for (idx = 0; idx < len; idx++) {
/* Version: [0-9].[0-9]: */
if (isdigit(version[idx]) && version[idx + 1] == '.' &&
isdigit(version[idx + 2]) && version[idx + 3] == ':')
{
sprintf(release,
"%c.%c\0",
version[idx],
version[idx + 2]);
break;
}
/* Version: [0-9].[0-9].[0-9]: */
if (isdigit(version[idx]) && version[idx + 1] == '.' &&
isdigit(version[idx + 2]) && version[idx + 3] == '.' &&
isdigit(version[idx + 4]) && version[idx + 5] == ':')
{
sprintf(release,
"%c.%c.%c\0",
version[idx],
version[idx + 2],
version[idx + 4]);
break;
}
/* Version: [0-9][0-9].[0-9].[0-9]: */
if (isdigit(version[idx]) && isdigit(version[idx + 1]) &&
version[idx + 2] == '.' && isdigit(version[idx + 3]) &&
version[idx + 4] == '.' && isdigit(version[idx + 5]) &&
version[idx + 6] == ':')
{
sprintf(release,
"%c%c.%c.%c\0",
version[idx],
version[idx + 1],
version[idx + 3],
version[idx + 5]);
break;
}
}
/*
* Compute the system name using the major version.
*
* If release[1] != '.', then it's Darwin... and this program would
* look very stupid if it printed 'NEXTSTEP 10.0' on an OSX box.
*/
if (release[1] == '.') {
switch (release[0]) {
case '0':
case '1':
case '2':
case '3':
sprintf(sysname, "NEXTSTEP\0");
break;
case '4':
sprintf(sysname, "OPENSTEP\0");
break;
case '5':
sprintf(sysname, "Rhapsody\0");
/* barf barf, Apple. */
for (idx = 0; idx < len; idx++)
if (version[idx] == '\n')
version[idx] = ' ';
break;
default:
sprintf(sysname, "Darwin\0");
}
} else {
sprintf(sysname, "Darwin\0");
}
} /* if (kret != ... */
/*
* Let's get the hostname on our way out
*/
gethostname(nodename, 255);
}
