Index: uspace/lib/c/generic/tls.c
===================================================================
--- uspace/lib/c/generic/tls.c	(revision 85f7369aa7a378fe5b780d408f8290b7f07f2afe)
+++ uspace/lib/c/generic/tls.c	(revision ac310404db41765a81048fa21177f6268343d8a6)
@@ -42,4 +42,5 @@
 #include <str.h>
 #include <align.h>
+#include <unistd.h>
 
 /** Create TLS (Thread Local Storage) data structures.
@@ -57,4 +58,6 @@
 	
 	tcb = __alloc_tls(&data, tls_size);
+	if (!tcb)
+		return NULL;
 	
 	/*
@@ -89,5 +92,8 @@
 
 	result = malloc(sizeof(tcb_t) + size);
+	if (!result)
+		return NULL;
 	*data = ((void *)result) + sizeof(tcb_t);
+
 	return result;
 }
@@ -118,5 +124,6 @@
 	size = ALIGN_UP(size, &_tls_alignment);
 	*data = memalign((uintptr_t) &_tls_alignment, sizeof(tcb_t) + size);
-
+	if (!*data)
+		return NULL;
 	tcb = (tcb_t *) (*data + size);
 	tcb->self = tcb;
Index: uspace/srv/fs/udf/udf_cksum.c
===================================================================
--- uspace/srv/fs/udf/udf_cksum.c	(revision 85f7369aa7a378fe5b780d408f8290b7f07f2afe)
+++ uspace/srv/fs/udf/udf_cksum.c	(revision ac310404db41765a81048fa21177f6268343d8a6)
@@ -73,17 +73,4 @@
 };
 
-/** Calculate CRC16
- *
- */
-uint16_t udf_cksum(uint8_t *buf, size_t len)
-{
-	uint16_t crc = 0;
-	
-	while (len-- > 0)
-		crc = crc_table[(crc >> 8 ^ *buf++) & 0xff] ^ (crc << 8);
-	
-	return crc;
-}
-
 /** Unicode checksum
  *
@@ -103,24 +90,4 @@
 	
 	return crc;
-}
-
-/** EA checksum
- *
- * Calculate a 16-bit checksum of the Implementation Use
- * Extended Attribute header or Application Use Extended Attribute
- * header. The fields AttributeType through ImplementationIdentifier
- * (or ApplicationIdentifier) inclusively represent the
- * data covered by the checksum (48 bytes).
- *
- */
-uint16_t udf_ea_cksum(uint8_t *data)
-{
-	uint16_t checksum = 0;
-	size_t count;
-	
-	for (count = 0; count < 48; count++)
-		checksum += *data++;
-	
-	return checksum;
 }
 
Index: uspace/srv/fs/udf/udf_cksum.h
===================================================================
--- uspace/srv/fs/udf/udf_cksum.h	(revision 85f7369aa7a378fe5b780d408f8290b7f07f2afe)
+++ uspace/srv/fs/udf/udf_cksum.h	(revision ac310404db41765a81048fa21177f6268343d8a6)
@@ -39,7 +39,5 @@
 #define UDF_TAG_SIZE  16
 
-extern uint16_t udf_cksum(uint8_t *, size_t);
 extern uint16_t udf_unicode_cksum(uint16_t *, size_t);
-extern uint16_t udf_ea_cksum(uint8_t *);
 extern uint8_t udf_tag_checksum(uint8_t *);
 
Index: uspace/srv/fs/udf/udf_file.c
===================================================================
--- uspace/srv/fs/udf/udf_file.c	(revision 85f7369aa7a378fe5b780d408f8290b7f07f2afe)
+++ uspace/srv/fs/udf/udf_file.c	(revision ac310404db41765a81048fa21177f6268343d8a6)
@@ -57,5 +57,5 @@
  *
  */
-int udf_read_extended_allocator(udf_node_t *node, uint16_t icb_flag,
+static int udf_read_extended_allocator(udf_node_t *node, uint16_t icb_flag,
     uint32_t pos)
 {
@@ -185,5 +185,5 @@
 			 */
 			if (FLE32(long_d->length) >> 30 == 3) {
-				udf_read_extended_allocator (node, icb_flag, pos_long_ad);
+				udf_read_extended_allocator(node, icb_flag, pos_long_ad);
 				break;
 			}
@@ -296,116 +296,4 @@
 }
 
-/** Read ICB sequence of allocators in Unallocated space entry descriptor
- *
- * This function read ICB sequence if free space is saved by space table.
- * Not finished.
- *
- * @param uased       Unallocated space entry descriptor
- * @param icb_flag    Type of allocators in sequence.
- *                    According to ECMA 167 4/14.8.8
- * @param start_alloc Offset of the allocator
- * @param len         Length of sequence
- *
- * @return EOK on success or a negative error code.
- *
- */
-int udf_read_free_space(uint8_t *uased, uint16_t icb_flag,
-    uint32_t start_alloc, uint32_t len)
-{
-	switch (icb_flag) {
-	case UDF_SHORT_AD:
-		log_msg(LVL_DEBUG,
-		    "UAICB: sequence of allocation descriptors - icbflag = short_ad_t");
-		
-		/* Identify number of current partition */
-		
-		size_t cnt = len / sizeof(udf_short_ad_t);
-		size_t n = 0;
-		
-		while (n < cnt) {
-			udf_short_ad_t *short_d =
-			    (udf_short_ad_t *) (uased + start_alloc + n * sizeof(udf_short_ad_t));
-			
-			if (short_d->length == 0)
-				break;
-			
-			n++;
-		}
-		
-		break;
-		
-	case UDF_LONG_AD:
-		log_msg(LVL_DEBUG,
-		    "UAICB: sequence of allocation descriptors - icbflag = long_ad_t");
-		
-		cnt = len / sizeof(udf_long_ad_t);
-		n = 0;
-		
-		while (n < cnt) {
-			udf_long_ad_t *long_d =
-			    (udf_long_ad_t *) (uased + start_alloc + n * sizeof(udf_long_ad_t));
-			
-			if (long_d->length == 0)
-				break;
-			
-			n++;
-		}
-		
-		break;
-		
-	case UDF_EXTENDED_AD:
-		log_msg(LVL_DEBUG,
-		    "UAICB: sequence of allocation descriptors - icbflag = extended_ad_t");
-		break;
-		
-	case UDF_DATA_AD:
-		log_msg(LVL_DEBUG,
-		    "UAICB: sequence of allocation descriptors - icbflag = 3, node contains data itself");
-		break;
-	}
-	
-	return EOK;
-}
-
-/** Read Unallocated space entry descriptor
- *
- * Read ICB sequence if free space is saved by space table.
- * Not finished.
- *
- */
-int udf_read_unallocated_space_entry(udf_instance_t * instance, uint64_t pos,
-    uint32_t len)
-{
-	block_t *block = NULL;
-	int rc = block_get(&block, instance->service_id, pos, BLOCK_FLAGS_NONE);
-	if (rc != EOK)
-		return rc;
-	
-	udf_descriptor_tag_t *desc = (udf_descriptor_tag_t *) block->data;
-	if (desc->checksum != udf_tag_checksum((uint8_t *) desc)) {
-		block_put(block);
-		return EINVAL;
-	}
-	
-	if (FLE16(desc->id) != UDF_UASPACE_ENTRY) {
-		// FIXME: Memory leak
-		return EINVAL;
-	}
-	
-	udf_unallocated_space_entry_descriptor_t *uased =
-	    (udf_unallocated_space_entry_descriptor_t *) block->data;
-	if (uased->icbtag.file_type != UDF_ICBTYPE_UASE) {
-		// FIXME: Memory leak
-		return EINVAL;
-	}
-	
-	uint16_t icb_flag = uased->icbtag.flags & UDF_ICBFLAG_MASK;
-	
-	rc = udf_read_free_space((uint8_t *) uased, icb_flag,
-	    UDF_UASE_OFFSET, uased->ad_lenght);
-	
-	return block_put(block);
-}
-
 /** Read data from disk - filling UDF node by allocators
  *
@@ -419,23 +307,4 @@
 	node->link_cnt = 1;
 	return udf_read_icb(node);
-}
-
-/** Read directory entry
- *
- * @param fid   Returned value
- * @param block Returned value
- * @param node  UDF node
- * @param pos   Number of FID which we need to find
- *
- * @return EOK on success or a negative error code.
- *
- */
-int udf_get_fid(udf_file_identifier_descriptor_t **fid, block_t **block,
-    udf_node_t *node, aoff64_t pos)
-{
-	if (node->data == NULL)
-		return udf_get_fid_in_allocator(fid, block, node, pos);
-	
-	return udf_get_fid_in_data(fid, node, pos);
 }
 
@@ -449,5 +318,5 @@
  *
  */
-int udf_get_fid_in_data(udf_file_identifier_descriptor_t **fid,
+static int udf_get_fid_in_data(udf_file_identifier_descriptor_t **fid,
     udf_node_t *node, aoff64_t pos)
 {
@@ -488,4 +357,23 @@
 	
 	return ENOENT;
+}
+
+/** Read directory entry
+ *
+ * @param fid   Returned value
+ * @param block Returned value
+ * @param node  UDF node
+ * @param pos   Number of FID which we need to find
+ *
+ * @return EOK on success or a negative error code.
+ *
+ */
+int udf_get_fid(udf_file_identifier_descriptor_t **fid, block_t **block,
+    udf_node_t *node, aoff64_t pos)
+{
+	if (node->data == NULL)
+		return udf_get_fid_in_allocator(fid, block, node, pos);
+	
+	return udf_get_fid_in_data(fid, node, pos);
 }
 
Index: uspace/srv/fs/udf/udf_file.h
===================================================================
--- uspace/srv/fs/udf/udf_file.h	(revision 85f7369aa7a378fe5b780d408f8290b7f07f2afe)
+++ uspace/srv/fs/udf/udf_file.h	(revision ac310404db41765a81048fa21177f6268343d8a6)
@@ -197,10 +197,7 @@
 extern int udf_read_allocation_sequence(udf_node_t *, uint8_t *, uint16_t,
     uint32_t, uint32_t);
-extern int udf_read_extended_allocator(udf_node_t *, uint16_t, uint32_t);
 extern int udf_read_file(size_t *, ipc_callid_t, udf_node_t *, aoff64_t,
     size_t);
 extern int udf_get_fid(udf_file_identifier_descriptor_t **, block_t **,
-    udf_node_t *, aoff64_t);
-extern int udf_get_fid_in_data(udf_file_identifier_descriptor_t **,
     udf_node_t *, aoff64_t);
 extern int udf_get_fid_in_allocator(udf_file_identifier_descriptor_t **,
@@ -208,7 +205,4 @@
 extern int udf_get_fid_in_sector(udf_file_identifier_descriptor_t **,
     block_t **, udf_node_t *, aoff64_t, size_t *, void **, size_t *);
-extern int udf_read_free_space(uint8_t *, uint16_t, uint32_t, uint32_t);
-extern int udf_read_unallocated_space_entry(udf_instance_t *, uint64_t,
-    uint32_t);
 
 #endif /* UDF_FILE_H_ */
Index: uspace/srv/fs/udf/udf_osta.c
===================================================================
--- uspace/srv/fs/udf/udf_osta.c	(revision 85f7369aa7a378fe5b780d408f8290b7f07f2afe)
+++ uspace/srv/fs/udf/udf_osta.c	(revision ac310404db41765a81048fa21177f6268343d8a6)
@@ -96,6 +96,6 @@
  *
  */
-size_t udf_uncompress_unicode(size_t number_of_bytes, uint8_t *udf_compressed,
-    uint16_t *unicode, size_t unicode_max_len)
+static size_t udf_uncompress_unicode(size_t number_of_bytes,
+    uint8_t *udf_compressed, uint16_t *unicode, size_t unicode_max_len)
 {
 	/* Use udf_compressed to store current byte being read. */
@@ -129,54 +129,4 @@
 	
 	return unicode_idx;
-}
-
-/** Convert Unicode wide characters to OSTA CS0 compressed Unicode string.
- *
- * The Unicode MUST be in the byte order of the compiler in order
- * to obtain correct results. Returns an error if the compression ID
- * is invalid.
- *
- * NOTE: This routine assumes the implementation already knows,
- * by the local environment, how many bits are appropriate and therefore
- * does no checking to test if the input characters fit into that number
- * of bits or not.
- *
- * @param[in]  number_of_chars Number of unicode characters.
- * @param[in]  comp_id         Compression ID to be used.
- * @param[in]  unicode         Unicode characters to compress.
- * @param[out] udf_compressed  Compressed string, as bytes.
- *
- * @return The total number of bytes in the compressed OSTA CS0 string,
- *         including the compression ID.
- *
- */
-size_t udf_compress_unicode(size_t number_of_chars, uint8_t comp_id,
-    uint16_t *unicode, uint8_t *udf_compressed)
-{
-	if ((comp_id != 8) && (comp_id != 16))
-		return 0;
-	
-	/* Place compression code in first byte. */
-	udf_compressed[0] = comp_id;
-	
-	size_t byte_idx = 1;
-	size_t unicode_idx = 0;
-	
-	while (unicode_idx < number_of_chars) {
-		if (comp_id == 16) {
-			/*
-			 * First, place the high bits of the char
-			 * into the byte stream.
-			 */
-			udf_compressed[byte_idx++] =
-			    (unicode[unicode_idx] & 0xFF00) >> 8;
-		}
-		
-		/* Then place the low bits into the stream. */
-		udf_compressed[byte_idx++] = unicode[unicode_idx] & 0x00FF;
-		unicode_idx++;
-	}
-	
-	return byte_idx;
 }
 
Index: uspace/srv/fs/udf/udf_osta.h
===================================================================
--- uspace/srv/fs/udf/udf_osta.h	(revision 85f7369aa7a378fe5b780d408f8290b7f07f2afe)
+++ uspace/srv/fs/udf/udf_osta.h	(revision ac310404db41765a81048fa21177f6268343d8a6)
@@ -52,6 +52,4 @@
 #define PERIOD             0x002E
 
-extern size_t udf_uncompress_unicode(size_t, uint8_t *, uint16_t *, size_t);
-extern size_t udf_compress_unicode(size_t, uint8_t, uint16_t *, uint8_t *);
 extern size_t udf_translate_name(uint16_t *, uint16_t *, size_t);
 extern void udf_to_unix_name(char *, size_t, char *, size_t, udf_charspec_t *);
Index: uspace/srv/fs/udf/udf_types.h
===================================================================
--- uspace/srv/fs/udf/udf_types.h	(revision 85f7369aa7a378fe5b780d408f8290b7f07f2afe)
+++ uspace/srv/fs/udf/udf_types.h	(revision ac310404db41765a81048fa21177f6268343d8a6)
@@ -142,6 +142,4 @@
 } __attribute__((packed)) udf_unallocated_space_descriptor_t;
 
-extern void udf_prepare_tag(udf_descriptor_tag_t *);
-
 #endif
 
Index: uspace/srv/fs/udf/udf_volume.c
===================================================================
--- uspace/srv/fs/udf/udf_volume.c	(revision 85f7369aa7a378fe5b780d408f8290b7f07f2afe)
+++ uspace/srv/fs/udf/udf_volume.c	(revision ac310404db41765a81048fa21177f6268343d8a6)
@@ -151,5 +151,5 @@
  *
  */
-void udf_prepare_tag(udf_descriptor_tag_t *tag)
+static void udf_prepare_tag(udf_descriptor_tag_t *tag)
 {
 	GET_LE16(tag->id);
@@ -159,4 +159,39 @@
 	GET_LE16(tag->descriptor_crc_length);
 	GET_LE32(tag->location);
+}
+
+/** Read AVD by using one of default sector size from array
+ *
+ * @param service_id
+ * @param avd         Returned value - Anchor Volume Descriptor
+ * @param sector_size Expected sector size
+ *
+ * @return EOK on success or a negative error code.
+ *
+ */
+static int udf_get_anchor_volume_descriptor_by_ssize(service_id_t service_id,
+    udf_anchor_volume_descriptor_t *avd, uint32_t sector_size)
+{
+	int rc = block_read_bytes_direct(service_id,
+	    UDF_AVDP_SECTOR * sector_size,
+	    sizeof(udf_anchor_volume_descriptor_t), avd);
+	if (rc != EOK)
+		return rc;
+	
+	if (avd->tag.checksum != udf_tag_checksum((uint8_t *) &avd->tag))
+		return EINVAL;
+	
+	// TODO: Should be tested in big-endian mode
+	udf_prepare_tag(&avd->tag);
+	
+	if (avd->tag.id != UDF_TAG_AVDP)
+		return EINVAL;
+	
+	GET_LE32(avd->main_extent.length);
+	GET_LE32(avd->main_extent.location);
+	GET_LE32(avd->reserve_extent.length);
+	GET_LE32(avd->reserve_extent.location);
+	
+	return EOK;
 }
 
@@ -200,39 +235,4 @@
 	
 	return EINVAL;
-}
-
-/** Read AVD by using one of default sector size from array
- *
- * @param service_id
- * @param avd         Returned value - Anchor Volume Descriptor
- * @param sector_size Expected sector size
- *
- * @return EOK on success or a negative error code.
- *
- */
-int udf_get_anchor_volume_descriptor_by_ssize(service_id_t service_id,
-    udf_anchor_volume_descriptor_t *avd, uint32_t sector_size)
-{
-	int rc = block_read_bytes_direct(service_id,
-	    UDF_AVDP_SECTOR * sector_size,
-	    sizeof(udf_anchor_volume_descriptor_t), avd);
-	if (rc != EOK)
-		return rc;
-	
-	if (avd->tag.checksum != udf_tag_checksum((uint8_t *) &avd->tag))
-		return EINVAL;
-	
-	// TODO: Should be tested in BegEndian mode
-	udf_prepare_tag(&avd->tag);
-	
-	if (avd->tag.id != UDF_TAG_AVDP)
-		return EINVAL;
-	
-	GET_LE32(avd->main_extent.length);
-	GET_LE32(avd->main_extent.location);
-	GET_LE32(avd->reserve_extent.length);
-	GET_LE32(avd->reserve_extent.location);
-	
-	return EOK;
 }
 
Index: uspace/srv/fs/udf/udf_volume.h
===================================================================
--- uspace/srv/fs/udf/udf_volume.h	(revision 85f7369aa7a378fe5b780d408f8290b7f07f2afe)
+++ uspace/srv/fs/udf/udf_volume.h	(revision ac310404db41765a81048fa21177f6268343d8a6)
@@ -215,6 +215,4 @@
 extern int udf_get_anchor_volume_descriptor(service_id_t,
     udf_anchor_volume_descriptor_t *);
-extern int udf_get_anchor_volume_descriptor_by_ssize(service_id_t,
-    udf_anchor_volume_descriptor_t *, uint32_t);
 extern int udf_read_volume_descriptor_sequence(service_id_t, udf_extent_t);
 extern fs_index_t udf_long_ad_to_pos(udf_instance_t *, udf_long_ad_t *);
