Changeset b4ca0a9c in mainline for uspace/srv

Timestamp:

2012-07-10T11:53:50Z (13 years ago)

Author:

Vojtech Horky <vojtechhorky@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

1e01a35

Parents:

a33706e (diff), 33fc3ae (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge mainline changes

Location:

uspace/srv

Files:

• bd/ata_bd/ata_bd.c (modified) (3 diffs)
• bd/file_bd/file_bd.c (modified) (3 diffs)
• bd/gxe_bd/gxe_bd.c (modified) (2 diffs)
• bd/part/guid_part/guid_part.c (modified) (2 diffs)
• bd/part/mbr_part/mbr_part.c (modified) (1 diff)
• bd/rd/rd.c (modified) (2 diffs)
• clipboard/clipboard.c (modified) (1 diff)
• devman/devman.h (modified) (1 diff)
• devman/main.c (modified) (15 diffs)
• fs/fat/fat_dentry.c (modified) (1 diff)
• hid/console/console.c (modified) (1 diff)
• hid/fb/fb.c (modified) (3 diffs)
• hid/input/ctl/kbdev.c (modified) (6 diffs)
• hid/input/generic/input.c (modified) (2 diffs)
• hid/input/port/adb.c (modified) (3 diffs)
• hid/input/proto/mousedev.c (modified) (4 diffs)
• hid/remcons/remcons.c (modified) (5 diffs)
• hid/remcons/telnet.h (modified) (1 diff)
• hid/remcons/user.h (modified) (1 diff)
• hid/s3c24xx_ts/s3c24xx_ts.c (modified) (1 diff)
• hw/char/s3c24xx_uart/s3c24xx_uart.c (modified) (1 diff)
• loader/main.c (modified) (1 diff)
• locsrv/locsrv.c (modified) (4 diffs)
• locsrv/locsrv.h (modified) (1 diff)
• net/ethip/ethip.c (modified) (1 diff)
• net/ethip/ethip_nic.c (modified) (4 diffs)
• net/inetsrv/inetsrv.c (modified) (4 diffs)
• net/loopip/loopip.c (modified) (1 diff)
• net/tcp/sock.c (modified) (2 diffs)
• net/udp/sock.c (modified) (21 diffs)
• net/udp/udp.c (modified) (1 diff)
• net/udp/udp_type.h (modified) (2 diffs)
• ns/ns.c (modified) (1 diff)
• vfs/vfs.c (modified) (5 diffs)

uspace/srv/bd/ata_bd/ata_bd.c

@@ -191 +191 @@
         }
 
-        printf(NAME ": Accepting connections\n");
+        printf("%s: Accepting connections\n", NAME);
         task_retval(0);
         async_manager();
@@ -243 +243 @@
 static int ata_bd_init(void)
 {
+        async_set_client_connection(ata_bd_connection);
+        int rc = loc_server_register(NAME);
+        if (rc != EOK) {
+                printf("%s: Unable to register driver.\n", NAME);
+                return rc;
+        }
+        
         void *vaddr;
-        int rc;
-        
-        async_set_client_connection(ata_bd_connection);
-        rc = loc_server_register(NAME);
-        if (rc < 0) {
-                printf(NAME ": Unable to register driver.\n");
-                return rc;
-        }
-
         rc = pio_enable((void *) cmd_physical, sizeof(ata_cmd_t), &vaddr);
         if (rc != EOK) {
-                printf(NAME ": Could not initialize device I/O space.\n");
+                printf("%s: Could not initialize device I/O space.\n", NAME);
                 return rc;
         }
-
+        
         cmd = vaddr;
-
+        
         rc = pio_enable((void *) ctl_physical, sizeof(ata_ctl_t), &vaddr);
         if (rc != EOK) {
-                printf(NAME ": Could not initialize device I/O space.\n");
+                printf("%s: Could not initialize device I/O space.\n", NAME);
                 return rc;
         }
-
+        
         ctl = vaddr;
-
-
+        
         return EOK;
 }
@@ -311 +308 @@
 
         (void) async_share_out_finalize(callid, &fs_va);
-        if (fs_va == (void *) -1) {
+        if (fs_va == AS_MAP_FAILED) {
                 async_answer_0(callid, EHANGUP);
                 return;

uspace/srv/bd/file_bd/file_bd.c

@@ -119 +119 @@
         rc = loc_service_register(device_name, &service_id);
         if (rc != EOK) {
-                printf(NAME ": Unable to register device '%s'.\n",
-                        device_name);
+                printf("%s: Unable to register device '%s'.\n",
+                    NAME, device_name);
                 return rc;
         }
-
-        printf(NAME ": Accepting connections\n");
+        
+        printf("%s: Accepting connections\n", NAME);
         task_retval(0);
         async_manager();
-
+        
         /* Not reached */
         return 0;
@@ -139 +139 @@
 static int file_bd_init(const char *fname)
 {
-        int rc;
-        long img_size;
-        
         async_set_client_connection(file_bd_connection);
-        rc = loc_server_register(NAME);
-        if (rc < 0) {
-                printf(NAME ": Unable to register driver.\n");
+        int rc = loc_server_register(NAME);
+        if (rc != EOK) {
+                printf("%s: Unable to register driver.\n", NAME);
                 return rc;
         }
-
+        
         img = fopen(fname, "rb+");
         if (img == NULL)
                 return EINVAL;
-
+        
         if (fseek(img, 0, SEEK_END) != 0) {
                 fclose(img);
                 return EIO;
         }
-
-        img_size = ftell(img);
+        
+        off64_t img_size = ftell(img);
         if (img_size < 0) {
                 fclose(img);
                 return EIO;
         }
-
+        
         num_blocks = img_size / block_size;
-
+        
         fibril_mutex_initialize(&dev_lock);
-
+        
         return EOK;
 }
@@ -192 +189 @@
 
         (void) async_share_out_finalize(callid, &fs_va);
-        if (fs_va == (void *) -1) {
+        if (fs_va == AS_MAP_FAILED) {
                 async_answer_0(callid, EHANGUP);
                 return;

uspace/srv/bd/gxe_bd/gxe_bd.c

@@ -122 +122 @@
 static int gxe_bd_init(void)
 {
+        async_set_client_connection(gxe_bd_connection);
+        int rc = loc_server_register(NAME);
+        if (rc != EOK) {
+                printf("%s: Unable to register driver.\n", NAME);
+                return rc;
+        }
+        
         void *vaddr;
-        int rc, i;
-        char name[16];
-        
-        async_set_client_connection(gxe_bd_connection);
-        rc = loc_server_register(NAME);
-        if (rc < 0) {
-                printf(NAME ": Unable to register driver.\n");
-                return rc;
-        }
-
         rc = pio_enable((void *) dev_physical, sizeof(gxe_bd_t), &vaddr);
         if (rc != EOK) {
-                printf(NAME ": Could not initialize device I/O space.\n");
+                printf("%s: Could not initialize device I/O space.\n", NAME);
                 return rc;
         }
-
+        
         dev = vaddr;
-
-        for (i = 0; i < MAX_DISKS; i++) {
-                snprintf(name, 16, "%s/disk%d", NAMESPACE, i);
+        
+        for (unsigned int i = 0; i < MAX_DISKS; i++) {
+                char name[16];
+                
+                snprintf(name, 16, "%s/disk%u", NAMESPACE, i);
                 rc = loc_service_register(name, &service_id[i]);
                 if (rc != EOK) {
-                        printf(NAME ": Unable to register device %s.\n", name);
+                        printf("%s: Unable to register device %s.\n", NAME,
+                            name);
                         return rc;
                 }
+                
                 fibril_mutex_initialize(&dev_lock[i]);
         }
-
+        
         return EOK;
 }
@@ -195 +196 @@
 
         (void) async_share_out_finalize(callid, &fs_va);
-        if (fs_va == (void *) -1) {
+        if (fs_va == AS_MAP_FAILED) {
                 async_answer_0(callid, EHANGUP);
                 return;

uspace/srv/bd/part/guid_part/guid_part.c

@@ -170 +170 @@
                 return rc;
         }
-
+        
         /*
          * Create partition devices.
@@ -350 +350 @@
 
         (void) async_share_out_finalize(callid, &fs_va);
-        if (fs_va == (void *) -1) {
+        if (fs_va == AS_MAP_FAILED) {
                 async_answer_0(callid, EHANGUP);
                 return;

uspace/srv/bd/part/mbr_part/mbr_part.c

@@ -427 +427 @@
 
         (void) async_share_out_finalize(callid, &fs_va);
-        if (fs_va == (void *) -1) {
+        if (fs_va == AS_MAP_FAILED) {
                 async_answer_0(callid, EHANGUP);
                 return;

uspace/srv/bd/rd/rd.c

@@ -106 +106 @@
         if (async_share_out_receive(&callid, &comm_size, &flags)) {
                 (void) async_share_out_finalize(callid, &fs_va);
-                if (fs_va == (void *) -1) {
+                if (fs_va == AS_MAP_FAILED) {
                         async_answer_0(callid, EHANGUP);
                         return;
@@ -237 +237 @@
         async_set_client_connection(rd_connection);
         ret = loc_server_register(NAME);
-        if (ret < 0) {
+        if (ret != EOK) {
                 printf("%s: Unable to register driver (%d)\n", NAME, ret);
                 return false;

uspace/srv/clipboard/clipboard.c

@@ -181 +181 @@
         
         async_set_client_connection(clip_connection);
-        
-        if (service_register(SERVICE_CLIPBOARD) != EOK)
-                return -1;
+        int rc = service_register(SERVICE_CLIPBOARD);
+        if (rc != EOK)
+                return rc;
         
         printf("%s: Accepting connections\n", NAME);

uspace/srv/devman/devman.h

@@ -210 +210 @@
 };
 
-
 /** Represents device tree. */
 typedef struct dev_tree {

uspace/srv/devman/main.c

@@ -245 +245 @@
         
         fibril_rwlock_write_lock(&device_tree.rwlock);
-
+        
         if (fun->state == FUN_ON_LINE) {
                 fibril_rwlock_write_unlock(&device_tree.rwlock);
@@ -259 +259 @@
                         return ENOMEM;
                 }
-
+                
                 insert_dev_node(&device_tree, dev, fun);
                 dev_add_ref(dev);
@@ -272 +272 @@
                 /* Give one reference over to assign_driver_fibril(). */
                 dev_add_ref(dev);
+                
                 /*
                  * Try to find a suitable driver and assign it to the device.  We do
@@ -288 +289 @@
                 }
                 fibril_add_ready(assign_fibril);
-        } else {
+        } else
                 loc_register_tree_function(fun, &device_tree);
-        }
         
         fibril_rwlock_write_unlock(&device_tree.rwlock);
@@ -419 +419 @@
         
         /* Check that function with same name is not there already. */
-        if (find_fun_node_in_device(tree, pdev, fun_name) != NULL) {
+        fun_node_t *tfun = find_fun_node_in_device(tree, pdev, fun_name);
+        if (tfun) {
+                fun_del_ref(tfun);      /* drop the new unwanted reference */
                 fibril_rwlock_write_unlock(&tree->rwlock);
                 dev_del_ref(pdev);
@@ -855 +857 @@
 }
 
+/** Get function driver name. */
+static void devman_fun_get_driver_name(ipc_callid_t iid, ipc_call_t *icall)
+{
+        devman_handle_t handle = IPC_GET_ARG1(*icall);
+
+        fun_node_t *fun = find_fun_node(&device_tree, handle);
+        if (fun == NULL) {
+                async_answer_0(iid, ENOMEM);
+                return;
+        }
+
+        ipc_callid_t data_callid;
+        size_t data_len;
+        if (!async_data_read_receive(&data_callid, &data_len)) {
+                async_answer_0(iid, EINVAL);
+                fun_del_ref(fun);
+                return;
+        }
+
+        void *buffer = malloc(data_len);
+        if (buffer == NULL) {
+                async_answer_0(data_callid, ENOMEM);
+                async_answer_0(iid, ENOMEM);
+                fun_del_ref(fun);
+                return;
+        }
+
+        fibril_rwlock_read_lock(&device_tree.rwlock);
+
+        /* Check function state */
+        if (fun->state == FUN_REMOVED) {
+                fibril_rwlock_read_unlock(&device_tree.rwlock);
+                free(buffer);
+
+                async_answer_0(data_callid, ENOENT);
+                async_answer_0(iid, ENOENT);
+                fun_del_ref(fun);
+                return;
+        }
+
+        /* Check whether function has a driver */
+        if (fun->child == NULL || fun->child->drv == NULL) {
+                fibril_rwlock_read_unlock(&device_tree.rwlock);
+                free(buffer);
+
+                async_answer_0(data_callid, EINVAL);
+                async_answer_0(iid, EINVAL);
+                fun_del_ref(fun);
+                return;
+        }
+
+        size_t sent_length = str_size(fun->child->drv->name);
+        if (sent_length > data_len) {
+                sent_length = data_len;
+        }
+
+        async_data_read_finalize(data_callid, fun->child->drv->name,
+            sent_length);
+        async_answer_0(iid, EOK);
+
+        fibril_rwlock_read_unlock(&device_tree.rwlock);
+        fun_del_ref(fun);
+        free(buffer);
+}
 
 /** Get device path. */
@@ -1083 +1149 @@
                         devman_fun_get_name(callid, &call);
                         break;
+                case DEVMAN_FUN_GET_DRIVER_NAME:
+                        devman_fun_get_driver_name(callid, &call);
+                        break;
                 case DEVMAN_FUN_GET_PATH:
                         devman_fun_get_path(callid, &call);
@@ -1149 +1218 @@
                 if (dev->pfun->dev != NULL)
                         driver = dev->pfun->dev->drv;
+                
                 fwd_h = dev->pfun->handle;
         } else if (dev->state == DEVICE_USABLE) {
@@ -1154 +1224 @@
                 driver = dev->drv;
                 assert(driver != NULL);
-
+                
                 fwd_h = handle;
         }
@@ -1181 +1251 @@
 
         if (fun != NULL) {
-                log_msg(LVL_DEBUG, 
+                log_msg(LVL_DEBUG,
                     "Forwarding request for `%s' function to driver `%s'.",
                     fun->pathname, driver->name);
         } else {
-                log_msg(LVL_DEBUG, 
+                log_msg(LVL_DEBUG,
                     "Forwarding request for `%s' device to driver `%s'.",
                     dev->pfun->pathname, driver->name);
@@ -1193 +1263 @@
         async_forward_fast(iid, exch, method, fwd_h, 0, IPC_FF_NONE);
         async_exchange_end(exch);
-
+        
 cleanup:
         if (dev != NULL)
                 dev_del_ref(dev);
+        
         if (fun != NULL)
                 fun_del_ref(fun);
@@ -1299 +1370 @@
                 return false;
         }
-
+        
         log_msg(LVL_DEBUG, "devman_init - list of drivers has been initialized.");
-
+        
         /* Create root device node. */
         if (!init_device_tree(&device_tree, &drivers_list)) {
@@ -1307 +1378 @@
                 return false;
         }
-
+        
         /*
          * Caution: As the device manager is not a real loc
@@ -1322 +1393 @@
 int main(int argc, char *argv[])
 {
-        printf(NAME ": HelenOS Device Manager\n");
-
-        if (log_init(NAME, LVL_WARN) != EOK) {
-                printf(NAME ": Error initializing logging subsystem.\n");
-                return -1;
+        printf("%s: HelenOS Device Manager\n", NAME);
+        
+        int rc = log_init(NAME, LVL_WARN);
+        if (rc != EOK) {
+                printf("%s: Error initializing logging subsystem.\n", NAME);
+                return rc;
         }
         
@@ -1333 +1405 @@
         async_set_client_data_destructor(devman_client_data_destroy);
         async_set_client_connection(devman_connection);
-
+        
         if (!devman_init()) {
                 log_msg(LVL_ERROR, "Error while initializing service.");
                 return -1;
         }
-
+        
         /* Register device manager at naming service. */
-        if (service_register(SERVICE_DEVMAN) != EOK) {
+        rc = service_register(SERVICE_DEVMAN);
+        if (rc != EOK) {
                 log_msg(LVL_ERROR, "Failed registering as a service.");
-                return -1;
-        }
-
-        printf(NAME ": Accepting connections.\n");
+                return rc;
+        }
+        
+        printf("%s: Accepting connections.\n", NAME);
         task_retval(0);
         async_manager();
-
+        
         /* Never reached. */
         return 0;

uspace/srv/fs/fat/fat_dentry.c

@@ -43 +43 @@
 #include <byteorder.h>
 #include <assert.h>
+#include <unistd.h>
 
 /** Compare path component with the name read from the dentry.

uspace/srv/hid/console/console.c

@@ -852 +852 @@
         async_set_client_connection(client_connection);
         int rc = loc_server_register(NAME);
-        if (rc < 0) {
+        if (rc != EOK) {
                 printf("%s: Unable to register server (%s)\n", NAME,
                     str_error(rc));

uspace/srv/hid/fb/fb.c

@@ -305 +305 @@
         
         int rc = async_share_out_finalize(callid, &frontbuf->data);
-        if ((rc != EOK) || (frontbuf->data == (void *) -1)) {
+        if ((rc != EOK) || (frontbuf->data == AS_MAP_FAILED)) {
                 free(frontbuf);
                 async_answer_0(iid, ENOMEM);
@@ -348 +348 @@
         
         int rc = async_share_out_finalize(callid, &imagemap->data);
-        if ((rc != EOK) || (imagemap->data == (void *) -1)) {
+        if ((rc != EOK) || (imagemap->data == AS_MAP_FAILED)) {
                 free(imagemap);
                 async_answer_0(iid, ENOMEM);
@@ -990 +990 @@
         int rc = loc_server_register(NAME);
         if (rc != EOK) {
-                printf("%s: Unable to register driver (%d)\n", NAME, rc);
-                return 1;
+                printf("%s: Unable to register driver\n", NAME);
+                return rc;
         }
         

uspace/srv/hid/input/ctl/kbdev.c

@@ -68 +68 @@
         /** Link to generic keyboard device */
         kbd_dev_t *kbd_dev;
-
+        
         /** Session with kbdev device */
         async_sess_t *sess;
@@ -75 +75 @@
 static kbdev_t *kbdev_new(kbd_dev_t *kdev)
 {
-        kbdev_t *kbdev;
-
-        kbdev = calloc(1, sizeof(kbdev_t));
+        kbdev_t *kbdev = calloc(1, sizeof(kbdev_t));
         if (kbdev == NULL)
                 return NULL;
-
+        
         kbdev->kbd_dev = kdev;
 
@@ -90 +88 @@
         if (kbdev->sess != NULL)
                 async_hangup(kbdev->sess);
+        
         free(kbdev);
 }
@@ -95 +94 @@
 static int kbdev_ctl_init(kbd_dev_t *kdev)
 {
-        async_sess_t *sess;
-        async_exch_t *exch;
-        kbdev_t *kbdev;
-        int rc;
-
-        sess = loc_service_connect(EXCHANGE_SERIALIZE, kdev->svc_id, 0);
+        async_sess_t *sess = loc_service_connect(EXCHANGE_SERIALIZE,
+            kdev->svc_id, 0);
         if (sess == NULL) {
                 printf("%s: Failed starting session with '%s.'\n", NAME,
                     kdev->svc_name);
-                return -1;
+                return ENOENT;
         }
-
-        kbdev = kbdev_new(kdev);
+        
+        kbdev_t *kbdev = kbdev_new(kdev);
         if (kbdev == NULL) {
                 printf("%s: Failed allocating device structure for '%s'.\n",
                     NAME, kdev->svc_name);
                 async_hangup(sess);
-                return -1;
+                return ENOMEM;
         }
-
+        
         kbdev->sess = sess;
-
-        exch = async_exchange_begin(sess);
+        
+        async_exch_t *exch = async_exchange_begin(sess);
         if (exch == NULL) {
                 printf("%s: Failed starting exchange with '%s'.\n", NAME,
                     kdev->svc_name);
                 kbdev_destroy(kbdev);
-                return -1;
+                return ENOENT;
         }
-
-        rc = async_connect_to_me(exch, 0, 0, 0, kbdev_callback_conn, kbdev);
+        
+        int rc = async_connect_to_me(exch, 0, 0, 0, kbdev_callback_conn, kbdev);
         if (rc != EOK) {
                 printf("%s: Failed creating callback connection from '%s'.\n",
@@ -131 +126 @@
                 async_exchange_end(exch);
                 kbdev_destroy(kbdev);
-                return -1;
+                return rc;
         }
-
+        
         async_exchange_end(exch);
-
+        
         kdev->ctl_private = (void *) kbdev;
         return 0;
@@ -142 +137 @@
 static void kbdev_ctl_set_ind(kbd_dev_t *kdev, unsigned mods)
 {
-        async_sess_t *sess;
-        async_exch_t *exch;
-
-        sess = ((kbdev_t *) kdev->ctl_private)->sess;
-
-        exch = async_exchange_begin(sess);
+        async_sess_t *sess = ((kbdev_t *) kdev->ctl_private)->sess;
+        async_exch_t *exch = async_exchange_begin(sess);
         if (!exch)
                 return;
-
+        
         async_msg_1(exch, KBDEV_SET_IND, mods);
         async_exchange_end(exch);

uspace/srv/hid/input/generic/input.c

@@ -662 +662 @@
         async_set_client_connection(client_connection);
         int rc = loc_server_register(NAME);
-        if (rc < 0) {
-                printf("%s: Unable to register server (%d)\n", NAME, rc);
-                return -1;
+        if (rc != EOK) {
+                printf("%s: Unable to register server\n", NAME);
+                return rc;
         }
         
@@ -671 +671 @@
         
         service_id_t service_id;
-        if (loc_service_register(kbd, &service_id) != EOK) {
+        rc = loc_service_register(kbd, &service_id);
+        if (rc != EOK) {
                 printf("%s: Unable to register service %s\n", NAME, kbd);
-                return -1;
+                return rc;
         }
         

uspace/srv/hid/input/port/adb.c

@@ -65 +65 @@
 static int adb_port_init(kbd_dev_t *kdev)
 {
+        kbd_dev = kdev;
+        
         const char *dev = "adb/kbd";
         service_id_t service_id;
-        async_exch_t *exch;
-        int rc;
-        
-        kbd_dev = kdev;
-        
-        rc = loc_service_get_id(dev, &service_id, 0);
+        int rc = loc_service_get_id(dev, &service_id, 0);
         if (rc != EOK)
                 return rc;
@@ -82 +79 @@
         }
         
-        exch = async_exchange_begin(dev_sess);
+        async_exch_t *exch = async_exchange_begin(dev_sess);
         if (exch == NULL) {
                 printf("%s: Failed starting exchange with device\n", NAME);
@@ -89 +86 @@
         }
         
-        /* NB: The callback connection is slotted for removal */
         rc = async_connect_to_me(exch, 0, 0, 0, kbd_port_events, NULL);
         async_exchange_end(exch);

uspace/srv/hid/input/proto/mousedev.c

@@ -117 +117 @@
                 printf("%s: Failed starting session with '%s'\n", NAME,
                     mdev->svc_name);
-                return -1;
+                return ENOENT;
         }
         
@@ -125 +125 @@
                     NAME, mdev->svc_name);
                 async_hangup(sess);
-                return -1;
+                return ENOMEM;
         }
         
@@ -134 +134 @@
                 mousedev_destroy(mousedev);
                 async_hangup(sess);
-                return -1;
+                return ENOENT;
         }
         
@@ -145 +145 @@
                     NAME, mdev->svc_name);
                 mousedev_destroy(mousedev);
-                return -1;
+                return rc;
         }
         
-        return 0;
+        return EOK;
 }
 

uspace/srv/hid/remcons/remcons.c

@@ -71 +71 @@
         TELNET_IAC, TELNET_WONT, TELNET_LINEMODE
 };
+
 static const size_t telnet_force_character_mode_command_count =
     sizeof(telnet_force_character_mode_command) / sizeof(telnet_cmd_t);
@@ -272 +273 @@
 static int network_user_fibril(void *arg)
 {
-        int rc;
         telnet_user_t *user = arg;
 
-        rc = loc_service_register(user->service_name, &user->service_id);
+        int rc = loc_service_register(user->service_name, &user->service_id);
         if (rc != EOK) {
                 telnet_user_error(user, "Unable to register %s with loc: %s.",
@@ -284 +284 @@
         telnet_user_log(user, "Service %s registerd with id %" PRIun ".",
             user->service_name, user->service_id);
-
+        
         fid_t spawn_fibril = fibril_create(spawn_task_fibril, user);
         assert(spawn_fibril);
         fibril_add_ready(spawn_fibril);
-
+        
         /* Wait for all clients to exit. */
         fibril_mutex_lock(&user->guard);
@@ -304 +304 @@
         }
         fibril_mutex_unlock(&user->guard);
-
+        
         rc = loc_service_unregister(user->service_id);
         if (rc != EOK) {
@@ -324 +324 @@
         async_set_client_connection(client_connection);
         int rc = loc_server_register(NAME);
-        if (rc < 0) {
-                fprintf(stderr, NAME ": Unable to register server: %s.\n",
-                    str_error(rc));
-                return 1;
-        }
-
+        if (rc != EOK) {
+                fprintf(stderr, "%s: Unable to register server\n", NAME);
+                return rc;
+        }
+        
         struct sockaddr_in addr;
-
+        
         addr.sin_family = AF_INET;
         addr.sin_port = htons(port);
-
+        
         rc = inet_pton(AF_INET, "127.0.0.1", (void *)
             &addr.sin_addr.s_addr);

uspace/srv/hid/remcons/telnet.h

@@ -57 +57 @@
 #define TELNET_LINEMODE 34
 
-
 #endif
 

uspace/srv/hid/remcons/user.h

@@ -76 +76 @@
 } telnet_user_t;
 
-telnet_user_t *telnet_user_create(int socket);
-void telnet_user_destroy(telnet_user_t *user);
-telnet_user_t *telnet_user_get_for_client_connection(service_id_t id);
-bool telnet_user_is_zombie(telnet_user_t *user);
-void telnet_user_notify_client_disconnected(telnet_user_t *user);
-int telnet_user_get_next_keyboard_event(telnet_user_t *user, kbd_event_t *event);
-int telnet_user_send_data(telnet_user_t *user, uint8_t *data, size_t size);
-void telnet_user_update_cursor_x(telnet_user_t *user, int new_x);
+extern telnet_user_t *telnet_user_create(int);
+extern void telnet_user_destroy(telnet_user_t *);
+extern telnet_user_t *telnet_user_get_for_client_connection(service_id_t);
+extern bool telnet_user_is_zombie(telnet_user_t *);
+extern void telnet_user_notify_client_disconnected(telnet_user_t *);
+extern int telnet_user_get_next_keyboard_event(telnet_user_t *, kbd_event_t *);
+extern int telnet_user_send_data(telnet_user_t *, uint8_t *, size_t);
+extern void telnet_user_update_cursor_x(telnet_user_t *, int);
 
 /** Print informational message about connected user. */
 #ifdef CONFIG_DEBUG
 #define telnet_user_log(user, fmt, ...) \
-        printf(NAME " [console %d (%d)]: " fmt "\n", user->id, (int) user->service_id, ##__VA_ARGS__)
+        printf(NAME " [console %d (%d)]: " fmt "\n", \
+            user->id, (int) user->service_id, ##__VA_ARGS__)
 #else
-#define telnet_user_log(user, fmt, ...) (void)0
+#define telnet_user_log(user, fmt, ...) ((void) 0)
 #endif
 
 /** Print error message associated with connected user. */
 #define telnet_user_error(user, fmt, ...) \
-        fprintf(stderr, NAME " [console %d (%d)]: ERROR: " fmt "\n", user->id, (int) user->service_id, ##__VA_ARGS__)
+        fprintf(stderr, NAME " [console %d (%d)]: ERROR: " fmt "\n", \
+            user->id, (int) user->service_id, ##__VA_ARGS__)
 
 #endif

uspace/srv/hid/s3c24xx_ts/s3c24xx_ts.c

@@ -84 +84 @@
 int main(int argc, char *argv[])
 {
-        int rc;
-
-        printf(NAME ": S3C24xx touchscreen driver\n");
+        printf("%s: S3C24xx touchscreen driver\n", NAME);
         
         async_set_client_connection(s3c24xx_ts_connection);
-        rc = loc_server_register(NAME);
-        if (rc < 0) {
-                printf(NAME ": Unable to register driver.\n");
-                return -1;
+        int rc = loc_server_register(NAME);
+        if (rc != EOK) {
+                printf("%s: Unable to register driver.\n", NAME);
+                return rc;
         }
 

uspace/srv/hw/char/s3c24xx_uart/s3c24xx_uart.c

@@ -77 +77 @@
 int main(int argc, char *argv[])
 {
-        int rc;
-
-        printf(NAME ": S3C24xx on-chip UART driver\n");
-
+        printf("%s: S3C24xx on-chip UART driver\n", NAME);
+        
         async_set_client_connection(s3c24xx_uart_connection);
-        rc = loc_server_register(NAME);
-        if (rc < 0) {
-                printf(NAME ": Unable to register server.\n");
-                return -1;
+        int rc = loc_server_register(NAME);
+        if (rc != EOK) {
+                printf("%s: Unable to register server.\n", NAME);
+                return rc;
         }
 

uspace/srv/loader/main.c

@@ -450 +450 @@
         int rc = ns_intro(id);
         if (rc != EOK)
-                return -1;
+                return rc;
         
         /* Register at naming service. */
-        if (service_register(SERVICE_LOAD) != EOK)
-                return -2;
+        rc = service_register(SERVICE_LOAD);
+        if (rc != EOK)
+                return rc;
         
         async_manager();

uspace/srv/locsrv/locsrv.c

@@ -390 +390 @@
          */
         list_initialize(&server->services);
-
         link_initialize(&server->servers);
         
@@ -651 +650 @@
             min(size, act_size));
         free(fqn);
+        
+        fibril_mutex_unlock(&services_list_mutex);
+        
+        async_answer_0(iid, retval);
+}
+
+static void loc_service_get_server_name(ipc_callid_t iid, ipc_call_t *icall)
+{
+        ipc_callid_t callid;
+        size_t size;
+        size_t act_size;
+        loc_service_t *svc;
+        
+        if (!async_data_read_receive(&callid, &size)) {
+                async_answer_0(callid, EREFUSED);
+                async_answer_0(iid, EREFUSED);
+                return;
+        }
+        
+        fibril_mutex_lock(&services_list_mutex);
+        
+        svc = loc_service_find_id(IPC_GET_ARG1(*icall));
+        if (svc == NULL) {
+                fibril_mutex_unlock(&services_list_mutex);
+                async_answer_0(callid, ENOENT);
+                async_answer_0(iid, ENOENT);
+                return;
+        }
+        
+        if (svc->server == NULL) {
+                fibril_mutex_unlock(&services_list_mutex);
+                async_answer_0(callid, EINVAL);
+                async_answer_0(iid, EINVAL);
+                return;
+        }
+        
+        act_size = str_size(svc->server->name);
+        if (act_size > size) {
+                fibril_mutex_unlock(&services_list_mutex);
+                async_answer_0(callid, EOVERFLOW);
+                async_answer_0(iid, EOVERFLOW);
+                return;
+        }
+        
+        sysarg_t retval = async_data_read_finalize(callid, svc->server->name,
+            min(size, act_size));
         
         fibril_mutex_unlock(&services_list_mutex);
@@ -1405 +1450 @@
                 case LOC_SERVICE_GET_NAME:
                         loc_service_get_name(callid, &call);
+                        break;
+                case LOC_SERVICE_GET_SERVER_NAME:
+                        loc_service_get_server_name(callid, &call);
                         break;
                 case LOC_NAMESPACE_GET_ID:
@@ -1490 +1538 @@
         
         /* Register location service at naming service */
-        if (service_register(SERVICE_LOC) != EOK)
-                return -1;
+        int rc = service_register(SERVICE_LOC);
+        if (rc != EOK)
+                return rc;
         
         printf("%s: Accepting connections\n", NAME);

uspace/srv/locsrv/locsrv.h

@@ -86 +86 @@
         /** Link to global list of services (services_list) */
         link_t services;
+        
         /** Link to server list of services (loc_server_t.services) */
         link_t server_services;
+        
         /** Link to list of services in category (category_t.services) */
         link_t cat_services;
+        
         /** List of category memberships (svc_categ_t) */
         list_t cat_memb;
+        
         /** Unique service identifier */
         service_id_t id;
+        
         /** Service namespace */
         loc_namespace_t *namespace;
+        
         /** Service name */
         char *name;
+        
         /** Supplier of this service */
         loc_server_t *server;
+        
         /** Use this interface when forwarding to server. */
         sysarg_t forward_interface;

uspace/srv/net/ethip/ethip.c

@@ -73 +73 @@
 static int ethip_init(void)
 {
-        int rc;
-
         async_set_client_connection(ethip_client_conn);
-
-        rc = loc_server_register(NAME);
+        
+        int rc = loc_server_register(NAME);
         if (rc != EOK) {
                 log_msg(LVL_ERROR, "Failed registering server.");
                 return rc;
         }
-
+        
         rc = ethip_nic_discovery_start();
         if (rc != EOK)
                 return rc;
-
+        
         return EOK;
 }

uspace/srv/net/ethip/ethip_nic.c

@@ -150 +150 @@
 static int ethip_nic_open(service_id_t sid)
 {
-        ethip_nic_t *nic;
-        int rc;
         bool in_list = false;
         nic_address_t nic_address;
-
+        
         log_msg(LVL_DEBUG, "ethip_nic_open()");
-        nic = ethip_nic_new();
+        ethip_nic_t *nic = ethip_nic_new();
         if (nic == NULL)
                 return ENOMEM;
-
-        rc = loc_service_get_name(sid, &nic->svc_name);
+        
+        int rc = loc_service_get_name(sid, &nic->svc_name);
         if (rc != EOK) {
                 log_msg(LVL_ERROR, "Failed getting service name.");
                 goto error;
         }
-
+        
         nic->sess = loc_service_connect(EXCHANGE_SERIALIZE, sid, 0);
         if (nic->sess == NULL) {
@@ -171 +169 @@
                 goto error;
         }
-
+        
         nic->svc_id = sid;
-
+        
         rc = nic_callback_create(nic->sess, ethip_nic_cb_conn, nic);
         if (rc != EOK) {
@@ -298 +296 @@
 int ethip_nic_discovery_start(void)
 {
-        int rc;
-
-        rc = loc_register_cat_change_cb(ethip_nic_cat_change_cb);
+        int rc = loc_register_cat_change_cb(ethip_nic_cat_change_cb);
         if (rc != EOK) {
                 log_msg(LVL_ERROR, "Failed registering callback for NIC "
@@ -306 +302 @@
                 return rc;
         }
-
+        
         return ethip_nic_check_new();
 }

uspace/srv/net/inetsrv/inetsrv.c

@@ -66 +66 @@
 static int inet_init(void)
 {
-        service_id_t sid;
-        int rc;
-
         log_msg(LVL_DEBUG, "inet_init()");
-
+        
         async_set_client_connection(inet_client_conn);
-
-        rc = loc_server_register(NAME);
+        
+        int rc = loc_server_register(NAME);
         if (rc != EOK) {
                 log_msg(LVL_ERROR, "Failed registering server (%d).", rc);
                 return EEXIST;
         }
-
+        
+        service_id_t sid;
         rc = loc_service_register_with_iface(SERVICE_NAME_INET, &sid,
             INET_PORT_DEFAULT);
@@ -85 +83 @@
                 return EEXIST;
         }
-
+        
         rc = loc_service_register_with_iface(SERVICE_NAME_INETCFG, &sid,
             INET_PORT_CFG);
@@ -92 +90 @@
                 return EEXIST;
         }
-
+        
         rc = loc_service_register_with_iface(SERVICE_NAME_INETPING, &sid,
             INET_PORT_PING);
@@ -99 +97 @@
                 return EEXIST;
         }
-
+        
         rc = inet_link_discovery_start();
         if (rc != EOK)
                 return EEXIST;
-
+        
         return EOK;
 }

uspace/srv/net/loopip/loopip.c

@@ -91 +91 @@
         category_id_t iplink_cat;
         const char *svc_name = "net/loopback";
-
+        
         async_set_client_connection(loopip_client_conn);
-
+        
         rc = loc_server_register(NAME);
         if (rc != EOK) {

uspace/srv/net/tcp/sock.c

@@ -68 +68 @@
 int tcp_sock_init(void)
 {
-        int rc;
-
         socket_ports_initialize(&gsock);
-
+        
         async_set_client_connection(tcp_sock_connection);
-
-        rc = service_register(SERVICE_TCP);
+        
+        int rc = service_register(SERVICE_TCP);
         if (rc != EOK)
                 return EEXIST;
-
+        
         return EOK;
 }
@@ -153 +151 @@
             sock, sock_id);
 
-        if (rc != EOK)
+        if (rc != EOK) {
+                fibril_destroy(sock->recv_fibril);
+                sock->recv_fibril = 0;
                 return rc;
+        }
 
         sock_core = socket_cores_find(&sock->client->sockets, *sock_id);

uspace/srv/net/udp/sock.c

@@ -51 +51 @@
 #include "ucall.h"
 
-#define FRAGMENT_SIZE 1024
-
 /** Free ports pool start. */
 #define UDP_FREE_PORTS_START            1025
@@ -63 +61 @@
 
 static void udp_sock_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg);
+static int udp_sock_recv_fibril(void *arg);
 
 int udp_sock_init(void)
 {
-        int rc;
-
         socket_ports_initialize(&gsock);
-
+        
         async_set_client_connection(udp_sock_connection);
-
-        rc = service_register(SERVICE_UDP);
+        
+        int rc = service_register(SERVICE_UDP);
         if (rc != EOK)
                 return EEXIST;
-
+        
         return EOK;
 }
@@ -84 +81 @@
 
         socket = (udp_sockdata_t *)sock_core->specific_data;
-        assert(socket->assoc != NULL);
-        udp_uc_destroy(socket->assoc);
+        (void)socket;
+
+        /* XXX We need to force the receive fibril to quit */
 }
 
@@ -93 +91 @@
         async_exch_t *exch = async_exchange_begin(sock_core->sess);
         async_msg_5(exch, NET_SOCKET_RECEIVED, (sysarg_t)sock_core->socket_id,
-            FRAGMENT_SIZE, 0, 0, 1);
+            UDP_FRAGMENT_SIZE, 0, 0, 1);
         async_exchange_end(exch);
 }
@@ -115 +113 @@
         sock->client = client;
 
+        sock->recv_buffer_used = 0;
+        sock->recv_error = UDP_EOK;
+        fibril_mutex_initialize(&sock->recv_buffer_lock);
+        fibril_condvar_initialize(&sock->recv_buffer_cv);
+
         rc = udp_uc_create(&sock->assoc);
         if (rc != EOK) {
+                free(sock);
+                async_answer_0(callid, rc);
+                return;
+        }
+
+        sock->recv_fibril = fibril_create(udp_sock_recv_fibril, sock);
+        if (sock->recv_fibril == 0) {
+                udp_uc_destroy(sock->assoc);
+                free(sock);
+                async_answer_0(callid, ENOMEM);
+                return;
+        }
+
+        sock_id = SOCKET_GET_SOCKET_ID(call);
+        rc = socket_create(&client->sockets, client->sess, sock, &sock_id);
+        if (rc != EOK) {
+                fibril_destroy(sock->recv_fibril);
                 udp_uc_destroy(sock->assoc);
                 free(sock);
@@ -123 +143 @@
         }
 
-        sock_id = SOCKET_GET_SOCKET_ID(call);
-        rc = socket_create(&client->sockets, client->sess, sock, &sock_id);
-        if (rc != EOK) {
-                async_answer_0(callid, rc);
-                return;
-        }
+        fibril_add_ready(sock->recv_fibril);
 
         sock_core = socket_cores_find(&client->sockets, sock_id);
@@ -136 +151 @@
         SOCKET_SET_SOCKET_ID(answer, sock_id);
 
-        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
+        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, UDP_FRAGMENT_SIZE);
         SOCKET_SET_HEADER_SIZE(answer, sizeof(udp_header_t));
         async_answer_3(callid, EOK, IPC_GET_ARG1(answer),
@@ -207 +222 @@
         }
 
-        udp_sock_notify_data(sock_core);
-
         log_msg(LVL_DEBUG, " - success");
         async_answer_0(callid, rc);
@@ -247 +260 @@
         ipc_callid_t wcallid;
         size_t length;
-        uint8_t buffer[FRAGMENT_SIZE];
+        uint8_t buffer[UDP_FRAGMENT_SIZE];
         udp_error_t urc;
         int rc;
@@ -294 +307 @@
                         goto out;
                 }
-
-                udp_sock_notify_data(sock_core);
         }
 
@@ -332 +343 @@
                 }
 
-                if (length > FRAGMENT_SIZE)
-                        length = FRAGMENT_SIZE;
+                if (length > UDP_FRAGMENT_SIZE)
+                        length = UDP_FRAGMENT_SIZE;
 
                 rc = async_data_write_finalize(wcallid, buffer, length);
@@ -369 +380 @@
         
         IPC_SET_ARG1(answer, 0);
-        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
+        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, UDP_FRAGMENT_SIZE);
         async_answer_2(callid, EOK, IPC_GET_ARG1(answer),
             IPC_GET_ARG2(answer));
@@ -388 +399 @@
         ipc_call_t answer;
         ipc_callid_t rcallid;
-        uint8_t buffer[FRAGMENT_SIZE];
         size_t data_len;
-        xflags_t xflags;
         udp_error_t urc;
+        udp_sock_t rsock;
         struct sockaddr_in addr;
-        udp_sock_t rsock;
         int rc;
 
@@ -418 +427 @@
         (void)flags;
 
-        urc = udp_uc_receive(socket->assoc, buffer, FRAGMENT_SIZE, &data_len,
-            &xflags, &rsock);
-        log_msg(LVL_DEBUG, "**** udp_uc_receive done, data_len=%zu", data_len);
+        log_msg(LVL_DEBUG, "udp_sock_recvfrom(): lock recv_buffer lock");
+        fibril_mutex_lock(&socket->recv_buffer_lock);
+        while (socket->recv_buffer_used == 0 && socket->recv_error == UDP_EOK) {
+                log_msg(LVL_DEBUG, "udp_sock_recvfrom(): wait for cv");
+                fibril_condvar_wait(&socket->recv_buffer_cv,
+                    &socket->recv_buffer_lock);
+        }
+
+        log_msg(LVL_DEBUG, "Got data in sock recv_buffer");
+
+        rsock = socket->recv_fsock;
+        data_len = socket->recv_buffer_used;
+        urc = socket->recv_error;
+
+        log_msg(LVL_DEBUG, "**** recv data_len=%zu", data_len);
 
         switch (urc) {
@@ -439 +460 @@
         log_msg(LVL_DEBUG, "**** udp_uc_receive -> %d", rc);
         if (rc != EOK) {
+                fibril_mutex_unlock(&socket->recv_buffer_lock);
                 fibril_mutex_unlock(&socket->lock);
                 async_answer_0(callid, rc);
@@ -452 +474 @@
                 log_msg(LVL_DEBUG, "addr read receive");
                 if (!async_data_read_receive(&rcallid, &addr_length)) {
+                        fibril_mutex_unlock(&socket->recv_buffer_lock);
                         fibril_mutex_unlock(&socket->lock);
                         async_answer_0(callid, EINVAL);
@@ -463 +486 @@
                 rc = async_data_read_finalize(rcallid, &addr, addr_length);
                 if (rc != EOK) {
+                        fibril_mutex_unlock(&socket->recv_buffer_lock);
                         fibril_mutex_unlock(&socket->lock);
                         async_answer_0(callid, EINVAL);
@@ -471 +495 @@
         log_msg(LVL_DEBUG, "data read receive");
         if (!async_data_read_receive(&rcallid, &length)) {
+                fibril_mutex_unlock(&socket->recv_buffer_lock);
                 fibril_mutex_unlock(&socket->lock);
                 async_answer_0(callid, EINVAL);
@@ -480 +505 @@
 
         log_msg(LVL_DEBUG, "data read finalize");
-        rc = async_data_read_finalize(rcallid, buffer, length);
+        rc = async_data_read_finalize(rcallid, socket->recv_buffer, length);
 
         if (length < data_len && rc == EOK)
@@ -491 +516 @@
         async_answer_3(callid, EOK, IPC_GET_ARG1(answer),
             IPC_GET_ARG2(answer), IPC_GET_ARG3(answer));
-        
-        /* Push one fragment notification to client's queue */
-        udp_sock_notify_data(sock_core);
+
+        socket->recv_buffer_used = 0;
+
+        fibril_condvar_broadcast(&socket->recv_buffer_cv);
+        fibril_mutex_unlock(&socket->recv_buffer_lock);
         fibril_mutex_unlock(&socket->lock);
 }
@@ -540 +567 @@
 }
 
+static int udp_sock_recv_fibril(void *arg)
+{
+        udp_sockdata_t *sock = (udp_sockdata_t *)arg;
+        udp_error_t urc;
+        xflags_t xflags;
+        size_t rcvd;
+
+        log_msg(LVL_DEBUG, "udp_sock_recv_fibril()");
+
+        while (true) {
+                log_msg(LVL_DEBUG, "[] wait for rcv buffer empty()");
+                fibril_mutex_lock(&sock->recv_buffer_lock);
+                while (sock->recv_buffer_used != 0) {
+                        fibril_condvar_wait(&sock->recv_buffer_cv,
+                            &sock->recv_buffer_lock);
+                }
+
+                log_msg(LVL_DEBUG, "[] call udp_uc_receive()");
+                urc = udp_uc_receive(sock->assoc, sock->recv_buffer,
+                    UDP_FRAGMENT_SIZE, &rcvd, &xflags, &sock->recv_fsock);
+                sock->recv_error = urc;
+
+                udp_sock_notify_data(sock->sock_core);
+
+                if (urc != UDP_EOK) {
+                        fibril_condvar_broadcast(&sock->recv_buffer_cv);
+                        fibril_mutex_unlock(&sock->recv_buffer_lock);
+                        break;
+                }
+
+                log_msg(LVL_DEBUG, "[] got data - broadcast recv_buffer_cv");
+
+                sock->recv_buffer_used = rcvd;
+                fibril_mutex_unlock(&sock->recv_buffer_lock);
+                fibril_condvar_broadcast(&sock->recv_buffer_cv);
+        }
+
+        udp_uc_destroy(sock->assoc);
+
+        return 0;
+}
+
 static void udp_sock_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
 {

uspace/srv/net/udp/udp.c

@@ -73 +73 @@
         printf(NAME ": UDP (User Datagram Protocol) service\n");
 
-        rc = log_init(NAME, LVL_WARN);
+        rc = log_init(NAME, LVL_DEBUG);
         if (rc != EOK) {
                 printf(NAME ": Failed to initialize log.\n");

uspace/srv/net/udp/udp_type.h

@@ -36 +36 @@
 #define UDP_TYPE_H
 
+#include <fibril.h>
 #include <fibril_synch.h>
 #include <socket_core.h>
 #include <sys/types.h>
+
+#define UDP_FRAGMENT_SIZE 4096
+
 
 typedef enum {
@@ -141 +145 @@
         /** Connection */
         udp_assoc_t *assoc;
+        /** Receiving fibril */
+        fid_t recv_fibril;
+        uint8_t recv_buffer[UDP_FRAGMENT_SIZE];
+        size_t recv_buffer_used;
+        udp_sock_t recv_fsock;
+        fibril_mutex_t recv_buffer_lock;
+        fibril_condvar_t recv_buffer_cv;
+        udp_error_t recv_error;
 } udp_sockdata_t;
 

uspace/srv/ns/ns.c

@@ -48 +48 @@
 int main(int argc, char **argv)
 {
-        printf(NAME ": HelenOS IPC Naming Service\n");
+        printf("%s: HelenOS IPC Naming Service\n", NAME);
         
         int rc = service_init();

uspace/srv/vfs/vfs.c

@@ -159 +159 @@
 int main(int argc, char **argv)
 {
-        printf(NAME ": HelenOS VFS server\n");
+        printf("%s: HelenOS VFS server\n", NAME);
         
         /*
@@ -165 +165 @@
          */
         if (!vfs_nodes_init()) {
-                printf(NAME ": Failed to initialize VFS node hash table\n");
+                printf("%s: Failed to initialize VFS node hash table\n",
+                    NAME);
                 return ENOMEM;
         }
@@ -172 +173 @@
          * Allocate and initialize the Path Lookup Buffer.
          */
-        plb = as_area_create((void *) -1, PLB_SIZE,
+        plb = as_area_create(AS_AREA_ANY, PLB_SIZE,
             AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE);
-        if (plb == (void *) -1) {
-                printf(NAME ": Cannot create address space area\n");
+        if (plb == AS_MAP_FAILED) {
+                printf("%s: Cannot create address space area\n", NAME);
                 return ENOMEM;
         }
@@ -196 +197 @@
         async_set_interrupt_received(notification_received);
         event_task_subscribe(EVENT_TASK_STATE_CHANGE, VFS_TASK_STATE_CHANGE);
-
+        
         /*
          * Register at the naming service.
          */
-        if (service_register(SERVICE_VFS) != EOK) {
+        int rc = service_register(SERVICE_VFS);
+        if (rc != EOK) {
                 printf("%s: Cannot register VFS service\n", NAME);
-                return EINVAL;
+                return rc;
         }
         
@@ -208 +210 @@
          * Start accepting connections.
          */
-        printf(NAME ": Accepting connections\n");
+        printf("%s: Accepting connections\n", NAME);
         async_manager();
         return 0;