Index: uspace/lib/c/generic/sort.c
===================================================================
--- uspace/lib/c/generic/sort.c	(revision 172aad63f50c7c155cabbf9d2f577f1d906b7262)
+++ uspace/lib/c/generic/sort.c	(revision 50f4b9515d8379359f3deeb824cd9361eefed873)
@@ -36,5 +36,5 @@
  *
  * This files contains functions implementing several sorting
- * algorithms (e.g. quick sort and bubble sort).
+ * algorithms (e.g. quick sort and gnome sort).
  *
  */
@@ -44,7 +44,20 @@
 #include <malloc.h>
 
-/** Bubble sort
- *
- * Apply generic bubble sort algorithm on supplied data,
+/** Immediate buffer size.
+ *
+ * For small buffer sizes avoid doing malloc()
+ * and use the stack.
+ *
+ */
+#define IBUF_SIZE  32
+
+/** Array accessor.
+ *
+ */
+#define INDEX(buf, i, elem_size)  ((buf) + (i) * (elem_size))
+
+/** Gnome sort
+ *
+ * Apply generic gnome sort algorithm on supplied data,
  * using pre-allocated buffer.
  *
@@ -58,22 +71,20 @@
  *
  */
-static void _bsort(void *data, size_t cnt, size_t elem_size, sort_cmp_t cmp,
+static void _gsort(void *data, size_t cnt, size_t elem_size, sort_cmp_t cmp,
     void *arg, void *slot)
 {
-	bool done = false;
-	void *tmp;
-	
-	while (!done) {
-		done = true;
-		
-		for (tmp = data; tmp < data + elem_size * (cnt - 1);
-		    tmp = tmp + elem_size) {
-			if (cmp(tmp, tmp + elem_size, arg) == 1) {
-				memcpy(slot, tmp, elem_size);
-				memcpy(tmp, tmp + elem_size, elem_size);
-				memcpy(tmp + elem_size, slot, elem_size);
-				done = false;
-			}
-		}
+	size_t i = 0;
+	
+	while (i < cnt) {
+		if ((i != 0) &&
+		    (cmp(INDEX(data, i, elem_size),
+		    INDEX(data, i - 1, elem_size), arg) == -1)) {
+			memcpy(slot, INDEX(data, i, elem_size), elem_size);
+			memcpy(INDEX(data, i, elem_size), INDEX(data, i - 1, elem_size),
+			    elem_size);
+			memcpy(INDEX(data, i - 1, elem_size), slot, elem_size);
+			i--;
+		} else
+			i++;
 	}
 }
@@ -89,5 +100,5 @@
  * @param cmp       Comparator function.
  * @param arg       3rd argument passed to cmp.
- * @param tmp       Pointer to scratch memory buffer
+ * @param slot      Pointer to scratch memory buffer
  *                  elem_size bytes long.
  * @param pivot     Pointer to scratch memory buffer
@@ -96,5 +107,5 @@
  */
 static void _qsort(void *data, size_t cnt, size_t elem_size, sort_cmp_t cmp,
-    void *arg, void *tmp, void *pivot)
+    void *arg, void *slot, void *pivot)
 {
 	if (cnt > 4) {
@@ -105,31 +116,31 @@
 		
 		while (true) {
-			while ((cmp(data + i * elem_size, pivot, arg) < 0) && (i < cnt))
+			while ((cmp(INDEX(data, i, elem_size), pivot, arg) < 0) && (i < cnt))
 				i++;
 			
-			while ((cmp(data + j * elem_size, pivot, arg) >= 0) && (j > 0))
+			while ((cmp(INDEX(data, j, elem_size), pivot, arg) >= 0) && (j > 0))
 				j--;
 			
 			if (i < j) {
-				memcpy(tmp, data + i * elem_size, elem_size);
-				memcpy(data + i * elem_size, data + j * elem_size,
+				memcpy(slot, INDEX(data, i, elem_size), elem_size);
+				memcpy(INDEX(data, i, elem_size), INDEX(data, j, elem_size),
 				    elem_size);
-				memcpy(data + j * elem_size, tmp, elem_size);
+				memcpy(INDEX(data, j, elem_size), slot, elem_size);
 			} else
 				break;
 		}
 		
-		_qsort(data, j + 1, elem_size, cmp, arg, tmp, pivot);
-		_qsort(data + (j + 1) * elem_size, cnt - j - 1, elem_size,
-		    cmp, arg, tmp, pivot);
+		_qsort(data, j + 1, elem_size, cmp, arg, slot, pivot);
+		_qsort(INDEX(data, j + 1, elem_size), cnt - j - 1, elem_size,
+		    cmp, arg, slot, pivot);
 	} else
-		_bsort(data, cnt, elem_size, cmp, arg, tmp);
-}
-
-/** Bubble sort wrapper
+		_gsort(data, cnt, elem_size, cmp, arg, slot);
+}
+
+/** Gnome sort wrapper
  *
  * This is only a wrapper that takes care of memory
  * allocations for storing the slot element for generic
- * bubble sort algorithm.
+ * gnome sort algorithm.
  *
  * @param data      Pointer to data to be sorted.
@@ -142,13 +153,20 @@
  *
  */
-bool bsort(void *data, size_t cnt, size_t elem_size, sort_cmp_t cmp, void *arg)
-{
-	void *slot = (void *) malloc(elem_size);
-	if (!slot)
-		return false;
-	
-	_bsort(data, cnt, elem_size, cmp, arg, slot);
-	
-	free(slot);
+bool gsort(void *data, size_t cnt, size_t elem_size, sort_cmp_t cmp, void *arg)
+{
+	uint8_t ibuf_slot[IBUF_SIZE];
+	void *slot;
+	
+	if (elem_size > IBUF_SIZE) {
+		slot = (void *) malloc(elem_size);
+		if (!slot)
+			return false;
+	} else
+		slot = (void *) ibuf_slot;
+	
+	_gsort(data, cnt, elem_size, cmp, arg, slot);
+	
+	if (elem_size > IBUF_SIZE)
+		free(slot);
 	
 	return true;
@@ -172,18 +190,30 @@
 bool qsort(void *data, size_t cnt, size_t elem_size, sort_cmp_t cmp, void *arg)
 {
-	void *tmp = (void *) malloc(elem_size);
-	if (!tmp)
-		return false;
-	
-	void *pivot = (void *) malloc(elem_size);
-	if (!pivot) {
-		free(tmp);
-		return false;
+	uint8_t ibuf_slot[IBUF_SIZE];
+	uint8_t ibuf_pivot[IBUF_SIZE];
+	void *slot;
+	void *pivot;
+	
+	if (elem_size > IBUF_SIZE) {
+		slot = (void *) malloc(elem_size);
+		if (!slot)
+			return false;
+		
+		pivot = (void *) malloc(elem_size);
+		if (!pivot) {
+			free(slot);
+			return false;
+		}
+	} else {
+		slot = (void *) ibuf_slot;
+		pivot = (void *) ibuf_pivot;
 	}
 	
-	_qsort(data, cnt, elem_size, cmp, arg, tmp, pivot);
-	
-	free(pivot);
-	free(tmp);
+	_qsort(data, cnt, elem_size, cmp, arg, slot, pivot);
+	
+	if (elem_size > IBUF_SIZE) {
+		free(pivot);
+		free(slot);
+	}
 	
 	return true;
Index: uspace/lib/c/include/sort.h
===================================================================
--- uspace/lib/c/include/sort.h	(revision 172aad63f50c7c155cabbf9d2f577f1d906b7262)
+++ uspace/lib/c/include/sort.h	(revision 50f4b9515d8379359f3deeb824cd9361eefed873)
@@ -41,5 +41,5 @@
 typedef int (* sort_cmp_t)(void *, void *, void *);
 
-extern bool bsort(void *, size_t, size_t, sort_cmp_t, void *);
+extern bool gsort(void *, size_t, size_t, sort_cmp_t, void *);
 extern bool qsort(void *, size_t, size_t, sort_cmp_t, void *);