hg_malloc: report free as the room left to carve, not size minus live

free was size minus the live figure, which reads ~95% available on a
256M arena regardless of load and barely moves. Worse, it is optimistic
in the direction that matters: carved-but-recycled cells are reusable
only within their own size class, so free can report hundreds of MB
while an allocation of a different size fails outright.

Report the uncarved remainder instead, which is what actually predicts
that failure. free + real_used no longer sums to size (real_used is the
live figure); free + carve does. The three figures now answer three
different questions rather than two of them being redundant.

Author: Lt-Flash

mem/hg_malloc.c

@@ -461,7 +461,8 @@ void hg_info(struct hg_block *hb, struct mem_info *info)
 	 * never decreases and would otherwise look like a leak. */
 	recycled = hg_slab_recycled(hb);
 	info->real_used = hb->real_used > recycled ? hb->real_used - recycled : 0;
-	info->free = hb->size - info->real_used;
+	/* room left to CARVE, not size minus live - see hg_get_free() */
+	info->free = hb->size - hb->real_used;
 
 	/* the peak of what real_used above actually reached - NOT the peak
 	 * carve (hb->max_real_used), which only ever grows and would drift

mem/hg_malloc.h

@@ -437,10 +437,18 @@ static inline unsigned long hg_get_used(struct hg_block *hb)
  * report the raw carve footprint. */
 static inline unsigned long hg_get_free(struct hg_block *hb)
 {
-	unsigned long recycled = hg_slab_recycled(hb);
-
-	return hb->size - (hb->real_used > recycled ?
-	                   hb->real_used - recycled : 0);
+	/* Headroom left to CARVE - deliberately NOT size minus the live figure.
+	 * Carved-but-recycled cells are reusable only within their own size
+	 * class, so counting them as free reports ~95% available right up until
+	 * an allocation of a DIFFERENT size fails with "no more HG_MALLOC arena
+	 * memory". hb->real_used is the carve footprint, so this is the number
+	 * that actually predicts that failure.
+	 *
+	 * Consequence: free + real_used != size here (real_used is live), unlike
+	 * q_malloc. The invariant that does hold is free + carve == size. Each
+	 * figure answers a different question: used = live payload, real_used /
+	 * max_used = live commitment and its peak, free = room left to carve. */
+	return hb->size - hb->real_used;
 }
 static inline unsigned long hg_get_real_used(struct hg_block *hb)
 {