1/* Copyright libuv project contributors. All rights reserved. 2 * 3 * Permission is hereby granted, free of charge, to any person obtaining a copy 4 * of this software and associated documentation files (the "Software"), to 5 * deal in the Software without restriction, including without limitation the 6 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or 7 * sell copies of the Software, and to permit persons to whom the Software is 8 * furnished to do so, subject to the following conditions: 9 * 10 * The above copyright notice and this permission notice shall be included in 11 * all copies or substantial portions of the Software. 12 * 13 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 14 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 15 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 16 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 17 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 18 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 19 * IN THE SOFTWARE. 20 */ 21 22#include "uv.h" 23#include "internal.h" 24 25#include <FindDirectory.h> /* find_path() */ 26#include <OS.h> 27 28 29void uv_loadavg(double avg[3]) { 30 avg[0] = 0; 31 avg[1] = 0; 32 avg[2] = 0; 33} 34 35 36int uv_exepath(char* buffer, size_t* size) { 37 char abspath[B_PATH_NAME_LENGTH]; 38 status_t status; 39 ssize_t abspath_len; 40 41 if (buffer == NULL || size == NULL || *size == 0) 42 return UV_EINVAL; 43 44 status = find_path(B_APP_IMAGE_SYMBOL, B_FIND_PATH_IMAGE_PATH, NULL, abspath, 45 sizeof(abspath)); 46 if (status != B_OK) 47 return UV__ERR(status); 48 49 abspath_len = uv__strscpy(buffer, abspath, *size); 50 *size -= 1; 51 if (abspath_len >= 0 && *size > (size_t)abspath_len) 52 *size = (size_t)abspath_len; 53 54 return 0; 55} 56 57 58uint64_t uv_get_free_memory(void) { 59 status_t status; 60 system_info sinfo; 61 62 status = get_system_info(&sinfo); 63 if (status != B_OK) 64 return 0; 65 66 return (sinfo.max_pages - sinfo.used_pages) * B_PAGE_SIZE; 67} 68 69 70uint64_t uv_get_total_memory(void) { 71 status_t status; 72 system_info sinfo; 73 74 status = get_system_info(&sinfo); 75 if (status != B_OK) 76 return 0; 77 78 return sinfo.max_pages * B_PAGE_SIZE; 79} 80 81 82uint64_t uv_get_constrained_memory(void) { 83 return 0; /* Memory constraints are unknown. */ 84} 85 86 87uint64_t uv_get_available_memory(void) { 88 return uv_get_free_memory(); 89} 90 91 92int uv_resident_set_memory(size_t* rss) { 93 area_info area; 94 ssize_t cookie; 95 status_t status; 96 thread_info thread; 97 98 status = get_thread_info(find_thread(NULL), &thread); 99 if (status != B_OK) 100 return UV__ERR(status); 101 102 cookie = 0; 103 *rss = 0; 104 while (get_next_area_info(thread.team, &cookie, &area) == B_OK) 105 *rss += area.ram_size; 106 107 return 0; 108} 109 110 111int uv_uptime(double* uptime) { 112 /* system_time() returns time since booting in microseconds */ 113 *uptime = (double)system_time() / 1000000; 114 return 0; 115} 116 117 118int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) { 119 cpu_topology_node_info* topology_infos; 120 int i; 121 status_t status; 122 system_info system; 123 uint32_t topology_count; 124 uint64_t cpuspeed; 125 uv_cpu_info_t* cpu_info; 126 127 if (cpu_infos == NULL || count == NULL) 128 return UV_EINVAL; 129 130 status = get_cpu_topology_info(NULL, &topology_count); 131 if (status != B_OK) 132 return UV__ERR(status); 133 134 topology_infos = uv__malloc(topology_count * sizeof(*topology_infos)); 135 if (topology_infos == NULL) 136 return UV_ENOMEM; 137 138 status = get_cpu_topology_info(topology_infos, &topology_count); 139 if (status != B_OK) { 140 uv__free(topology_infos); 141 return UV__ERR(status); 142 } 143 144 cpuspeed = 0; 145 for (i = 0; i < (int)topology_count; i++) { 146 if (topology_infos[i].type == B_TOPOLOGY_CORE) { 147 cpuspeed = topology_infos[i].data.core.default_frequency; 148 break; 149 } 150 } 151 152 uv__free(topology_infos); 153 154 status = get_system_info(&system); 155 if (status != B_OK) 156 return UV__ERR(status); 157 158 *cpu_infos = uv__calloc(system.cpu_count, sizeof(**cpu_infos)); 159 if (*cpu_infos == NULL) 160 return UV_ENOMEM; 161 162 /* CPU time and model are not exposed by Haiku. */ 163 cpu_info = *cpu_infos; 164 for (i = 0; i < (int)system.cpu_count; i++) { 165 cpu_info->model = uv__strdup("unknown"); 166 cpu_info->speed = (int)(cpuspeed / 1000000); 167 cpu_info++; 168 } 169 *count = system.cpu_count; 170 171 return 0; 172} 173