Index: uspace/srv/ns/clonable.c =================================================================== --- uspace/srv/ns/clonable.c (revision b7fd2a02e4161f4edd38548e7f8456b8021549be) +++ uspace/srv/ns/clonable.c (revision a35b458e9db1ca95e679799dc7c1b12c83359ca3) @@ -84,22 +84,22 @@ return; } - + cs_req_t *csr = list_get_instance(req_link, cs_req_t, link); list_remove(req_link); - + /* Currently we can only handle a single type of clonable service. */ assert(csr->service == SERVICE_LOADER); - + async_answer_0(callid, EOK); - + async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE); if (sess == NULL) async_answer_0(callid, EIO); - + async_exch_t *exch = async_exchange_begin(sess); async_forward_fast(csr->callid, exch, csr->iface, csr->arg3, 0, IPC_FF_NONE); async_exchange_end(exch); - + free(csr); async_hangup(sess); @@ -120,5 +120,5 @@ { assert(service == SERVICE_LOADER); - + cs_req_t *csr = malloc(sizeof(cs_req_t)); if (csr == NULL) { @@ -126,8 +126,8 @@ return; } - + /* Spawn a loader. */ errno_t rc = loader_spawn("loader"); - + if (rc != EOK) { free(csr); @@ -135,5 +135,5 @@ return; } - + link_initialize(&csr->link); csr->service = service; @@ -141,5 +141,5 @@ csr->callid = callid; csr->arg3 = IPC_GET_ARG3(*call); - + /* * We can forward the call only after the server we spawned connects Index: uspace/srv/ns/ns.c =================================================================== --- uspace/srv/ns/ns.c (revision b7fd2a02e4161f4edd38548e7f8456b8021549be) +++ uspace/srv/ns/ns.c (revision a35b458e9db1ca95e679799dc7c1b12c83359ca3) @@ -69,25 +69,25 @@ return; } - + async_answer_0(iid, EOK); while (true) { process_pending_conn(); - + callid = async_get_call(&call); if (!IPC_GET_IMETHOD(call)) break; - + task_id_t id; errno_t retval; - + service_t service; sysarg_t phone; - + switch (IPC_GET_IMETHOD(call)) { case NS_REGISTER: service = IPC_GET_ARG1(call); phone = IPC_GET_ARG5(call); - + /* * Server requests service registration. @@ -99,5 +99,5 @@ retval = register_service(service, phone, &call); } - + break; case NS_PING: @@ -120,5 +120,5 @@ break; } - + async_answer_0(callid, retval); } @@ -130,22 +130,22 @@ { printf("%s: HelenOS IPC Naming Service\n", NAME); - + errno_t rc = service_init(); if (rc != EOK) return rc; - + rc = clonable_init(); if (rc != EOK) return rc; - + rc = task_init(); if (rc != EOK) return rc; - + async_set_fallback_port_handler(ns_connection, NULL); - + printf("%s: Accepting connections\n", NAME); async_manager(); - + /* Not reached */ return 0; Index: uspace/srv/ns/service.c =================================================================== --- uspace/srv/ns/service.c (revision b7fd2a02e4161f4edd38548e7f8456b8021549be) +++ uspace/srv/ns/service.c (revision a35b458e9db1ca95e679799dc7c1b12c83359ca3) @@ -43,8 +43,8 @@ typedef struct { ht_link_t link; - + /** Service ID */ service_t service; - + /** Session to the service */ async_sess_t *sess; @@ -60,5 +60,5 @@ hashed_service_t *service = hash_table_get_inst(item, hashed_service_t, link); - + return service->service; } @@ -68,5 +68,5 @@ hashed_service_t *service = hash_table_get_inst(item, hashed_service_t, link); - + return service->service == *(service_t *) key; } @@ -102,7 +102,7 @@ return ENOMEM; } - + list_initialize(&pending_conn); - + return EOK; } @@ -116,5 +116,5 @@ if (!link) continue; - + hashed_service_t *hashed_service = hash_table_get_inst(link, hashed_service_t, link); async_exch_t *exch = async_exchange_begin(hashed_service->sess); @@ -122,8 +122,8 @@ pending->arg3, 0, IPC_FF_NONE); async_exchange_end(exch); - + list_remove(&pending->link); free(pending); - + goto loop; } @@ -143,15 +143,15 @@ if (hash_table_find(&service_hash_table, &service)) return EEXIST; - + hashed_service_t *hashed_service = (hashed_service_t *) malloc(sizeof(hashed_service_t)); if (!hashed_service) return ENOMEM; - + hashed_service->service = service; hashed_service->sess = async_callback_receive(EXCHANGE_SERIALIZE); if (hashed_service->sess == NULL) return EIO; - + hash_table_insert(&service_hash_table, &hashed_service->link); return EOK; @@ -174,5 +174,5 @@ sysarg_t flags = IPC_GET_ARG4(*call); errno_t retval; - + ht_link_t *link = hash_table_find(&service_hash_table, &service); if (!link) { @@ -185,5 +185,5 @@ goto out; } - + link_initialize(&pending->link); pending->service = service; @@ -191,13 +191,13 @@ pending->callid = callid; pending->arg3 = arg3; - + list_append(&pending->link, &pending_conn); return; } - + retval = ENOENT; goto out; } - + hashed_service_t *hashed_service = hash_table_get_inst(link, hashed_service_t, link); async_exch_t *exch = async_exchange_begin(hashed_service->sess); @@ -205,5 +205,5 @@ async_exchange_end(exch); return; - + out: async_answer_0(callid, retval); Index: uspace/srv/ns/task.c =================================================================== --- uspace/srv/ns/task.c (revision b7fd2a02e4161f4edd38548e7f8456b8021549be) +++ uspace/srv/ns/task.c (revision a35b458e9db1ca95e679799dc7c1b12c83359ca3) @@ -48,5 +48,5 @@ typedef struct { ht_link_t link; - + task_id_t id; /**< Task ID. */ bool finished; /**< Task is done. */ @@ -115,5 +115,5 @@ sysarg_t in_phone_hash = *(sysarg_t*)key; p2i_entry_t *entry = hash_table_get_inst(item, p2i_entry_t, link); - + return (in_phone_hash == entry->in_phone_hash); } @@ -157,10 +157,10 @@ return ENOMEM; } - + if (!hash_table_create(&phone_to_id, 0, 0, &p2i_ops)) { printf(NAME ": No memory available for tasks\n"); return ENOMEM; } - + list_initialize(&pending_wait); return EOK; @@ -171,5 +171,5 @@ { task_exit_t texit; - + loop: list_foreach(pending_wait, link, pending_wait_t, pr) { @@ -177,13 +177,13 @@ if (!link) continue; - + hashed_task_t *ht = hash_table_get_inst(link, hashed_task_t, link); if (!ht->finished) continue; - + texit = ht->have_rval ? TASK_EXIT_NORMAL : TASK_EXIT_UNEXPECTED; async_answer_2(pr->callid, EOK, texit, ht->retval); - + list_remove(&pr->link); free(pr); @@ -197,5 +197,5 @@ hashed_task_t *ht = (link != NULL) ? hash_table_get_inst(link, hashed_task_t, link) : NULL; - + if (ht == NULL) { /* No such task exists. */ @@ -203,5 +203,5 @@ return; } - + if (ht->finished) { task_exit_t texit = ht->have_rval ? TASK_EXIT_NORMAL : @@ -210,5 +210,5 @@ return; } - + /* Add to pending list */ pending_wait_t *pr = @@ -218,5 +218,5 @@ return; } - + link_initialize(&pr->link); pr->id = id; @@ -228,13 +228,13 @@ { task_id_t id = MERGE_LOUP32(IPC_GET_ARG1(*call), IPC_GET_ARG2(*call)); - + ht_link_t *link = hash_table_find(&phone_to_id, &call->in_phone_hash); if (link != NULL) return EEXIST; - + p2i_entry_t *entry = (p2i_entry_t *) malloc(sizeof(p2i_entry_t)); if (entry == NULL) return ENOMEM; - + hashed_task_t *ht = (hashed_task_t *) malloc(sizeof(hashed_task_t)); if (ht == NULL) { @@ -242,17 +242,17 @@ return ENOMEM; } - + /* * Insert into the phone-to-id map. */ - + entry->in_phone_hash = call->in_phone_hash; entry->id = id; hash_table_insert(&phone_to_id, &entry->link); - + /* * Insert into the main table. */ - + ht->id = id; ht->finished = false; @@ -260,5 +260,5 @@ ht->retval = -1; hash_table_insert(&task_hash_table, &ht->link); - + return EOK; } @@ -269,8 +269,8 @@ if (link == NULL) return ENOENT; - + p2i_entry_t *entry = hash_table_get_inst(link, p2i_entry_t, link); *id = entry->id; - + return EOK; } @@ -279,18 +279,18 @@ { task_id_t id = call->in_task_id; - + ht_link_t *link = hash_table_find(&task_hash_table, &id); hashed_task_t *ht = (link != NULL) ? hash_table_get_inst(link, hashed_task_t, link) : NULL; - + if ((ht == NULL) || (ht->finished)) return EINVAL; - + ht->finished = true; ht->have_rval = true; ht->retval = IPC_GET_ARG1(*call); - + process_pending_wait(); - + return EOK; } @@ -302,8 +302,8 @@ if (rc != EOK) return rc; - + /* Delete from phone-to-id map. */ hash_table_remove(&phone_to_id, &call->in_phone_hash); - + /* Mark task as finished. */ ht_link_t *link = hash_table_find(&task_hash_table, &id); @@ -312,10 +312,10 @@ hashed_task_t *ht = hash_table_get_inst(link, hashed_task_t, link); - + ht->finished = true; - + process_pending_wait(); hash_table_remove(&task_hash_table, &id); - + return EOK; }