Index: uspace/srv/audio/hound/main.c
===================================================================
--- uspace/srv/audio/hound/main.c	(revision da680b4b4a258b7464a3f60a90d226a51447f783)
+++ uspace/srv/audio/hound/main.c	(revision d054ad327ffe0b12fea2dcc17f0711048959b7b2)
@@ -62,5 +62,5 @@
 }
 
-static void scan_for_devices(void)
+static void scan_for_devices(void *arg)
 {
 	hound_server_devices_iterate(device_callback);
@@ -94,5 +94,5 @@
 	}
 
-	ret = hound_server_set_device_change_callback(scan_for_devices);
+	ret = hound_server_set_device_change_callback(scan_for_devices, NULL);
 	if (ret != EOK) {
 		log_fatal("Failed to register for device changes: %s",
@@ -103,5 +103,5 @@
 	log_info("Running with service id %" PRIun, id);
 
-	scan_for_devices();
+	scan_for_devices(NULL);
 	task_retval(0);
 	async_manager();
Index: uspace/srv/bd/vbd/disk.c
===================================================================
--- uspace/srv/bd/vbd/disk.c	(revision da680b4b4a258b7464a3f60a90d226a51447f783)
+++ uspace/srv/bd/vbd/disk.c	(revision d054ad327ffe0b12fea2dcc17f0711048959b7b2)
@@ -447,5 +447,5 @@
 }
 
-static void vbds_disk_cat_change_cb(void)
+static void vbds_disk_cat_change_cb(void *arg)
 {
 	(void) vbds_disks_check_new();
@@ -456,5 +456,5 @@
 	errno_t rc;
 
-	rc = loc_register_cat_change_cb(vbds_disk_cat_change_cb);
+	rc = loc_register_cat_change_cb(vbds_disk_cat_change_cb, NULL);
 	if (rc != EOK) {
 		log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering callback "
Index: uspace/srv/hid/compositor/compositor.c
===================================================================
--- uspace/srv/hid/compositor/compositor.c	(revision da680b4b4a258b7464a3f60a90d226a51447f783)
+++ uspace/srv/hid/compositor/compositor.c	(revision d054ad327ffe0b12fea2dcc17f0711048959b7b2)
@@ -2262,5 +2262,5 @@
 }
 
-static void category_change_cb(void)
+static void category_change_cb(void *arg)
 {
 	discover_viewports();
@@ -2311,5 +2311,5 @@
 	}
 
-	rc = loc_register_cat_change_cb(category_change_cb);
+	rc = loc_register_cat_change_cb(category_change_cb, NULL);
 	if (rc != EOK) {
 		printf("%s: Failed to register category change callback\n", NAME);
Index: uspace/srv/hid/input/input.c
===================================================================
--- uspace/srv/hid/input/input.c	(revision da680b4b4a258b7464a3f60a90d226a51447f783)
+++ uspace/srv/hid/input/input.c	(revision d054ad327ffe0b12fea2dcc17f0711048959b7b2)
@@ -818,5 +818,5 @@
 }
 
-static void cat_change_cb(void)
+static void cat_change_cb(void *arg)
 {
 	dev_check_new();
@@ -826,5 +826,5 @@
 static errno_t input_start_dev_discovery(void)
 {
-	errno_t rc = loc_register_cat_change_cb(cat_change_cb);
+	errno_t rc = loc_register_cat_change_cb(cat_change_cb, NULL);
 	if (rc != EOK) {
 		printf("%s: Failed registering callback for device discovery: "
Index: uspace/srv/hid/output/port/chardev.c
===================================================================
--- uspace/srv/hid/output/port/chardev.c	(revision da680b4b4a258b7464a3f60a90d226a51447f783)
+++ uspace/srv/hid/output/port/chardev.c	(revision d054ad327ffe0b12fea2dcc17f0711048959b7b2)
@@ -155,5 +155,5 @@
  * fibril blocked in chardev_init().
  */
-static void check_for_dev(void)
+static void check_for_dev(void *arg)
 {
 	errno_t rc;
@@ -236,5 +236,5 @@
 	}
 
-	rc = loc_register_cat_change_cb(check_for_dev);
+	rc = loc_register_cat_change_cb(check_for_dev, NULL);
 	if (rc != EOK) {
 		printf("%s: Failed to register callback for device discovery.\n",
@@ -243,5 +243,5 @@
 	}
 
-	check_for_dev();
+	check_for_dev(NULL);
 
 	fibril_mutex_lock(&discovery_lock);
Index: uspace/srv/net/ethip/ethip_nic.c
===================================================================
--- uspace/srv/net/ethip/ethip_nic.c	(revision da680b4b4a258b7464a3f60a90d226a51447f783)
+++ uspace/srv/net/ethip/ethip_nic.c	(revision d054ad327ffe0b12fea2dcc17f0711048959b7b2)
@@ -224,5 +224,5 @@
 }
 
-static void ethip_nic_cat_change_cb(void)
+static void ethip_nic_cat_change_cb(void *arg)
 {
 	(void) ethip_nic_check_new();
@@ -323,5 +323,5 @@
 errno_t ethip_nic_discovery_start(void)
 {
-	errno_t rc = loc_register_cat_change_cb(ethip_nic_cat_change_cb);
+	errno_t rc = loc_register_cat_change_cb(ethip_nic_cat_change_cb, NULL);
 	if (rc != EOK) {
 		log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering callback for NIC "
Index: uspace/srv/net/nconfsrv/iplink.c
===================================================================
--- uspace/srv/net/nconfsrv/iplink.c	(revision da680b4b4a258b7464a3f60a90d226a51447f783)
+++ uspace/srv/net/nconfsrv/iplink.c	(revision d054ad327ffe0b12fea2dcc17f0711048959b7b2)
@@ -170,5 +170,5 @@
 }
 
-static void ncs_link_cat_change_cb(void)
+static void ncs_link_cat_change_cb(void *arg)
 {
 	(void) ncs_link_check_new();
@@ -179,5 +179,5 @@
 	errno_t rc;
 
-	rc = loc_register_cat_change_cb(ncs_link_cat_change_cb);
+	rc = loc_register_cat_change_cb(ncs_link_cat_change_cb, NULL);
 	if (rc != EOK) {
 		log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering callback for IP link "
Index: uspace/srv/volsrv/part.c
===================================================================
--- uspace/srv/volsrv/part.c	(revision da680b4b4a258b7464a3f60a90d226a51447f783)
+++ uspace/srv/volsrv/part.c	(revision d054ad327ffe0b12fea2dcc17f0711048959b7b2)
@@ -35,12 +35,13 @@
  */
 
-#include <stdbool.h>
+#include <adt/list.h>
 #include <errno.h>
-#include <str_error.h>
 #include <fibril_synch.h>
 #include <io/log.h>
 #include <loc.h>
+#include <stdbool.h>
 #include <stdlib.h>
 #include <str.h>
+#include <str_error.h>
 #include <vfs/vfs.h>
 
@@ -50,10 +51,8 @@
 #include "types/part.h"
 
-static errno_t vol_part_add_locked(service_id_t);
+static errno_t vol_part_add_locked(vol_parts_t *, service_id_t);
 static void vol_part_remove_locked(vol_part_t *);
-static errno_t vol_part_find_by_id_ref_locked(service_id_t, vol_part_t **);
-
-static LIST_INITIALIZE(vol_parts); /* of vol_part_t */
-static FIBRIL_MUTEX_INITIALIZE(vol_parts_lock);
+static errno_t vol_part_find_by_id_ref_locked(vol_parts_t *, service_id_t,
+    vol_part_t **);
 
 struct fsname_type {
@@ -87,5 +86,5 @@
 
 /** Check for new and removed partitions */
-static errno_t vol_part_check_new(void)
+static errno_t vol_part_check_new(vol_parts_t *parts)
 {
 	bool already_known;
@@ -98,10 +97,10 @@
 	errno_t rc;
 
-	fibril_mutex_lock(&vol_parts_lock);
+	fibril_mutex_lock(&parts->lock);
 
 	rc = loc_category_get_id("partition", &part_cat, IPC_FLAG_BLOCKING);
 	if (rc != EOK) {
 		log_msg(LOG_DEFAULT, LVL_ERROR, "Failed resolving category 'partition'.");
-		fibril_mutex_unlock(&vol_parts_lock);
+		fibril_mutex_unlock(&parts->lock);
 		return ENOENT;
 	}
@@ -111,5 +110,5 @@
 		log_msg(LOG_DEFAULT, LVL_ERROR, "Failed getting list of partition "
 		    "devices.");
-		fibril_mutex_unlock(&vol_parts_lock);
+		fibril_mutex_unlock(&parts->lock);
 		return EIO;
 	}
@@ -120,5 +119,5 @@
 
 		// XXX Make this faster
-		list_foreach(vol_parts, lparts, vol_part_t, part) {
+		list_foreach(parts->parts, lparts, vol_part_t, part) {
 			if (part->svc_id == svcs[i]) {
 				already_known = true;
@@ -130,5 +129,5 @@
 			log_msg(LOG_DEFAULT, LVL_NOTE, "Found partition '%lu'",
 			    (unsigned long) svcs[i]);
-			rc = vol_part_add_locked(svcs[i]);
+			rc = vol_part_add_locked(parts, svcs[i]);
 			if (rc != EOK) {
 				log_msg(LOG_DEFAULT, LVL_ERROR, "Could not add "
@@ -139,7 +138,7 @@
 
 	/* Check for removed partitions */
-	cur = list_first(&vol_parts);
+	cur = list_first(&parts->parts);
 	while (cur != NULL) {
-		next = list_next(cur, &vol_parts);
+		next = list_next(cur, &parts->parts);
 		part = list_get_instance(cur, vol_part_t, lparts);
 
@@ -164,5 +163,5 @@
 	free(svcs);
 
-	fibril_mutex_unlock(&vol_parts_lock);
+	fibril_mutex_unlock(&parts->lock);
 	return EOK;
 }
@@ -180,4 +179,5 @@
 	atomic_set(&part->refcnt, 1);
 	link_initialize(&part->lparts);
+	part->parts = NULL;
 	part->pcnt = vpc_empty;
 
@@ -206,5 +206,5 @@
 	log_msg(LOG_DEFAULT, LVL_NOTE, "Probe partition %s", part->svc_name);
 
-	assert(fibril_mutex_is_locked(&vol_parts_lock));
+	assert(fibril_mutex_is_locked(&part->parts->lock));
 
 	fst = &fstab[0];
@@ -324,14 +324,14 @@
 }
 
-static errno_t vol_part_add_locked(service_id_t sid)
+static errno_t vol_part_add_locked(vol_parts_t *parts, service_id_t sid)
 {
 	vol_part_t *part;
 	errno_t rc;
 
-	assert(fibril_mutex_is_locked(&vol_parts_lock));
+	assert(fibril_mutex_is_locked(&parts->lock));
 	log_msg(LOG_DEFAULT, LVL_NOTE, "vol_part_add_locked(%zu)", sid);
 
 	/* Check for duplicates */
-	rc = vol_part_find_by_id_ref_locked(sid, &part);
+	rc = vol_part_find_by_id_ref_locked(parts, sid, &part);
 	if (rc == EOK) {
 		vol_part_del_ref(part);
@@ -346,4 +346,5 @@
 
 	part->svc_id = sid;
+	part->parts = parts;
 
 	rc = loc_service_get_name(sid, &part->svc_name);
@@ -361,5 +362,5 @@
 		goto error;
 
-	list_append(&part->lparts, &vol_parts);
+	list_append(&part->lparts, &parts->parts);
 
 	log_msg(LOG_DEFAULT, LVL_NOTE, "Added partition %zu", part->svc_id);
@@ -374,6 +375,7 @@
 static void vol_part_remove_locked(vol_part_t *part)
 {
-	assert(fibril_mutex_is_locked(&vol_parts_lock));
-	log_msg(LOG_DEFAULT, LVL_NOTE, "vol_part_remove_locked(%zu)", part->svc_id);
+	assert(fibril_mutex_is_locked(&part->parts->lock));
+	log_msg(LOG_DEFAULT, LVL_NOTE, "vol_part_remove_locked(%zu)",
+	    part->svc_id);
 
 	list_remove(&part->lparts);
@@ -383,30 +385,51 @@
 }
 
-errno_t vol_part_add(service_id_t sid)
-{
-	errno_t rc;
-
-	fibril_mutex_lock(&vol_parts_lock);
-	rc = vol_part_add_locked(sid);
-	fibril_mutex_unlock(&vol_parts_lock);
+errno_t vol_part_add(vol_parts_t *parts, service_id_t sid)
+{
+	errno_t rc;
+
+	fibril_mutex_lock(&parts->lock);
+	rc = vol_part_add_locked(parts, sid);
+	fibril_mutex_unlock(&parts->lock);
 
 	return rc;
 }
 
-static void vol_part_cat_change_cb(void)
-{
-	(void) vol_part_check_new();
-}
-
-errno_t vol_part_init(void)
-{
-	return EOK;
-}
-
-errno_t vol_part_discovery_start(void)
-{
-	errno_t rc;
-
-	rc = loc_register_cat_change_cb(vol_part_cat_change_cb);
+static void vol_part_cat_change_cb(void *arg)
+{
+	vol_parts_t *parts = (vol_parts_t *) arg;
+
+	(void) vol_part_check_new(parts);
+}
+
+errno_t vol_parts_create(vol_parts_t **rparts)
+{
+	vol_parts_t *parts;
+
+	parts = calloc(1, sizeof(vol_parts_t));
+	if (parts == NULL)
+		return ENOMEM;
+
+	fibril_mutex_initialize(&parts->lock);
+	list_initialize(&parts->parts);
+
+	*rparts = parts;
+	return EOK;
+}
+
+void vol_parts_destroy(vol_parts_t *parts)
+{
+	if (parts == NULL)
+		return;
+
+	assert(list_empty(&parts->parts));
+	free(parts);
+}
+
+errno_t vol_part_discovery_start(vol_parts_t *parts)
+{
+	errno_t rc;
+
+	rc = loc_register_cat_change_cb(vol_part_cat_change_cb, parts);
 	if (rc != EOK) {
 		log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering callback "
@@ -415,27 +438,28 @@
 	}
 
-	return vol_part_check_new();
+	return vol_part_check_new(parts);
 }
 
 /** Get list of partitions as array of service IDs. */
-errno_t vol_part_get_ids(service_id_t *id_buf, size_t buf_size, size_t *act_size)
+errno_t vol_part_get_ids(vol_parts_t *parts, service_id_t *id_buf,
+    size_t buf_size, size_t *act_size)
 {
 	size_t act_cnt;
 	size_t buf_cnt;
 
-	fibril_mutex_lock(&vol_parts_lock);
+	fibril_mutex_lock(&parts->lock);
 
 	buf_cnt = buf_size / sizeof(service_id_t);
 
-	act_cnt = list_count(&vol_parts);
+	act_cnt = list_count(&parts->parts);
 	*act_size = act_cnt * sizeof(service_id_t);
 
 	if (buf_size % sizeof(service_id_t) != 0) {
-		fibril_mutex_unlock(&vol_parts_lock);
+		fibril_mutex_unlock(&parts->lock);
 		return EINVAL;
 	}
 
 	size_t pos = 0;
-	list_foreach(vol_parts, lparts, vol_part_t, part) {
+	list_foreach(parts->parts, lparts, vol_part_t, part) {
 		if (pos < buf_cnt)
 			id_buf[pos] = part->svc_id;
@@ -443,14 +467,14 @@
 	}
 
-	fibril_mutex_unlock(&vol_parts_lock);
-	return EOK;
-}
-
-static errno_t vol_part_find_by_id_ref_locked(service_id_t sid,
-    vol_part_t **rpart)
-{
-	assert(fibril_mutex_is_locked(&vol_parts_lock));
-
-	list_foreach(vol_parts, lparts, vol_part_t, part) {
+	fibril_mutex_unlock(&parts->lock);
+	return EOK;
+}
+
+static errno_t vol_part_find_by_id_ref_locked(vol_parts_t *parts,
+    service_id_t sid, vol_part_t **rpart)
+{
+	assert(fibril_mutex_is_locked(&parts->lock));
+
+	list_foreach(parts->parts, lparts, vol_part_t, part) {
 		if (part->svc_id == sid) {
 			/* Add reference */
@@ -464,11 +488,12 @@
 }
 
-errno_t vol_part_find_by_id_ref(service_id_t sid, vol_part_t **rpart)
-{
-	errno_t rc;
-
-	fibril_mutex_lock(&vol_parts_lock);
-	rc = vol_part_find_by_id_ref_locked(sid, rpart);
-	fibril_mutex_unlock(&vol_parts_lock);
+errno_t vol_part_find_by_id_ref(vol_parts_t *parts, service_id_t sid,
+    vol_part_t **rpart)
+{
+	errno_t rc;
+
+	fibril_mutex_lock(&parts->lock);
+	rc = vol_part_find_by_id_ref_locked(parts, sid, rpart);
+	fibril_mutex_unlock(&parts->lock);
 
 	return rc;
@@ -539,5 +564,5 @@
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "vol_part_mkfs_part()");
 
-	fibril_mutex_lock(&vol_parts_lock);
+	fibril_mutex_lock(&part->parts->lock);
 
 	rc = volsrv_part_mkfs(part->svc_id, fstype, label);
@@ -545,5 +570,5 @@
 		log_msg(LOG_DEFAULT, LVL_DEBUG, "vol_part_mkfs_part() - failed %s",
 		    str_error(rc));
-		fibril_mutex_unlock(&vol_parts_lock);
+		fibril_mutex_unlock(&part->parts->lock);
 		return rc;
 	}
@@ -556,5 +581,5 @@
 	rc = vol_part_probe(part);
 	if (rc != EOK) {
-		fibril_mutex_unlock(&vol_parts_lock);
+		fibril_mutex_unlock(&part->parts->lock);
 		return rc;
 	}
@@ -562,9 +587,9 @@
 	rc = vol_part_mount(part);
 	if (rc != EOK) {
-		fibril_mutex_unlock(&vol_parts_lock);
+		fibril_mutex_unlock(&part->parts->lock);
 		return rc;
 	}
 
-	fibril_mutex_unlock(&vol_parts_lock);
+	fibril_mutex_unlock(&part->parts->lock);
 	return EOK;
 }
Index: uspace/srv/volsrv/part.h
===================================================================
--- uspace/srv/volsrv/part.h	(revision da680b4b4a258b7464a3f60a90d226a51447f783)
+++ uspace/srv/volsrv/part.h	(revision d054ad327ffe0b12fea2dcc17f0711048959b7b2)
@@ -43,9 +43,12 @@
 #include "types/part.h"
 
-extern errno_t vol_part_init(void);
-extern errno_t vol_part_discovery_start(void);
-extern errno_t vol_part_add(service_id_t);
-extern errno_t vol_part_get_ids(service_id_t *, size_t, size_t *);
-extern errno_t vol_part_find_by_id_ref(service_id_t, vol_part_t **);
+extern errno_t vol_parts_create(vol_parts_t **);
+extern void vol_parts_destroy(vol_parts_t *);
+extern errno_t vol_part_discovery_start(vol_parts_t *);
+extern errno_t vol_part_add(vol_parts_t *, service_id_t);
+extern errno_t vol_part_get_ids(vol_parts_t *, service_id_t *, size_t,
+    size_t *);
+extern errno_t vol_part_find_by_id_ref(vol_parts_t *, service_id_t,
+    vol_part_t **);
 extern void vol_part_del_ref(vol_part_t *);
 extern errno_t vol_part_eject_part(vol_part_t *);
Index: uspace/srv/volsrv/types/part.h
===================================================================
--- uspace/srv/volsrv/types/part.h	(revision da680b4b4a258b7464a3f60a90d226a51447f783)
+++ uspace/srv/volsrv/types/part.h	(revision d054ad327ffe0b12fea2dcc17f0711048959b7b2)
@@ -40,4 +40,5 @@
 #include <adt/list.h>
 #include <atomic.h>
+#include <fibril_synch.h>
 #include <stdbool.h>
 #include <types/label.h>
@@ -45,4 +46,6 @@
 /** Partition */
 typedef struct {
+	/** Containing partition list */
+	struct vol_parts *parts;
 	/** Link to vol_parts */
 	link_t lparts;
@@ -65,4 +68,12 @@
 } vol_part_t;
 
+/** Partitions */
+typedef struct vol_parts {
+	/** Synchronize access to list of partitions */
+	fibril_mutex_t lock;
+	/** Partitions (list of vol_part_t) */
+	list_t parts;
+} vol_parts_t;
+
 #endif
 
Index: uspace/srv/volsrv/volsrv.c
===================================================================
--- uspace/srv/volsrv/volsrv.c	(revision da680b4b4a258b7464a3f60a90d226a51447f783)
+++ uspace/srv/volsrv/volsrv.c	(revision d054ad327ffe0b12fea2dcc17f0711048959b7b2)
@@ -57,20 +57,22 @@
 {
 	errno_t rc;
+	vol_parts_t *parts = NULL;
+
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "vol_init()");
 
-	rc = vol_part_init();
+	rc = vol_parts_create(&parts);
 	if (rc != EOK)
-		return rc;
-
-	rc = vol_part_discovery_start();
+		goto error;
+
+	rc = vol_part_discovery_start(parts);
 	if (rc != EOK)
-		return rc;
-
-	async_set_fallback_port_handler(vol_client_conn, NULL);
+		goto error;
+
+	async_set_fallback_port_handler(vol_client_conn, parts);
 
 	rc = loc_server_register(NAME);
 	if (rc != EOK) {
 		log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering server: %s.", str_error(rc));
-		return EEXIST;
+		rc = EEXIST;
 	}
 
@@ -79,11 +81,15 @@
 	if (rc != EOK) {
 		log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service: %s.", str_error(rc));
-		return EEXIST;
+		rc = EEXIST;
+		goto error;
 	}
 
 	return EOK;
-}
-
-static void vol_get_parts_srv(ipc_call_t *icall)
+error:
+	vol_parts_destroy(parts);
+	return rc;
+}
+
+static void vol_get_parts_srv(vol_parts_t *parts, ipc_call_t *icall)
 {
 	ipc_call_t call;
@@ -105,5 +111,5 @@
 	}
 
-	rc = vol_part_get_ids(id_buf, size, &act_size);
+	rc = vol_part_get_ids(parts, id_buf, size, &act_size);
 	if (rc != EOK) {
 		async_answer_0(&call, rc);
@@ -118,21 +124,21 @@
 }
 
-static void vol_part_add_srv(ipc_call_t *icall)
-{
-	service_id_t sid;
-	errno_t rc;
-
-	sid = IPC_GET_ARG1(*icall);
-
-	rc = vol_part_add(sid);
-	if (rc != EOK) {
-		async_answer_0(icall, rc);
-		return;
-	}
-
-	async_answer_0(icall, EOK);
-}
-
-static void vol_part_info_srv(ipc_call_t *icall)
+static void vol_part_add_srv(vol_parts_t *parts, ipc_call_t *icall)
+{
+	service_id_t sid;
+	errno_t rc;
+
+	sid = IPC_GET_ARG1(*icall);
+
+	rc = vol_part_add(parts, sid);
+	if (rc != EOK) {
+		async_answer_0(icall, rc);
+		return;
+	}
+
+	async_answer_0(icall, EOK);
+}
+
+static void vol_part_info_srv(vol_parts_t *parts, ipc_call_t *icall)
 {
 	service_id_t sid;
@@ -144,5 +150,5 @@
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "vol_part_info_srv(%zu)",
 	    sid);
-	rc = vol_part_find_by_id_ref(sid, &part);
+	rc = vol_part_find_by_id_ref(parts, sid, &part);
 	if (rc != EOK) {
 		async_answer_0(icall, ENOENT);
@@ -183,5 +189,5 @@
 }
 
-static void vol_part_eject_srv(ipc_call_t *icall)
+static void vol_part_eject_srv(vol_parts_t *parts, ipc_call_t *icall)
 {
 	service_id_t sid;
@@ -192,5 +198,5 @@
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "vol_part_eject_srv(%zu)", sid);
 
-	rc = vol_part_find_by_id_ref(sid, &part);
+	rc = vol_part_find_by_id_ref(parts, sid, &part);
 	if (rc != EOK) {
 		async_answer_0(icall, ENOENT);
@@ -209,5 +215,5 @@
 }
 
-static void vol_part_empty_srv(ipc_call_t *icall)
+static void vol_part_empty_srv(vol_parts_t *parts, ipc_call_t *icall)
 {
 	service_id_t sid;
@@ -218,5 +224,5 @@
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "vol_part_empty_srv(%zu)", sid);
 
-	rc = vol_part_find_by_id_ref(sid, &part);
+	rc = vol_part_find_by_id_ref(parts, sid, &part);
 	if (rc != EOK) {
 		async_answer_0(icall, ENOENT);
@@ -235,5 +241,5 @@
 }
 
-static void vol_part_get_lsupp_srv(ipc_call_t *icall)
+static void vol_part_get_lsupp_srv(vol_parts_t *parts, ipc_call_t *icall)
 {
 	vol_fstype_t fstype;
@@ -273,5 +279,5 @@
 
 
-static void vol_part_mkfs_srv(ipc_call_t *icall)
+static void vol_part_mkfs_srv(vol_parts_t *parts, ipc_call_t *icall)
 {
 	service_id_t sid;
@@ -298,5 +304,5 @@
 	}
 
-	rc = vol_part_find_by_id_ref(sid, &part);
+	rc = vol_part_find_by_id_ref(parts, sid, &part);
 	if (rc != EOK) {
 		free(label);
@@ -319,4 +325,6 @@
 static void vol_client_conn(ipc_call_t *icall, void *arg)
 {
+	vol_parts_t *parts = (vol_parts_t *) arg;
+
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "vol_client_conn()");
 
@@ -337,23 +345,23 @@
 		switch (method) {
 		case VOL_GET_PARTS:
-			vol_get_parts_srv(&call);
+			vol_get_parts_srv(parts, &call);
 			break;
 		case VOL_PART_ADD:
-			vol_part_add_srv(&call);
+			vol_part_add_srv(parts, &call);
 			break;
 		case VOL_PART_INFO:
-			vol_part_info_srv(&call);
+			vol_part_info_srv(parts, &call);
 			break;
 		case VOL_PART_EJECT:
-			vol_part_eject_srv(&call);
+			vol_part_eject_srv(parts, &call);
 			break;
 		case VOL_PART_EMPTY:
-			vol_part_empty_srv(&call);
+			vol_part_empty_srv(parts, &call);
 			break;
 		case VOL_PART_LSUPP:
-			vol_part_get_lsupp_srv(&call);
+			vol_part_get_lsupp_srv(parts, &call);
 			break;
 		case VOL_PART_MKFS:
-			vol_part_mkfs_srv(&call);
+			vol_part_mkfs_srv(parts, &call);
 			break;
 		default: