usbloadergx/libcustomntfs/lcnalloc.c

/**
 * lcnalloc.c - Cluster (de)allocation code. Originated from the Linux-NTFS project.
 *
 * Copyright (c) 2002-2004 Anton Altaparmakov
 * Copyright (c) 2004 Yura Pakhuchiy
 * Copyright (c) 2004-2008 Szabolcs Szakacsits
 * Copyright (c) 2008-2009 Jean-Pierre Andre
 *
 * This program/include file is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as published
 * by the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program/include file is distributed in the hope that it will be
 * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program (in the main directory of the NTFS-3G
 * distribution in the file COPYING); if not, write to the Free Software
 * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#ifdef HAVE_STDIO_H
#include <stdio.h>
#endif
#ifdef HAVE_ERRNO_H
#include <errno.h>
#endif

#include "types.h"
#include "attrib.h"
#include "bitmap.h"
#include "debug.h"
#include "runlist.h"
#include "volume.h"
#include "lcnalloc.h"
#include "logging.h"
#include "misc.h"

/*
 * Plenty possibilities for big optimizations all over in the cluster
 * allocation, however at the moment the dominant bottleneck (~ 90%) is 
 * the update of the mapping pairs which converges to the cubic Faulhaber's
 * formula as the function of the number of extents (fragments, runs).
 */
#define NTFS_LCNALLOC_BSIZE 4096
#define NTFS_LCNALLOC_SKIP  NTFS_LCNALLOC_BSIZE

enum {
	ZONE_MFT = 1,
	ZONE_DATA1 = 2,
	ZONE_DATA2 = 4
} ;

static void ntfs_cluster_set_zone_pos(LCN start, LCN end, LCN *pos, LCN tc)
{
	ntfs_log_trace("pos: %lld  tc: %lld\n", (long long)*pos, (long long)tc);

	if (tc >= end)
		*pos = start;
	else if (tc >= start)
		*pos = tc;
}

static void ntfs_cluster_update_zone_pos(ntfs_volume *vol, u8 zone, LCN tc)
{
	ntfs_log_trace("tc = %lld, zone = %d\n", (long long)tc, zone);
	
	if (zone == ZONE_MFT)
		ntfs_cluster_set_zone_pos(vol->mft_lcn, vol->mft_zone_end,
					  &vol->mft_zone_pos, tc);
	else if (zone == ZONE_DATA1)
		ntfs_cluster_set_zone_pos(vol->mft_zone_end, vol->nr_clusters,
					  &vol->data1_zone_pos, tc);
	else /* zone == ZONE_DATA2 */
		ntfs_cluster_set_zone_pos(0, vol->mft_zone_start, 
					  &vol->data2_zone_pos, tc);
}

/*
 *		Unmark full zones when a cluster has been freed in a full zone
 *
 *	Next allocation will reuse the freed cluster
 */

static void update_full_status(ntfs_volume *vol, LCN lcn)
{
	if (lcn >= vol->mft_zone_end) {
		if (vol->full_zones & ZONE_DATA1) {
			ntfs_cluster_update_zone_pos(vol, ZONE_DATA1, lcn);
			vol->full_zones &= ~ZONE_DATA1;
		}
	} else
		if (lcn < vol->mft_zone_start) {
			if (vol->full_zones & ZONE_DATA2) {
				ntfs_cluster_update_zone_pos(vol, ZONE_DATA2, lcn);
				vol->full_zones &= ~ZONE_DATA2;
			}
		} else {
			if (vol->full_zones & ZONE_MFT) {
				ntfs_cluster_update_zone_pos(vol, ZONE_MFT, lcn);
				vol->full_zones &= ~ZONE_MFT;
			}
		}
}
 
static s64 max_empty_bit_range(unsigned char *buf, int size)
{
	int i, j, run = 0;
	int max_range = 0;
	s64 start_pos = -1;
	
	ntfs_log_trace("Entering\n");
	
	i = 0;
	while (i < size) {
		switch (*buf) {
		case 0 :
			do {
				buf++;
				run += 8;
				i++;
			} while ((i < size) && !*buf);
			break;
		case 255 :
			if (run > max_range) {
				max_range = run;
				start_pos = (s64)i * 8 - run;
			}
			run = 0;
			do {
				buf++;
				i++;
			} while ((i < size) && (*buf == 255));
			break;
		default :
			for (j = 0; j < 8; j++) {
			
				int bit = *buf & (1 << j);
		
				if (bit) {
					if (run > max_range) {
						max_range = run;
						start_pos = (s64)i * 8 + (j - run);
					}
					run = 0;
				} else 
					run++;
			}
			i++;
			buf++;
		
		}
	}
	
	if (run > max_range)
		start_pos = (s64)i * 8 - run;
	
	return start_pos;
}

static int bitmap_writeback(ntfs_volume *vol, s64 pos, s64 size, void *b, 
			    u8 *writeback)
{
	s64 written;
	
	ntfs_log_trace("Entering\n");
	
	if (!*writeback)
		return 0;
	
	*writeback = 0;
	
	written = ntfs_attr_pwrite(vol->lcnbmp_na, pos, size, b);
	if (written != size) {
		if (!written)
			errno = EIO;
		ntfs_log_perror("Bitmap write error (%lld, %lld)",
				(long long)pos, (long long)size);
		return -1;
	}

	return 0;
}

/**
 * ntfs_cluster_alloc - allocate clusters on an ntfs volume
 * @vol:	mounted ntfs volume on which to allocate the clusters
 * @start_vcn:	vcn to use for the first allocated cluster
 * @count:	number of clusters to allocate
 * @start_lcn:	starting lcn at which to allocate the clusters (or -1 if none)
 * @zone:	zone from which to allocate the clusters
 *
 * Allocate @count clusters preferably starting at cluster @start_lcn or at the
 * current allocator position if @start_lcn is -1, on the mounted ntfs volume
 * @vol. @zone is either DATA_ZONE for allocation of normal clusters and
 * MFT_ZONE for allocation of clusters for the master file table, i.e. the
 * $MFT/$DATA attribute.
 *
 * On success return a runlist describing the allocated cluster(s).
 *
 * On error return NULL with errno set to the error code.
 *
 * Notes on the allocation algorithm
 * =================================
 *
 * There are two data zones. First is the area between the end of the mft zone
 * and the end of the volume, and second is the area between the start of the
 * volume and the start of the mft zone. On unmodified/standard NTFS 1.x
 * volumes, the second data zone doesn't exist due to the mft zone being
 * expanded to cover the start of the volume in order to reserve space for the
 * mft bitmap attribute.
 *
 * The complexity stems from the need of implementing the mft vs data zoned 
 * approach and from the fact that we have access to the lcn bitmap via up to 
 * NTFS_LCNALLOC_BSIZE bytes at a time, so we need to cope with crossing over 
 * boundaries of two buffers. Further, the fact that the allocator allows for 
 * caller supplied hints as to the location of where allocation should begin 
 * and the fact that the allocator keeps track of where in the data zones the 
 * next natural allocation should occur, contribute to the complexity of the 
 * function. But it should all be worthwhile, because this allocator: 
 *   1) implements MFT zone reservation
 *   2) causes reduction in fragmentation. 
 * The code is not optimized for speed.
 */
runlist *ntfs_cluster_alloc(ntfs_volume *vol, VCN start_vcn, s64 count,
		LCN start_lcn, const NTFS_CLUSTER_ALLOCATION_ZONES zone)
{
	LCN zone_start, zone_end;  /* current search range */
	LCN last_read_pos, lcn;
	LCN bmp_pos;		/* current bit position inside the bitmap */
	LCN prev_lcn = 0, prev_run_len = 0;
	s64 clusters, br;
	runlist *rl = NULL, *trl;
	u8 *buf, *byte, bit, writeback;
	u8 pass = 1; 	/* 1: inside zone;  2: start of zone */
	u8 search_zone; /* 4: data2 (start) 1: mft (middle) 2: data1 (end) */
	u8 done_zones = 0;
	u8 has_guess, used_zone_pos;
	int err = 0, rlpos, rlsize, buf_size;

	ntfs_log_enter("Entering with count = 0x%llx, start_lcn = 0x%llx, "
		       "zone = %s_ZONE.\n", (long long)count, (long long)
		       start_lcn, zone == MFT_ZONE ? "MFT" : "DATA");
	
	if (!vol || count < 0 || start_lcn < -1 || !vol->lcnbmp_na ||
			(s8)zone < FIRST_ZONE || zone > LAST_ZONE) {
		errno = EINVAL;
		ntfs_log_perror("%s: vcn: %lld, count: %lld, lcn: %lld", 
				__FUNCTION__, (long long)start_vcn, 
				(long long)count, (long long)start_lcn);
		goto out;
	}

	/* Return empty runlist if @count == 0 */
	if (!count) {
		rl = ntfs_malloc(0x1000);
		if (rl) {
			rl[0].vcn = start_vcn;
			rl[0].lcn = LCN_RL_NOT_MAPPED;
			rl[0].length = 0;
		}
		goto out;
	}

	buf = ntfs_malloc(NTFS_LCNALLOC_BSIZE);
	if (!buf)
		goto out;
	/*
	 * If no @start_lcn was requested, use the current zone
	 * position otherwise use the requested @start_lcn.
	 */
	has_guess = 1;
	zone_start = start_lcn;
	
	if (zone_start < 0) {
		if (zone == DATA_ZONE)
			zone_start = vol->data1_zone_pos;
		else
			zone_start = vol->mft_zone_pos;
		has_guess = 0;
	}
	
	used_zone_pos = has_guess ? 0 : 1;
	
	if (!zone_start || zone_start == vol->mft_zone_start ||
			zone_start == vol->mft_zone_end)
		pass = 2;
		
	if (zone_start < vol->mft_zone_start) {
		zone_end = vol->mft_zone_start;
		search_zone = ZONE_DATA2;
	} else if (zone_start < vol->mft_zone_end) {
		zone_end = vol->mft_zone_end;
		search_zone = ZONE_MFT;
	} else {
		zone_end = vol->nr_clusters;
		search_zone = ZONE_DATA1;
	}
	
	bmp_pos = zone_start;

	/* Loop until all clusters are allocated. */
	clusters = count;
	rlpos = rlsize = 0;
	while (1) {
			/* check whether we have exhausted the current zone */
		if (search_zone & vol->full_zones)
			goto zone_pass_done;
		last_read_pos = bmp_pos >> 3;
		br = ntfs_attr_pread(vol->lcnbmp_na, last_read_pos, 
				     NTFS_LCNALLOC_BSIZE, buf);
		if (br <= 0) {
			if (!br)
				goto zone_pass_done;
			err = errno;
			ntfs_log_perror("Reading $BITMAP failed");
			goto err_ret;
		}
		/*
		 * We might have read less than NTFS_LCNALLOC_BSIZE bytes
		 * if we are close to the end of the attribute.
		 */
		buf_size = (int)br << 3;
		lcn = bmp_pos & 7;
		bmp_pos &= ~7;
		writeback = 0;
		
		while (lcn < buf_size) {
			byte = buf + (lcn >> 3);
			bit = 1 << (lcn & 7);
			if (has_guess) {
				if (*byte & bit) {
					has_guess = 0;
					break;
				}
			} else {
				lcn = max_empty_bit_range(buf, br);
				if (lcn < 0)
					break;
				has_guess = 1;
				continue;
			}

			/* First free bit is at lcn + bmp_pos. */
			 
			/* Reallocate memory if necessary. */
			if ((rlpos + 2) * (int)sizeof(runlist) >= rlsize) {
				rlsize += 4096;
				trl = realloc(rl, rlsize);
				if (!trl) {
					err = ENOMEM;
					ntfs_log_perror("realloc() failed");
					goto wb_err_ret;
				}
				rl = trl;
			}
			
			/* Allocate the bitmap bit. */
			*byte |= bit;
			writeback = 1;
			if (vol->free_clusters <= 0) 
				ntfs_log_error("Non-positive free clusters "
					       "(%lld)!\n",
						(long long)vol->free_clusters);
			else	
				vol->free_clusters--; 
			
			/*
			 * Coalesce with previous run if adjacent LCNs.
			 * Otherwise, append a new run.
			 */
			if (prev_lcn == lcn + bmp_pos - prev_run_len && rlpos) {
				ntfs_log_debug("Cluster coalesce: prev_lcn: "
					       "%lld  lcn: %lld  bmp_pos: %lld  "
					       "prev_run_len: %lld\n", 
					       (long long)prev_lcn, 
					       (long long)lcn, (long long)bmp_pos, 
					       (long long)prev_run_len);
				rl[rlpos - 1].length = ++prev_run_len;
			} else {
				if (rlpos)
					rl[rlpos].vcn = rl[rlpos - 1].vcn +
							prev_run_len;
				else {
					rl[rlpos].vcn = start_vcn;
					ntfs_log_debug("Start_vcn: %lld\n", 
						       (long long)start_vcn);
				}
				
				rl[rlpos].lcn = prev_lcn = lcn + bmp_pos;
				rl[rlpos].length = prev_run_len = 1;
				rlpos++;
			}
			
			ntfs_log_debug("RUN:   %-16lld %-16lld %-16lld\n", 
				       (long long)rl[rlpos - 1].vcn, 
				       (long long)rl[rlpos - 1].lcn, 
				       (long long)rl[rlpos - 1].length);
			/* Done? */
			if (!--clusters) {
				if (used_zone_pos)
					ntfs_cluster_update_zone_pos(vol, 
						search_zone, lcn + bmp_pos + 1 +
							NTFS_LCNALLOC_SKIP);
				goto done_ret;
			}
			
			lcn++;
		}
		
		if (bitmap_writeback(vol, last_read_pos, br, buf, &writeback)) {
			err = errno;
			goto err_ret;
		}
		
		if (!used_zone_pos) {
			
			used_zone_pos = 1;
			
			if (search_zone == ZONE_MFT)
				zone_start = vol->mft_zone_pos;
			else if (search_zone == ZONE_DATA1)
				zone_start = vol->data1_zone_pos;
			else
				zone_start = vol->data2_zone_pos;
			
			if (!zone_start || zone_start == vol->mft_zone_start ||
					zone_start == vol->mft_zone_end)
				pass = 2;
			bmp_pos = zone_start;
		} else
			bmp_pos += buf_size;
		
		if (bmp_pos < zone_end)
			continue;

zone_pass_done:
		ntfs_log_trace("Finished current zone pass(%i).\n", pass);
		if (pass == 1) {
			pass = 2;
			zone_end = zone_start;
			
			if (search_zone == ZONE_MFT)
				zone_start = vol->mft_zone_start;
			else if (search_zone == ZONE_DATA1)
				zone_start = vol->mft_zone_end;
			else
				zone_start = 0;
			
			/* Sanity check. */
			if (zone_end < zone_start)
				zone_end = zone_start;
			
			bmp_pos = zone_start;
			
			continue;
		} 
		/* pass == 2 */
done_zones_check:
		done_zones |= search_zone;
		vol->full_zones |= search_zone;
		if (done_zones < (ZONE_MFT + ZONE_DATA1 + ZONE_DATA2)) {
			ntfs_log_trace("Switching zone.\n");
			pass = 1;
			if (rlpos) {
				LCN tc = rl[rlpos - 1].lcn + 
				      rl[rlpos - 1].length + NTFS_LCNALLOC_SKIP;
				
				if (used_zone_pos)
					ntfs_cluster_update_zone_pos(vol, 
						search_zone, tc);
			}
			
			switch (search_zone) {
			case ZONE_MFT:
				ntfs_log_trace("Zone switch: mft -> data1\n");
switch_to_data1_zone:		search_zone = ZONE_DATA1;
				zone_start = vol->data1_zone_pos;
				zone_end = vol->nr_clusters;
				if (zone_start == vol->mft_zone_end)
					pass = 2;
				break;
			case ZONE_DATA1:
				ntfs_log_trace("Zone switch: data1 -> data2\n");
				search_zone = ZONE_DATA2;
				zone_start = vol->data2_zone_pos;
				zone_end = vol->mft_zone_start;
				if (!zone_start)
					pass = 2;
				break;
			case ZONE_DATA2:
				if (!(done_zones & ZONE_DATA1)) {
					ntfs_log_trace("data2 -> data1\n");
					goto switch_to_data1_zone;
				}
				ntfs_log_trace("Zone switch: data2 -> mft\n");
				search_zone = ZONE_MFT;
				zone_start = vol->mft_zone_pos;
				zone_end = vol->mft_zone_end;
				if (zone_start == vol->mft_zone_start)
					pass = 2;
				break;
			}
			
			bmp_pos = zone_start;
			
			if (zone_start == zone_end) {
				ntfs_log_trace("Empty zone, skipped.\n");
				goto done_zones_check;
			}
			
			continue;
		}
		
		ntfs_log_trace("All zones are finished, no space on device.\n");
		err = ENOSPC;
		goto err_ret;
	}
done_ret:
	ntfs_log_debug("At done_ret.\n");
	/* Add runlist terminator element. */
	rl[rlpos].vcn = rl[rlpos - 1].vcn + rl[rlpos - 1].length;
	rl[rlpos].lcn = LCN_RL_NOT_MAPPED;
	rl[rlpos].length = 0;
	if (bitmap_writeback(vol, last_read_pos, br, buf, &writeback)) {
		err = errno;
		goto err_ret;
	}
done_err_ret:
	free(buf);
	if (err) {
		errno = err;
		ntfs_log_perror("Failed to allocate clusters");
		rl = NULL;
	}
out:	
	ntfs_log_leave("\n");
	return rl;

wb_err_ret:
	ntfs_log_trace("At wb_err_ret.\n");
	if (bitmap_writeback(vol, last_read_pos, br, buf, &writeback))
		err = errno;
err_ret:
	ntfs_log_trace("At err_ret.\n");
	if (rl) {
		/* Add runlist terminator element. */
		rl[rlpos].vcn = rl[rlpos - 1].vcn + rl[rlpos - 1].length;
		rl[rlpos].lcn = LCN_RL_NOT_MAPPED;
		rl[rlpos].length = 0;
		ntfs_debug_runlist_dump(rl);
		ntfs_cluster_free_from_rl(vol, rl);
		free(rl);
		rl = NULL;
	}
	goto done_err_ret;
}

/**
 * ntfs_cluster_free_from_rl - free clusters from runlist
 * @vol:	mounted ntfs volume on which to free the clusters
 * @rl:		runlist from which deallocate clusters
 *
 * On success return 0 and on error return -1 with errno set to the error code.
 */
int ntfs_cluster_free_from_rl(ntfs_volume *vol, runlist *rl)
{
	s64 nr_freed = 0;
	int ret = -1;

	ntfs_log_trace("Entering.\n");

	for (; rl->length; rl++) {

		ntfs_log_trace("Dealloc lcn 0x%llx, len 0x%llx.\n",
			       (long long)rl->lcn, (long long)rl->length);

		if (rl->lcn >= 0) { 
			update_full_status(vol,rl->lcn);
			if (ntfs_bitmap_clear_run(vol->lcnbmp_na, rl->lcn, 
						  rl->length)) {
				ntfs_log_perror("Cluster deallocation failed "
					       "(%lld, %lld)",
						(long long)rl->lcn, 
						(long long)rl->length);
				goto out;
			}
			nr_freed += rl->length ; 
		}
	}

	ret = 0;
out:
	vol->free_clusters += nr_freed; 
	if (vol->free_clusters > vol->nr_clusters)
		ntfs_log_error("Too many free clusters (%lld > %lld)!",
			       (long long)vol->free_clusters, 
			       (long long)vol->nr_clusters);
	return ret;
}

/*
 *		Basic cluster run free
 *	Returns 0 if successful
 */

int ntfs_cluster_free_basic(ntfs_volume *vol, s64 lcn, s64 count)
{
	s64 nr_freed = 0;
	int ret = -1;

	ntfs_log_trace("Entering.\n");
	ntfs_log_trace("Dealloc lcn 0x%llx, len 0x%llx.\n",
			       (long long)lcn, (long long)count);

	if (lcn >= 0) { 
		update_full_status(vol,lcn);
		if (ntfs_bitmap_clear_run(vol->lcnbmp_na, lcn, 
						  count)) {
			ntfs_log_perror("Cluster deallocation failed "
				       "(%lld, %lld)",
					(long long)lcn, 
					(long long)count);
				goto out;
		}
		nr_freed += count; 
	}
	ret = 0;
out:
	vol->free_clusters += nr_freed;
	if (vol->free_clusters > vol->nr_clusters)
		ntfs_log_error("Too many free clusters (%lld > %lld)!",
			       (long long)vol->free_clusters, 
			       (long long)vol->nr_clusters);
	return ret;
}

/**
 * ntfs_cluster_free - free clusters on an ntfs volume
 * @vol:	mounted ntfs volume on which to free the clusters
 * @na:		attribute whose runlist describes the clusters to free
 * @start_vcn:	vcn in @rl at which to start freeing clusters
 * @count:	number of clusters to free or -1 for all clusters
 *
 * Free @count clusters starting at the cluster @start_vcn in the runlist
 * described by the attribute @na from the mounted ntfs volume @vol.
 *
 * If @count is -1, all clusters from @start_vcn to the end of the runlist
 * are deallocated.
 *
 * On success return the number of deallocated clusters (not counting sparse
 * clusters) and on error return -1 with errno set to the error code.
 */
int ntfs_cluster_free(ntfs_volume *vol, ntfs_attr *na, VCN start_vcn, s64 count)
{
	runlist *rl;
	s64 delta, to_free, nr_freed = 0;
	int ret = -1;

	if (!vol || !vol->lcnbmp_na || !na || start_vcn < 0 ||
			(count < 0 && count != -1)) {
		ntfs_log_trace("Invalid arguments!\n");
		errno = EINVAL;
		return -1;
	}
	
	ntfs_log_enter("Entering for inode 0x%llx, attr 0x%x, count 0x%llx, "
		       "vcn 0x%llx.\n", (unsigned long long)na->ni->mft_no,
		       na->type, (long long)count, (long long)start_vcn);

	rl = ntfs_attr_find_vcn(na, start_vcn);
	if (!rl) {
		if (errno == ENOENT)
			ret = 0;
		goto leave;
	}

	if (rl->lcn < 0 && rl->lcn != LCN_HOLE) {
		errno = EIO;
		ntfs_log_perror("%s: Unexpected lcn (%lld)", __FUNCTION__, 
				(long long)rl->lcn);
		goto leave;
	}

	/* Find the starting cluster inside the run that needs freeing. */
	delta = start_vcn - rl->vcn;

	/* The number of clusters in this run that need freeing. */
	to_free = rl->length - delta;
	if (count >= 0 && to_free > count)
		to_free = count;

	if (rl->lcn != LCN_HOLE) {
		/* Do the actual freeing of the clusters in this run. */
		update_full_status(vol,rl->lcn + delta);
		if (ntfs_bitmap_clear_run(vol->lcnbmp_na, rl->lcn + delta,
					  to_free))
			goto leave;
		nr_freed = to_free;
	} 

	/* Go to the next run and adjust the number of clusters left to free. */
	++rl;
	if (count >= 0)
		count -= to_free;

	/*
	 * Loop over the remaining runs, using @count as a capping value, and
	 * free them.
	 */
	for (; rl->length && count != 0; ++rl) {
		// FIXME: Need to try ntfs_attr_map_runlist() for attribute
		//	  list support! (AIA)
		if (rl->lcn < 0 && rl->lcn != LCN_HOLE) {
			// FIXME: Eeek! We need rollback! (AIA)
			errno = EIO;
			ntfs_log_perror("%s: Invalid lcn (%lli)", 
					__FUNCTION__, (long long)rl->lcn);
			goto out;
		}

		/* The number of clusters in this run that need freeing. */
		to_free = rl->length;
		if (count >= 0 && to_free > count)
			to_free = count;

		if (rl->lcn != LCN_HOLE) {
			update_full_status(vol,rl->lcn);
			if (ntfs_bitmap_clear_run(vol->lcnbmp_na, rl->lcn,
					to_free)) {
				// FIXME: Eeek! We need rollback! (AIA)
				ntfs_log_perror("%s: Clearing bitmap run failed",
						__FUNCTION__);
				goto out;
			}
			nr_freed += to_free;
		}

		if (count >= 0)
			count -= to_free;
	}

	if (count != -1 && count != 0) {
		// FIXME: Eeek! BUG()
		errno = EIO;
		ntfs_log_perror("%s: count still not zero (%lld)", __FUNCTION__,
			       (long long)count);
		goto out;
	}

	ret = nr_freed;
out:
	vol->free_clusters += nr_freed ; 
	if (vol->free_clusters > vol->nr_clusters)
		ntfs_log_error("Too many free clusters (%lld > %lld)!",
			       (long long)vol->free_clusters, 
			       (long long)vol->nr_clusters);
leave:	
	ntfs_log_leave("\n");
	return ret;
}