source: mainline/uspace/lib/device/src/hr.c@ fc265b4

Last change on this file since fc265b4 was fc265b4, checked in by Miroslav Cimerman <mc@…>, 3 months ago

hr: IPC methods: don't create own hr_t session
  • Property mode set to 100644
File size: 10.6 KB
Line 
1/*
2 * Copyright (c) 2025 Miroslav Cimerman
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29/** @addtogroup libdevice
30 * @{
31 */
32/**
33 * @file
34 */
35
36#include <abi/ipc/interfaces.h>
37#include <async.h>
38#include <hr.h>
39#include <ipc/hr.h>
40#include <ipc/services.h>
41#include <loc.h>
42#include <stdlib.h>
43#include <stdio.h>
44#include <str.h>
45
46errno_t hr_sess_init(hr_t **rhr)
47{
48 errno_t rc;
49 hr_t *hr = NULL;
50
51 if (rhr == NULL)
52 return EINVAL;
53
54 hr = calloc(1, sizeof(hr_t));
55 if (hr == NULL) {
56 rc = ENOMEM;
57 goto error;
58 }
59
60 service_id_t hr_svcid;
61
62 rc = loc_service_get_id(SERVICE_NAME_HR, &hr_svcid, 0);
63 if (rc != EOK)
64 goto error;
65
66 hr->sess = loc_service_connect(hr_svcid, INTERFACE_HR, 0);
67 if (hr->sess == NULL) {
68 rc = EIO;
69 goto error;
70 }
71
72 *rhr = hr;
73 return EOK;
74error:
75 if (hr != NULL)
76 free(hr);
77
78 return rc;
79}
80
81void hr_sess_destroy(hr_t *hr)
82{
83 if (hr == NULL)
84 return;
85
86 async_hangup(hr->sess);
87 free(hr);
88}
89
90errno_t hr_create(hr_t *hr, hr_config_t *hr_config)
91{
92 errno_t rc, retval;
93 async_exch_t *exch;
94 aid_t req;
95
96 exch = async_exchange_begin(hr->sess);
97 if (exch == NULL)
98 return EINVAL;
99
100 req = async_send_0(exch, HR_CREATE, NULL);
101
102 rc = async_data_write_start(exch, hr_config, sizeof(hr_config_t));
103 if (rc != EOK) {
104 async_exchange_end(exch);
105 async_forget(req);
106 return rc;
107 }
108
109 async_exchange_end(exch);
110 async_wait_for(req, &retval);
111 return retval;
112}
113
114errno_t hr_assemble(hr_t *hr, hr_config_t *hr_config, size_t *rassembled_cnt)
115{
116 errno_t rc;
117 async_exch_t *exch;
118 aid_t req;
119 size_t assembled_cnt;
120
121 exch = async_exchange_begin(hr->sess);
122 if (exch == NULL)
123 return EINVAL;
124
125 req = async_send_0(exch, HR_ASSEMBLE, NULL);
126
127 rc = async_data_write_start(exch, hr_config, sizeof(hr_config_t));
128 if (rc != EOK) {
129 async_exchange_end(exch);
130 async_forget(req);
131 return rc;
132 }
133
134 rc = async_data_read_start(exch, &assembled_cnt, sizeof(size_t));
135 if (rc != EOK) {
136 async_exchange_end(exch);
137 async_forget(req);
138 return rc;
139 }
140
141 async_exchange_end(exch);
142 async_wait_for(req, &rc);
143
144 if (rassembled_cnt != NULL)
145 *rassembled_cnt = assembled_cnt;
146
147 return rc;
148}
149
150errno_t hr_auto_assemble(hr_t *hr, size_t *rassembled_cnt)
151{
152 errno_t rc;
153 size_t assembled_cnt;
154
155 async_exch_t *exch = async_exchange_begin(hr->sess);
156 if (exch == NULL) {
157 rc = EINVAL;
158 goto error;
159 }
160
161 aid_t req = async_send_0(exch, HR_AUTO_ASSEMBLE, NULL);
162
163 rc = async_data_read_start(exch, &assembled_cnt, sizeof(size_t));
164 if (rc != EOK) {
165 async_exchange_end(exch);
166 async_forget(req);
167 return rc;
168 }
169
170 async_exchange_end(exch);
171 async_wait_for(req, &rc);
172
173 if (rassembled_cnt != NULL)
174 *rassembled_cnt = assembled_cnt;
175error:
176 return rc;
177}
178
179static errno_t print_vol_info(size_t index, hr_vol_info_t *vol_info)
180{
181 errno_t rc;
182 size_t i;
183 char *devname;
184 hr_extent_t *ext;
185
186 printf("--- vol %zu ---\n", index);
187
188 printf("svc_id: %" PRIun "\n", vol_info->svc_id);
189
190 rc = loc_service_get_name(vol_info->svc_id, &devname);
191 if (rc != EOK)
192 return rc;
193 printf("devname: %s\n", devname);
194
195 printf("status: %s\n", hr_get_vol_status_msg(vol_info->status));
196
197 printf("level: %d\n", vol_info->level);
198 if (vol_info->level == HR_LVL_4 || vol_info->level == HR_LVL_5) {
199 printf("layout: %s\n",
200 hr_get_layout_str(vol_info->layout));
201 }
202 if (vol_info->level == HR_LVL_0 || vol_info->level == HR_LVL_4) {
203 if (vol_info->strip_size / 1024 < 1)
204 printf("strip size in bytes: %" PRIu32 "\n",
205 vol_info->strip_size);
206 else
207 printf("strip size: %" PRIu32 "K\n",
208 vol_info->strip_size / 1024);
209 }
210 printf("size in bytes: %" PRIu64 "MiB\n",
211 vol_info->nblocks * vol_info->bsize / 1024 / 1024);
212 printf("size in blocks: %" PRIu64 "\n", vol_info->nblocks);
213 printf("block size: %zu\n", vol_info->bsize);
214
215 if (vol_info->level == HR_LVL_4)
216 printf("extents: [P] [status] [index] [devname]\n");
217 else
218 printf("extents: [status] [index] [devname]\n");
219 for (i = 0; i < vol_info->extent_no; i++) {
220 ext = &vol_info->extents[i];
221 if (ext->status == HR_EXT_MISSING || ext->status == HR_EXT_NONE) {
222 devname = (char *) "MISSING-devname";
223 } else {
224 rc = loc_service_get_name(ext->svc_id, &devname);
225 if (rc != EOK) {
226 printf("loc_service_get_name() failed, skipping...\n");
227 continue;
228 }
229 }
230 if (vol_info->level == HR_LVL_4) {
231 if ((i == 0 && vol_info->layout == HR_RLQ_RAID4_0) ||
232 (i == vol_info->extent_no - 1 &&
233 vol_info->layout == HR_RLQ_RAID4_N))
234 printf(" P %s %zu %s\n", hr_get_ext_status_msg(ext->status), i, devname);
235 else
236 printf(" %s %zu %s\n", hr_get_ext_status_msg(ext->status), i, devname);
237 } else {
238 printf(" %s %zu %s\n", hr_get_ext_status_msg(ext->status), i, devname);
239 }
240 }
241
242 if (vol_info->hotspare_no == 0)
243 return EOK;
244
245 printf("hotspares: [status] [index] [devname]\n");
246 for (i = 0; i < vol_info->hotspare_no; i++) {
247 ext = &vol_info->hotspares[i];
248 if (ext->status == HR_EXT_MISSING) {
249 devname = (char *) "MISSING-devname";
250 } else {
251 rc = loc_service_get_name(ext->svc_id, &devname);
252 if (rc != EOK)
253 return rc;
254 }
255 printf(" %s %zu %s\n",
256 hr_get_ext_status_msg(ext->status), i, devname);
257 }
258
259 return EOK;
260}
261
262errno_t hr_stop(hr_t *hr, const char *devname)
263{
264 errno_t rc;
265 async_exch_t *exch;
266 service_id_t svc_id;
267
268 rc = loc_service_get_id(devname, &svc_id, 0);
269 if (rc != EOK)
270 return rc;
271
272 exch = async_exchange_begin(hr->sess);
273 if (exch == NULL) {
274 rc = EINVAL;
275 goto error;
276 }
277
278 rc = async_req_1_0(exch, HR_STOP, svc_id);
279 async_exchange_end(exch);
280error:
281 return rc;
282}
283
284errno_t hr_stop_all(hr_t *hr)
285{
286 async_exch_t *exch;
287 errno_t rc;
288
289 exch = async_exchange_begin(hr->sess);
290 if (exch == NULL) {
291 rc = EINVAL;
292 goto error;
293 }
294
295 rc = async_req_0_0(exch, HR_STOP_ALL);
296 async_exchange_end(exch);
297error:
298 return rc;
299}
300
301errno_t hr_fail_extent(hr_t *hr, const char *volume_name, unsigned long extent)
302{
303 errno_t rc;
304 async_exch_t *exch;
305 service_id_t vol_svc_id;
306
307 rc = loc_service_get_id(volume_name, &vol_svc_id, 0);
308 if (rc != EOK)
309 return rc;
310
311 exch = async_exchange_begin(hr->sess);
312 if (exch == NULL) {
313 rc = EINVAL;
314 goto error;
315 }
316
317 rc = async_req_2_0(exch, HR_FAIL_EXTENT, vol_svc_id, extent);
318 async_exchange_end(exch);
319error:
320 return rc;
321}
322
323errno_t hr_add_hotspare(hr_t *hr, const char *volume_name, const char *hotspare)
324{
325 errno_t rc;
326 async_exch_t *exch;
327 service_id_t vol_svc_id, hs_svc_id;
328
329 rc = loc_service_get_id(volume_name, &vol_svc_id, 0);
330 if (rc != EOK)
331 return rc;
332
333 rc = loc_service_get_id(hotspare, &hs_svc_id, 0);
334 if (rc != EOK)
335 return rc;
336
337 exch = async_exchange_begin(hr->sess);
338 if (exch == NULL) {
339 rc = EINVAL;
340 goto error;
341 }
342
343 rc = async_req_2_0(exch, HR_ADD_HOTSPARE, vol_svc_id, hs_svc_id);
344 async_exchange_end(exch);
345error:
346 return rc;
347}
348
349errno_t hr_print_status(hr_t *hr)
350{
351 errno_t rc, retval;
352 async_exch_t *exch;
353 aid_t req;
354 size_t size, i;
355 hr_vol_info_t *vols = NULL;
356
357 exch = async_exchange_begin(hr->sess);
358 if (exch == NULL) {
359 rc = EINVAL;
360 goto error;
361 }
362
363 req = async_send_0(exch, HR_STATUS, NULL);
364 rc = async_data_read_start(exch, &size, sizeof(size_t));
365 if (rc != EOK) {
366 async_exchange_end(exch);
367 async_forget(req);
368 return rc;
369 }
370
371 vols = calloc(size, sizeof(hr_vol_info_t));
372 if (vols == NULL) {
373 async_exchange_end(exch);
374 async_forget(req);
375 return ENOMEM;
376 }
377
378 for (i = 0; i < size; i++) {
379 rc = async_data_read_start(exch, &vols[i],
380 sizeof(hr_vol_info_t));
381 if (rc != EOK) {
382 async_exchange_end(exch);
383 async_forget(req);
384 goto error;
385 }
386 }
387
388 async_exchange_end(exch);
389 async_wait_for(req, &retval);
390 if (retval != EOK) {
391 rc = retval;
392 goto error;
393 }
394
395 if (size == 0) {
396 printf("no active volumes\n");
397 goto error;
398 }
399
400 for (i = 0; i < size; i++) {
401 rc = print_vol_info(i, &vols[i]);
402 if (rc != EOK)
403 goto error;
404 }
405
406error:
407 if (vols != NULL)
408 free(vols);
409 return rc;
410}
411
412const char *hr_get_vol_status_msg(hr_vol_status_t status)
413{
414 switch (status) {
415 case HR_VOL_NONE:
416 return "NONE/UNKNOWN";
417 case HR_VOL_ONLINE:
418 return "ONLINE";
419 case HR_VOL_FAULTY:
420 return "FAULTY";
421 case HR_VOL_DEGRADED:
422 return "DEGRADED";
423 case HR_VOL_REBUILD:
424 return "REBUILD";
425 default:
426 return "Invalid state value";
427 }
428}
429
430const char *hr_get_ext_status_msg(hr_ext_status_t status)
431{
432 switch (status) {
433 case HR_EXT_NONE:
434 return "NONE/UNKNOWN";
435 case HR_EXT_INVALID:
436 return "INVALID";
437 case HR_EXT_ONLINE:
438 return "ONLINE";
439 case HR_EXT_MISSING:
440 return "MISSING";
441 case HR_EXT_FAILED:
442 return "FAILED";
443 case HR_EXT_REBUILD:
444 return "REBUILD";
445 case HR_EXT_HOTSPARE:
446 return "HOTSPARE";
447 default:
448 return "Invalid state value";
449 }
450}
451
452const char *hr_get_layout_str(hr_layout_t layout)
453{
454 switch (layout) {
455 case HR_RLQ_NONE:
456 return "RAID layout not set";
457 case HR_RLQ_RAID4_0:
458 return "RAID-4 Non-Rotating Parity 0";
459 case HR_RLQ_RAID4_N:
460 return "RAID-4 Non-Rotating Parity N";
461 case HR_RLQ_RAID5_0R:
462 return "RAID-5 Rotating Parity 0 with Data Restart";
463 case HR_RLQ_RAID5_NR:
464 return "RAID-5 Rotating Parity N with Data Restart";
465 case HR_RLQ_RAID5_NC:
466 return "RAID-5 Rotating Parity N with Data Continuation";
467 default:
468 return "Invalid RAID layout";
469 }
470}
471
472const char *hr_get_metadata_type_str(hr_metadata_type_t type)
473{
474 switch (type) {
475 case HR_METADATA_NATIVE:
476 return "Native HelenRAID metadata";
477 case HR_METADATA_GEOM_MIRROR:
478 return "GEOM::MIRROR";
479 case HR_METADATA_GEOM_STRIPE:
480 return "GEOM::STRIPE";
481 default:
482 return "Invalid metadata type value";
483 }
484}
485
486/** @}
487 */
Note: See TracBrowser for help on using the repository browser.