|
160
|
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
|
|
|
29 void uv_loadavg(double avg[3]) {
|
|
|
30 avg[0] = 0;
|
|
|
31 avg[1] = 0;
|
|
|
32 avg[2] = 0;
|
|
|
33 }
|
|
|
34
|
|
|
35
|
|
|
36 int 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
|
|
|
58 uint64_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
|
|
|
70 uint64_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
|
|
|
82 uint64_t uv_get_constrained_memory(void) {
|
|
|
83 return 0; /* Memory constraints are unknown. */
|
|
|
84 }
|
|
|
85
|
|
|
86
|
|
|
87 uint64_t uv_get_available_memory(void) {
|
|
|
88 return uv_get_free_memory();
|
|
|
89 }
|
|
|
90
|
|
|
91
|
|
|
92 int 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
|
|
|
111 int 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
|
|
|
118 int 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 topology_count; /* Haiku expects address of uint32, not uint32_t */
|
|
|
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 }
|
