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 hr
|
---|
30 | * @{
|
---|
31 | */
|
---|
32 | /**
|
---|
33 | * @file
|
---|
34 | */
|
---|
35 |
|
---|
36 | #include <async.h>
|
---|
37 | #include <bd_srv.h>
|
---|
38 | #include <errno.h>
|
---|
39 | #include <hr.h>
|
---|
40 | #include <io/log.h>
|
---|
41 | #include <inttypes.h>
|
---|
42 | #include <ipc/hr.h>
|
---|
43 | #include <ipc/services.h>
|
---|
44 | #include <loc.h>
|
---|
45 | #include <task.h>
|
---|
46 | #include <stdatomic.h>
|
---|
47 | #include <stdio.h>
|
---|
48 | #include <stdlib.h>
|
---|
49 | #include <str.h>
|
---|
50 | #include <str_error.h>
|
---|
51 |
|
---|
52 | #include "fge.h"
|
---|
53 | #include "io.h"
|
---|
54 | #include "superblock.h"
|
---|
55 | #include "util.h"
|
---|
56 | #include "var.h"
|
---|
57 |
|
---|
58 | loc_srv_t *hr_srv;
|
---|
59 |
|
---|
60 | static fibril_mutex_t hr_volumes_lock;
|
---|
61 | static list_t hr_volumes;
|
---|
62 |
|
---|
63 | static service_id_t ctl_sid;
|
---|
64 |
|
---|
65 | static hr_volume_t *hr_get_volume(service_id_t svc_id)
|
---|
66 | {
|
---|
67 | HR_DEBUG("hr_get_volume(): (%" PRIun ")\n", svc_id);
|
---|
68 |
|
---|
69 | fibril_mutex_lock(&hr_volumes_lock);
|
---|
70 | list_foreach(hr_volumes, lvolumes, hr_volume_t, vol) {
|
---|
71 | if (vol->svc_id == svc_id) {
|
---|
72 | fibril_mutex_unlock(&hr_volumes_lock);
|
---|
73 | return vol;
|
---|
74 | }
|
---|
75 | }
|
---|
76 |
|
---|
77 | fibril_mutex_unlock(&hr_volumes_lock);
|
---|
78 | return NULL;
|
---|
79 | }
|
---|
80 |
|
---|
81 | static errno_t hr_remove_volume(service_id_t svc_id)
|
---|
82 | {
|
---|
83 | HR_DEBUG("hr_remove_volume(): (%" PRIun ")\n", svc_id);
|
---|
84 |
|
---|
85 | fibril_mutex_lock(&hr_volumes_lock);
|
---|
86 | list_foreach(hr_volumes, lvolumes, hr_volume_t, vol) {
|
---|
87 | if (vol->svc_id == svc_id) {
|
---|
88 | hr_fpool_destroy(vol->fge);
|
---|
89 | hr_fini_devs(vol);
|
---|
90 | list_remove(&vol->lvolumes);
|
---|
91 | free(vol);
|
---|
92 | fibril_mutex_unlock(&hr_volumes_lock);
|
---|
93 | return EOK;
|
---|
94 | }
|
---|
95 | }
|
---|
96 |
|
---|
97 | fibril_mutex_unlock(&hr_volumes_lock);
|
---|
98 | return ENOENT;
|
---|
99 | }
|
---|
100 |
|
---|
101 | static void hr_create_srv(ipc_call_t *icall, bool assemble)
|
---|
102 | {
|
---|
103 | HR_DEBUG("hr_create_srv()\n");
|
---|
104 |
|
---|
105 | errno_t rc;
|
---|
106 | size_t i, size;
|
---|
107 | hr_config_t *cfg;
|
---|
108 | hr_volume_t *new_volume;
|
---|
109 | ipc_call_t call;
|
---|
110 |
|
---|
111 | if (!async_data_write_receive(&call, &size)) {
|
---|
112 | async_answer_0(&call, EREFUSED);
|
---|
113 | async_answer_0(icall, EREFUSED);
|
---|
114 | return;
|
---|
115 | }
|
---|
116 |
|
---|
117 | if (size != sizeof(hr_config_t)) {
|
---|
118 | async_answer_0(&call, EINVAL);
|
---|
119 | async_answer_0(icall, EINVAL);
|
---|
120 | return;
|
---|
121 | }
|
---|
122 |
|
---|
123 | cfg = calloc(1, sizeof(hr_config_t));
|
---|
124 | if (cfg == NULL) {
|
---|
125 | async_answer_0(&call, ENOMEM);
|
---|
126 | async_answer_0(icall, ENOMEM);
|
---|
127 | return;
|
---|
128 | }
|
---|
129 |
|
---|
130 | rc = async_data_write_finalize(&call, cfg, size);
|
---|
131 | if (rc != EOK) {
|
---|
132 | free(cfg);
|
---|
133 | async_answer_0(&call, rc);
|
---|
134 | async_answer_0(icall, rc);
|
---|
135 | return;
|
---|
136 | }
|
---|
137 |
|
---|
138 | /*
|
---|
139 | * If there was a missing device provided
|
---|
140 | * for creation of a new array, abort
|
---|
141 | */
|
---|
142 | if (!assemble) {
|
---|
143 | for (i = 0; i < cfg->dev_no; i++) {
|
---|
144 | if (cfg->devs[i] == 0) {
|
---|
145 | HR_ERROR("missing device provided for array "
|
---|
146 | "creation, aborting");
|
---|
147 | free(cfg);
|
---|
148 | async_answer_0(icall, EINVAL);
|
---|
149 | return;
|
---|
150 | }
|
---|
151 | }
|
---|
152 | }
|
---|
153 |
|
---|
154 | new_volume = calloc(1, sizeof(hr_volume_t));
|
---|
155 | if (new_volume == NULL) {
|
---|
156 | free(cfg);
|
---|
157 | async_answer_0(icall, ENOMEM);
|
---|
158 | return;
|
---|
159 | }
|
---|
160 |
|
---|
161 | hr_fpool_t *fge = hr_fpool_create(16, 32, sizeof(hr_io_t));
|
---|
162 | if (fge == NULL) {
|
---|
163 | free(new_volume);
|
---|
164 | free(cfg);
|
---|
165 | async_answer_0(icall, ENOMEM);
|
---|
166 | return;
|
---|
167 | }
|
---|
168 | new_volume->fge = fge;
|
---|
169 |
|
---|
170 | str_cpy(new_volume->devname, HR_DEVNAME_LEN, cfg->devname);
|
---|
171 | for (i = 0; i < cfg->dev_no; i++)
|
---|
172 | new_volume->extents[i].svc_id = cfg->devs[i];
|
---|
173 | new_volume->level = cfg->level;
|
---|
174 | new_volume->extent_no = cfg->dev_no;
|
---|
175 |
|
---|
176 | if (assemble) {
|
---|
177 | if (cfg->level != HR_LVL_UNKNOWN)
|
---|
178 | HR_WARN("level manually set when assembling, ingoring");
|
---|
179 | new_volume->level = HR_LVL_UNKNOWN;
|
---|
180 | }
|
---|
181 |
|
---|
182 | rc = hr_init_devs(new_volume);
|
---|
183 | if (rc != EOK) {
|
---|
184 | free(cfg);
|
---|
185 | free(new_volume);
|
---|
186 | async_answer_0(icall, rc);
|
---|
187 | return;
|
---|
188 | }
|
---|
189 |
|
---|
190 | if (assemble) {
|
---|
191 | /* just bsize needed for reading metadata later */
|
---|
192 | rc = hr_check_devs(new_volume, NULL, &new_volume->bsize);
|
---|
193 | if (rc != EOK)
|
---|
194 | goto error;
|
---|
195 |
|
---|
196 | rc = hr_fill_vol_from_meta(new_volume);
|
---|
197 | if (rc != EOK)
|
---|
198 | goto error;
|
---|
199 | }
|
---|
200 |
|
---|
201 | switch (new_volume->level) {
|
---|
202 | case HR_LVL_1:
|
---|
203 | if (!assemble)
|
---|
204 | new_volume->layout = 0x00; /* XXX: yet unused */
|
---|
205 | new_volume->hr_ops.create = hr_raid1_create;
|
---|
206 | new_volume->hr_ops.init = hr_raid1_init;
|
---|
207 | new_volume->hr_ops.status_event = hr_raid1_status_event;
|
---|
208 | new_volume->hr_ops.add_hotspare = hr_raid1_add_hotspare;
|
---|
209 | break;
|
---|
210 | case HR_LVL_0:
|
---|
211 | if (!assemble)
|
---|
212 | new_volume->layout = 0x00;
|
---|
213 | new_volume->hr_ops.create = hr_raid0_create;
|
---|
214 | new_volume->hr_ops.init = hr_raid0_init;
|
---|
215 | new_volume->hr_ops.status_event = hr_raid0_status_event;
|
---|
216 | break;
|
---|
217 | case HR_LVL_4:
|
---|
218 | if (!assemble)
|
---|
219 | new_volume->layout = HR_RLQ_RAID4_N;
|
---|
220 | new_volume->hr_ops.create = hr_raid5_create;
|
---|
221 | new_volume->hr_ops.init = hr_raid5_init;
|
---|
222 | new_volume->hr_ops.status_event = hr_raid5_status_event;
|
---|
223 | new_volume->hr_ops.add_hotspare = hr_raid5_add_hotspare;
|
---|
224 | break;
|
---|
225 | case HR_LVL_5:
|
---|
226 | if (!assemble)
|
---|
227 | new_volume->layout = HR_RLQ_RAID5_NR;
|
---|
228 | new_volume->hr_ops.create = hr_raid5_create;
|
---|
229 | new_volume->hr_ops.init = hr_raid5_init;
|
---|
230 | new_volume->hr_ops.status_event = hr_raid5_status_event;
|
---|
231 | new_volume->hr_ops.add_hotspare = hr_raid5_add_hotspare;
|
---|
232 | break;
|
---|
233 | default:
|
---|
234 | HR_ERROR("unkown level: %d, aborting\n", new_volume->level);
|
---|
235 | rc = EINVAL;
|
---|
236 | goto error;
|
---|
237 | }
|
---|
238 |
|
---|
239 | if (!assemble) {
|
---|
240 | new_volume->hr_ops.init(new_volume);
|
---|
241 | if (rc != EOK)
|
---|
242 | goto error;
|
---|
243 |
|
---|
244 | rc = hr_write_meta_to_vol(new_volume);
|
---|
245 | if (rc != EOK)
|
---|
246 | goto error;
|
---|
247 | }
|
---|
248 |
|
---|
249 | fibril_mutex_initialize(&new_volume->lock); /* XXX: will remove this */
|
---|
250 |
|
---|
251 | fibril_mutex_initialize(&new_volume->halt_lock);
|
---|
252 | new_volume->halt_please = false;
|
---|
253 |
|
---|
254 | fibril_rwlock_initialize(&new_volume->extents_lock);
|
---|
255 | fibril_rwlock_initialize(&new_volume->states_lock);
|
---|
256 |
|
---|
257 | fibril_mutex_initialize(&new_volume->hotspare_lock);
|
---|
258 |
|
---|
259 | list_initialize(&new_volume->range_lock_list);
|
---|
260 | fibril_mutex_initialize(&new_volume->range_lock_list_lock);
|
---|
261 |
|
---|
262 | atomic_init(&new_volume->rebuild_blk, 0);
|
---|
263 |
|
---|
264 | rc = new_volume->hr_ops.create(new_volume);
|
---|
265 | if (rc != EOK)
|
---|
266 | goto error;
|
---|
267 |
|
---|
268 | fibril_mutex_lock(&hr_volumes_lock);
|
---|
269 | list_append(&new_volume->lvolumes, &hr_volumes);
|
---|
270 | fibril_mutex_unlock(&hr_volumes_lock);
|
---|
271 |
|
---|
272 | if (assemble) {
|
---|
273 | HR_DEBUG("assembled volume \"%s\" (%" PRIun ")\n",
|
---|
274 | new_volume->devname, new_volume->svc_id);
|
---|
275 | } else {
|
---|
276 | HR_DEBUG("created volume \"%s\" (%" PRIun ")\n",
|
---|
277 | new_volume->devname, new_volume->svc_id);
|
---|
278 | }
|
---|
279 |
|
---|
280 | free(cfg);
|
---|
281 | async_answer_0(icall, rc);
|
---|
282 | return;
|
---|
283 | error:
|
---|
284 | free(cfg);
|
---|
285 | free(fge);
|
---|
286 | hr_fini_devs(new_volume);
|
---|
287 | free(new_volume);
|
---|
288 | async_answer_0(icall, rc);
|
---|
289 | }
|
---|
290 |
|
---|
291 | static void hr_stop_srv(ipc_call_t *icall)
|
---|
292 | {
|
---|
293 | HR_DEBUG("hr_stop_srv()\n");
|
---|
294 |
|
---|
295 | errno_t rc = EOK;
|
---|
296 | service_id_t svc_id;
|
---|
297 | long fail_extent;
|
---|
298 | hr_volume_t *vol;
|
---|
299 |
|
---|
300 | svc_id = ipc_get_arg1(icall);
|
---|
301 | fail_extent = (long)ipc_get_arg2(icall);
|
---|
302 |
|
---|
303 | vol = hr_get_volume(svc_id);
|
---|
304 | if (vol == NULL) {
|
---|
305 | async_answer_0(icall, ENOENT);
|
---|
306 | return;
|
---|
307 | }
|
---|
308 |
|
---|
309 | if (fail_extent == -1) {
|
---|
310 | rc = hr_remove_volume(svc_id);
|
---|
311 | if (rc != EOK) {
|
---|
312 | async_answer_0(icall, rc);
|
---|
313 | return;
|
---|
314 | }
|
---|
315 | rc = loc_service_unregister(hr_srv, svc_id);
|
---|
316 | } else {
|
---|
317 | fibril_rwlock_write_lock(&vol->states_lock);
|
---|
318 | fibril_rwlock_read_lock(&vol->extents_lock);
|
---|
319 | hr_update_ext_status(vol, fail_extent, HR_EXT_FAILED);
|
---|
320 | fibril_rwlock_read_unlock(&vol->extents_lock);
|
---|
321 | fibril_rwlock_write_unlock(&vol->states_lock);
|
---|
322 |
|
---|
323 | vol->hr_ops.status_event(vol);
|
---|
324 | }
|
---|
325 | async_answer_0(icall, rc);
|
---|
326 | }
|
---|
327 |
|
---|
328 | static void hr_add_hotspare_srv(ipc_call_t *icall)
|
---|
329 | {
|
---|
330 | HR_DEBUG("hr_add_hotspare()\n");
|
---|
331 |
|
---|
332 | errno_t rc = EOK;
|
---|
333 | service_id_t vol_svc_id;
|
---|
334 | service_id_t hotspare;
|
---|
335 | hr_volume_t *vol;
|
---|
336 |
|
---|
337 | vol_svc_id = ipc_get_arg1(icall);
|
---|
338 | hotspare = ipc_get_arg2(icall);
|
---|
339 |
|
---|
340 | vol = hr_get_volume(vol_svc_id);
|
---|
341 | if (vol == NULL) {
|
---|
342 | async_answer_0(icall, ENOENT);
|
---|
343 | return;
|
---|
344 | }
|
---|
345 |
|
---|
346 | if (vol->hr_ops.add_hotspare == NULL) {
|
---|
347 | HR_DEBUG("hr_add_hotspare(): not supported on RAID level %d\n",
|
---|
348 | vol->level);
|
---|
349 | async_answer_0(icall, ENOTSUP);
|
---|
350 | return;
|
---|
351 | }
|
---|
352 |
|
---|
353 | rc = vol->hr_ops.add_hotspare(vol, hotspare);
|
---|
354 |
|
---|
355 | async_answer_0(icall, rc);
|
---|
356 | }
|
---|
357 |
|
---|
358 | static void hr_print_status_srv(ipc_call_t *icall)
|
---|
359 | {
|
---|
360 | HR_DEBUG("hr_status_srv()\n");
|
---|
361 |
|
---|
362 | errno_t rc;
|
---|
363 | size_t vol_cnt = 0;
|
---|
364 | hr_vol_info_t info;
|
---|
365 | ipc_call_t call;
|
---|
366 | size_t size;
|
---|
367 |
|
---|
368 | fibril_mutex_lock(&hr_volumes_lock);
|
---|
369 |
|
---|
370 | vol_cnt = list_count(&hr_volumes);
|
---|
371 |
|
---|
372 | if (!async_data_read_receive(&call, &size)) {
|
---|
373 | rc = EREFUSED;
|
---|
374 | goto error;
|
---|
375 | }
|
---|
376 |
|
---|
377 | if (size != sizeof(size_t)) {
|
---|
378 | rc = EINVAL;
|
---|
379 | goto error;
|
---|
380 | }
|
---|
381 |
|
---|
382 | rc = async_data_read_finalize(&call, &vol_cnt, size);
|
---|
383 | if (rc != EOK)
|
---|
384 | goto error;
|
---|
385 |
|
---|
386 | list_foreach(hr_volumes, lvolumes, hr_volume_t, vol) {
|
---|
387 | memcpy(info.extents, vol->extents,
|
---|
388 | sizeof(hr_extent_t) * HR_MAX_EXTENTS);
|
---|
389 | memcpy(info.hotspares, vol->hotspares,
|
---|
390 | sizeof(hr_extent_t) * HR_MAX_HOTSPARES);
|
---|
391 | info.svc_id = vol->svc_id;
|
---|
392 | info.extent_no = vol->extent_no;
|
---|
393 | info.hotspare_no = vol->hotspare_no;
|
---|
394 | info.level = vol->level;
|
---|
395 | /* print usable number of blocks */
|
---|
396 | info.nblocks = vol->data_blkno;
|
---|
397 | info.strip_size = vol->strip_size;
|
---|
398 | info.bsize = vol->bsize;
|
---|
399 | info.status = vol->status;
|
---|
400 | info.layout = vol->layout;
|
---|
401 |
|
---|
402 | if (!async_data_read_receive(&call, &size)) {
|
---|
403 | rc = EREFUSED;
|
---|
404 | goto error;
|
---|
405 | }
|
---|
406 |
|
---|
407 | if (size != sizeof(hr_vol_info_t)) {
|
---|
408 | rc = EINVAL;
|
---|
409 | goto error;
|
---|
410 | }
|
---|
411 |
|
---|
412 | rc = async_data_read_finalize(&call, &info, size);
|
---|
413 | if (rc != EOK)
|
---|
414 | goto error;
|
---|
415 | }
|
---|
416 |
|
---|
417 | fibril_mutex_unlock(&hr_volumes_lock);
|
---|
418 | async_answer_0(icall, EOK);
|
---|
419 | return;
|
---|
420 | error:
|
---|
421 | fibril_mutex_unlock(&hr_volumes_lock);
|
---|
422 | async_answer_0(&call, rc);
|
---|
423 | async_answer_0(icall, rc);
|
---|
424 | }
|
---|
425 |
|
---|
426 | static void hr_ctl_conn(ipc_call_t *icall, void *arg)
|
---|
427 | {
|
---|
428 | HR_DEBUG("hr_ctl_conn()\n");
|
---|
429 |
|
---|
430 | async_accept_0(icall);
|
---|
431 |
|
---|
432 | while (true) {
|
---|
433 | ipc_call_t call;
|
---|
434 | async_get_call(&call);
|
---|
435 | sysarg_t method = ipc_get_imethod(&call);
|
---|
436 |
|
---|
437 | if (!method) {
|
---|
438 | async_answer_0(&call, EOK);
|
---|
439 | return;
|
---|
440 | }
|
---|
441 |
|
---|
442 | switch (method) {
|
---|
443 | case HR_CREATE:
|
---|
444 | hr_create_srv(&call, false);
|
---|
445 | break;
|
---|
446 | case HR_ASSEMBLE:
|
---|
447 | hr_create_srv(&call, true);
|
---|
448 | break;
|
---|
449 | case HR_STOP:
|
---|
450 | hr_stop_srv(&call);
|
---|
451 | break;
|
---|
452 | case HR_ADD_HOTSPARE:
|
---|
453 | hr_add_hotspare_srv(&call);
|
---|
454 | break;
|
---|
455 | case HR_STATUS:
|
---|
456 | hr_print_status_srv(&call);
|
---|
457 | break;
|
---|
458 | default:
|
---|
459 | async_answer_0(&call, EINVAL);
|
---|
460 | }
|
---|
461 | }
|
---|
462 | }
|
---|
463 |
|
---|
464 | static void hr_client_conn(ipc_call_t *icall, void *arg)
|
---|
465 | {
|
---|
466 | HR_DEBUG("hr_client_conn()\n");
|
---|
467 |
|
---|
468 | hr_volume_t *vol;
|
---|
469 |
|
---|
470 | service_id_t svc_id = ipc_get_arg2(icall);
|
---|
471 |
|
---|
472 | if (svc_id == ctl_sid) {
|
---|
473 | hr_ctl_conn(icall, arg);
|
---|
474 | } else {
|
---|
475 | HR_DEBUG("bd_conn()\n");
|
---|
476 | vol = hr_get_volume(svc_id);
|
---|
477 | if (vol == NULL)
|
---|
478 | async_answer_0(icall, EINVAL);
|
---|
479 | bd_conn(icall, &vol->hr_bds);
|
---|
480 | }
|
---|
481 | }
|
---|
482 |
|
---|
483 | int main(int argc, char **argv)
|
---|
484 | {
|
---|
485 | errno_t rc;
|
---|
486 |
|
---|
487 | printf("%s: HelenRAID server\n", NAME);
|
---|
488 |
|
---|
489 | rc = log_init(NAME);
|
---|
490 | if (rc != EOK) {
|
---|
491 | printf("%s: failed to initialize logging\n", NAME);
|
---|
492 | return 1;
|
---|
493 | }
|
---|
494 |
|
---|
495 | fibril_mutex_initialize(&hr_volumes_lock);
|
---|
496 | list_initialize(&hr_volumes);
|
---|
497 |
|
---|
498 | async_set_fallback_port_handler(hr_client_conn, NULL);
|
---|
499 |
|
---|
500 | rc = loc_server_register(NAME, &hr_srv);
|
---|
501 | if (rc != EOK) {
|
---|
502 | HR_ERROR("failed registering server: %s", str_error(rc));
|
---|
503 | return EEXIST;
|
---|
504 | }
|
---|
505 |
|
---|
506 | rc = loc_service_register(hr_srv, SERVICE_NAME_HR, &ctl_sid);
|
---|
507 | if (rc != EOK) {
|
---|
508 | HR_ERROR("failed registering service: %s", str_error(rc));
|
---|
509 | return EEXIST;
|
---|
510 | }
|
---|
511 |
|
---|
512 | printf("%s: accepting connections\n", NAME);
|
---|
513 | task_retval(0);
|
---|
514 | async_manager();
|
---|
515 |
|
---|
516 | return 0;
|
---|
517 | }
|
---|
518 |
|
---|
519 | /** @}
|
---|
520 | */
|
---|