From 3f3b442b5ad2455507c9bfdacf39a3792eb3a6d0 Mon Sep 17 00:00:00 2001

From: Konstantin Komarov <almaz.alexandrovich@paragon-software.com>

Date: Fri, 13 Aug 2021 17:21:29 +0300

Subject: [Backport 3f3b442b5ad2] src: Add bitmap

This adds bitmap

Signed-off-by: Konstantin Komarov <almaz.alexandrovich@paragon-software.com>

---

 src/bitfunc.c |  135 ++++

 src/bitmap.c  | 1519 ++++++++++++++++++++++++++++++++++++++++++++

 2 files changed, 1654 insertions(+)

 create mode 100644 src/bitfunc.c

 create mode 100644 src/bitmap.c

diff --git a/src/bitfunc.c b/src/bitfunc.c

new file mode 100644

index 0000000000000000000000000000000000000000..2de5faef2721d5bac9caf7ff81adec167ae21dea

--- /dev/null

+++ b/src/bitfunc.c

@@ -0,0 +1,135 @@

+// SPDX-License-Identifier: GPL-2.0

+/*

+ *

+ * Copyright (C) 2019-2021 Paragon Software GmbH, All rights reserved.

+ *

+ */

+#include <linux/blkdev.h>

+#include <linux/buffer_head.h>

+#include <linux/fs.h>

+#include <linux/nls.h>

+

+#include "debug.h"

+#include "ntfs.h"

+#include "ntfs_fs.h"

+

+#define BITS_IN_SIZE_T (sizeof(size_t) * 8)

+

+/*

+ * fill_mask[i] - first i bits are '1' , i = 0,1,2,3,4,5,6,7,8

+ * fill_mask[i] = 0xFF >> (8-i)

+ */

+static const u8 fill_mask[] = { 0x00, 0x01, 0x03, 0x07, 0x0F,

+				0x1F, 0x3F, 0x7F, 0xFF };

+

+/*

+ * zero_mask[i] - first i bits are '0' , i = 0,1,2,3,4,5,6,7,8

+ * zero_mask[i] = 0xFF << i

+ */

+static const u8 zero_mask[] = { 0xFF, 0xFE, 0xFC, 0xF8, 0xF0,

+				0xE0, 0xC0, 0x80, 0x00 };

+

+/*

+ * are_bits_clear

+ *

+ * Returns true if all bits [bit, bit+nbits) are zeros "0"

+ */

+bool are_bits_clear(const ulong *lmap, size_t bit, size_t nbits)

+{

+	size_t pos = bit & 7;

+	const u8 *map = (u8 *)lmap + (bit >> 3);

+

+	if (pos) {

+		if (8 - pos >= nbits)

+			return !nbits || !(*map & fill_mask[pos + nbits] &

+					   zero_mask[pos]);

+

+		if (*map++ & zero_mask[pos])

+			return false;

+		nbits -= 8 - pos;

+	}

+

+	pos = ((size_t)map) & (sizeof(size_t) - 1);

+	if (pos) {

+		pos = sizeof(size_t) - pos;

+		if (nbits >= pos * 8) {

+			for (nbits -= pos * 8; pos; pos--, map++) {

+				if (*map)

+					return false;

+			}

+		}

+	}

+

+	for (pos = nbits / BITS_IN_SIZE_T; pos; pos--, map += sizeof(size_t)) {

+		if (*((size_t *)map))

+			return false;

+	}

+

+	for (pos = (nbits % BITS_IN_SIZE_T) >> 3; pos; pos--, map++) {

+		if (*map)

+			return false;

+	}

+

+	pos = nbits & 7;

+	if (pos && (*map & fill_mask[pos]))

+		return false;

+

+	// All bits are zero

+	return true;

+}

+

+/*

+ * are_bits_set

+ *

+ * Returns true if all bits [bit, bit+nbits) are ones "1"

+ */

+bool are_bits_set(const ulong *lmap, size_t bit, size_t nbits)

+{

+	u8 mask;

+	size_t pos = bit & 7;

+	const u8 *map = (u8 *)lmap + (bit >> 3);

+

+	if (pos) {

+		if (8 - pos >= nbits) {

+			mask = fill_mask[pos + nbits] & zero_mask[pos];

+			return !nbits || (*map & mask) == mask;

+		}

+

+		mask = zero_mask[pos];

+		if ((*map++ & mask) != mask)

+			return false;

+		nbits -= 8 - pos;

+	}

+

+	pos = ((size_t)map) & (sizeof(size_t) - 1);

+	if (pos) {

+		pos = sizeof(size_t) - pos;

+		if (nbits >= pos * 8) {

+			for (nbits -= pos * 8; pos; pos--, map++) {

+				if (*map != 0xFF)

+					return false;

+			}

+		}

+	}

+

+	for (pos = nbits / BITS_IN_SIZE_T; pos; pos--, map += sizeof(size_t)) {

+		if (*((size_t *)map) != MINUS_ONE_T)

+			return false;

+	}

+

+	for (pos = (nbits % BITS_IN_SIZE_T) >> 3; pos; pos--, map++) {

+		if (*map != 0xFF)

+			return false;

+	}

+

+	pos = nbits & 7;

+	if (pos) {

+		u8 mask = fill_mask[pos];

+

+		if ((*map & mask) != mask)

+			return false;

+	}

+

+	// All bits are ones

+	return true;

+}

diff --git a/src/bitmap.c b/src/bitmap.c

new file mode 100644

index 0000000000000000000000000000000000000000..32aab0031221db3ee67b09c239b960158370d238

--- /dev/null

+++ b/src/bitmap.c

@@ -0,0 +1,1519 @@

+// SPDX-License-Identifier: GPL-2.0

+/*

+ *

+ * Copyright (C) 2019-2021 Paragon Software GmbH, All rights reserved.

+ *

+ * This code builds two trees of free clusters extents.

+ * Trees are sorted by start of extent and by length of extent.

+ * NTFS_MAX_WND_EXTENTS defines the maximum number of elements in trees.

+ * In extreme case code reads on-disk bitmap to find free clusters

+ *

+ */

+

+#include <linux/blkdev.h>

+#include <linux/buffer_head.h>

+#include <linux/fs.h>

+#include <linux/nls.h>

+

+#include "debug.h"

+#include "ntfs.h"

+#include "ntfs_fs.h"

+

+/*

+ * Maximum number of extents in tree.

+ */

+#define NTFS_MAX_WND_EXTENTS (32u * 1024u)

+

+struct rb_node_key {

+	struct rb_node node;

+	size_t key;

+};

+

+/*

+ * Tree is sorted by start (key)

+ */

+struct e_node {

+	struct rb_node_key start; /* Tree sorted by start */

+	struct rb_node_key count; /* Tree sorted by len*/

+};

+

+static int wnd_rescan(struct wnd_bitmap *wnd);

+static struct buffer_head *wnd_map(struct wnd_bitmap *wnd, size_t iw);

+static bool wnd_is_free_hlp(struct wnd_bitmap *wnd, size_t bit, size_t bits);

+

+static struct kmem_cache *ntfs_enode_cachep;

+

+int __init ntfs3_init_bitmap(void)

+{

+	ntfs_enode_cachep =

+		kmem_cache_create("ntfs3_enode_cache", sizeof(struct e_node), 0,

+				  SLAB_RECLAIM_ACCOUNT, NULL);

+	return ntfs_enode_cachep ? 0 : -ENOMEM;

+}

+

+void ntfs3_exit_bitmap(void)

+{

+	kmem_cache_destroy(ntfs_enode_cachep);

+}

+

+static inline u32 wnd_bits(const struct wnd_bitmap *wnd, size_t i)

+{

+	return i + 1 == wnd->nwnd ? wnd->bits_last : wnd->sb->s_blocksize * 8;

+}

+

+/*

+ * b_pos + b_len - biggest fragment

+ * Scan range [wpos wbits) window 'buf'

+ * Returns -1 if not found

+ */

+static size_t wnd_scan(const ulong *buf, size_t wbit, u32 wpos, u32 wend,

+		       size_t to_alloc, size_t *prev_tail, size_t *b_pos,

+		       size_t *b_len)

+{

+	while (wpos < wend) {

+		size_t free_len;

+		u32 free_bits, end;

+		u32 used = find_next_zero_bit(buf, wend, wpos);

+

+		if (used >= wend) {

+			if (*b_len < *prev_tail) {

+				*b_pos = wbit - *prev_tail;

+				*b_len = *prev_tail;

+			}

+

+			*prev_tail = 0;

+			return -1;

+		}

+

+		if (used > wpos) {

+			wpos = used;

+			if (*b_len < *prev_tail) {

+				*b_pos = wbit - *prev_tail;

+				*b_len = *prev_tail;

+			}

+

+			*prev_tail = 0;

+		}

+

+		/*

+		 * Now we have a fragment [wpos, wend) staring with 0

+		 */

+		end = wpos + to_alloc - *prev_tail;

+		free_bits = find_next_bit(buf, min(end, wend), wpos);

+

+		free_len = *prev_tail + free_bits - wpos;

+

+		if (*b_len < free_len) {

+			*b_pos = wbit + wpos - *prev_tail;

+			*b_len = free_len;

+		}

+

+		if (free_len >= to_alloc)

+			return wbit + wpos - *prev_tail;

+

+		if (free_bits >= wend) {

+			*prev_tail += free_bits - wpos;

+			return -1;

+		}

+

+		wpos = free_bits + 1;

+

+		*prev_tail = 0;

+	}

+

+	return -1;

+}

+

+/*

+ * wnd_close

+ *

+ * Frees all resources

+ */

+void wnd_close(struct wnd_bitmap *wnd)

+{

+	struct rb_node *node, *next;

+

+	ntfs_free(wnd->free_bits);

+	run_close(&wnd->run);

+

+	node = rb_first(&wnd->start_tree);

+

+	while (node) {

+		next = rb_next(node);

+		rb_erase(node, &wnd->start_tree);

+		kmem_cache_free(ntfs_enode_cachep,

+				rb_entry(node, struct e_node, start.node));

+		node = next;

+	}

+}

+

+static struct rb_node *rb_lookup(struct rb_root *root, size_t v)

+{

+	struct rb_node **p = &root->rb_node;

+	struct rb_node *r = NULL;

+

+	while (*p) {

+		struct rb_node_key *k;

+

+		k = rb_entry(*p, struct rb_node_key, node);

+		if (v < k->key) {

+			p = &(*p)->rb_left;

+		} else if (v > k->key) {

+			r = &k->node;

+			p = &(*p)->rb_right;

+		} else {

+			return &k->node;

+		}

+	}

+

+	return r;

+}

+

+/*

+ * rb_insert_count

+ *

+ * Helper function to insert special kind of 'count' tree

+ */

+static inline bool rb_insert_count(struct rb_root *root, struct e_node *e)

+{

+	struct rb_node **p = &root->rb_node;

+	struct rb_node *parent = NULL;

+	size_t e_ckey = e->count.key;

+	size_t e_skey = e->start.key;

+

+	while (*p) {

+		struct e_node *k =

+			rb_entry(parent = *p, struct e_node, count.node);

+

+		if (e_ckey > k->count.key) {

+			p = &(*p)->rb_left;

+		} else if (e_ckey < k->count.key) {

+			p = &(*p)->rb_right;

+		} else if (e_skey < k->start.key) {

+			p = &(*p)->rb_left;

+		} else if (e_skey > k->start.key) {

+			p = &(*p)->rb_right;

+		} else {

+			WARN_ON(1);

+			return false;

+		}

+	}

+

+	rb_link_node(&e->count.node, parent, p);

+	rb_insert_color(&e->count.node, root);

+	return true;

+}

+

+/*

+ * inline bool rb_insert_start

+ *

+ * Helper function to insert special kind of 'start' tree

+ */

+static inline bool rb_insert_start(struct rb_root *root, struct e_node *e)

+{

+	struct rb_node **p = &root->rb_node;

+	struct rb_node *parent = NULL;

+	size_t e_skey = e->start.key;

+

+	while (*p) {

+		struct e_node *k;

+

+		parent = *p;

+

+		k = rb_entry(parent, struct e_node, start.node);

+		if (e_skey < k->start.key) {

+			p = &(*p)->rb_left;

+		} else if (e_skey > k->start.key) {

+			p = &(*p)->rb_right;

+		} else {

+			WARN_ON(1);

+			return false;

+		}

+	}

+

+	rb_link_node(&e->start.node, parent, p);

+	rb_insert_color(&e->start.node, root);

+	return true;

+}

+

+/*

+ * wnd_add_free_ext

+ *

+ * adds a new extent of free space

+ * build = 1 when building tree

+ */

+static void wnd_add_free_ext(struct wnd_bitmap *wnd, size_t bit, size_t len,

+			     bool build)

+{

+	struct e_node *e, *e0 = NULL;

+	size_t ib, end_in = bit + len;

+	struct rb_node *n;

+

+	if (build) {

+		/* Use extent_min to filter too short extents */

+		if (wnd->count >= NTFS_MAX_WND_EXTENTS &&

+		    len <= wnd->extent_min) {

+			wnd->uptodated = -1;

+			return;

+		}

+	} else {

+		/* Try to find extent before 'bit' */

+		n = rb_lookup(&wnd->start_tree, bit);

+

+		if (!n) {

+			n = rb_first(&wnd->start_tree);

+		} else {

+			e = rb_entry(n, struct e_node, start.node);

+			n = rb_next(n);

+			if (e->start.key + e->count.key == bit) {

+				/* Remove left */

+				bit = e->start.key;

+				len += e->count.key;

+				rb_erase(&e->start.node, &wnd->start_tree);

+				rb_erase(&e->count.node, &wnd->count_tree);

+				wnd->count -= 1;

+				e0 = e;

+			}

+		}

+

+		while (n) {

+			size_t next_end;

+

+			e = rb_entry(n, struct e_node, start.node);

+			next_end = e->start.key + e->count.key;

+			if (e->start.key > end_in)

+				break;

+

+			/* Remove right */

+			n = rb_next(n);

+			len += next_end - end_in;

+			end_in = next_end;

+			rb_erase(&e->start.node, &wnd->start_tree);

+			rb_erase(&e->count.node, &wnd->count_tree);

+			wnd->count -= 1;

+

+			if (!e0)

+				e0 = e;

+			else

+				kmem_cache_free(ntfs_enode_cachep, e);

+		}

+

+		if (wnd->uptodated != 1) {

+			/* Check bits before 'bit' */

+			ib = wnd->zone_bit == wnd->zone_end ||

+					     bit < wnd->zone_end

+				     ? 0

+				     : wnd->zone_end;

+

+			while (bit > ib && wnd_is_free_hlp(wnd, bit - 1, 1)) {

+				bit -= 1;

+				len += 1;

+			}

+

+			/* Check bits after 'end_in' */

+			ib = wnd->zone_bit == wnd->zone_end ||

+					     end_in > wnd->zone_bit

+				     ? wnd->nbits

+				     : wnd->zone_bit;

+

+			while (end_in < ib && wnd_is_free_hlp(wnd, end_in, 1)) {

+				end_in += 1;

+				len += 1;

+			}

+		}

+	}

+	/* Insert new fragment */

+	if (wnd->count >= NTFS_MAX_WND_EXTENTS) {

+		if (e0)

+			kmem_cache_free(ntfs_enode_cachep, e0);

+

+		wnd->uptodated = -1;

+

+		/* Compare with smallest fragment */

+		n = rb_last(&wnd->count_tree);

+		e = rb_entry(n, struct e_node, count.node);

+		if (len <= e->count.key)

+			goto out; /* Do not insert small fragments */

+

+		if (build) {

+			struct e_node *e2;

+

+			n = rb_prev(n);

+			e2 = rb_entry(n, struct e_node, count.node);

+			/* smallest fragment will be 'e2->count.key' */

+			wnd->extent_min = e2->count.key;

+		}

+

+		/* Replace smallest fragment by new one */

+		rb_erase(&e->start.node, &wnd->start_tree);

+		rb_erase(&e->count.node, &wnd->count_tree);

+		wnd->count -= 1;

+	} else {

+		e = e0 ? e0 : kmem_cache_alloc(ntfs_enode_cachep, GFP_ATOMIC);

+		if (!e) {

+			wnd->uptodated = -1;

+			goto out;

+		}

+

+		if (build && len <= wnd->extent_min)

+			wnd->extent_min = len;

+	}

+	e->start.key = bit;

+	e->count.key = len;

+	if (len > wnd->extent_max)

+		wnd->extent_max = len;

+

+	rb_insert_start(&wnd->start_tree, e);

+	rb_insert_count(&wnd->count_tree, e);

+	wnd->count += 1;

+

+out:;

+}

+

+/*

+ * wnd_remove_free_ext

+ *

+ * removes a run from the cached free space

+ */

+static void wnd_remove_free_ext(struct wnd_bitmap *wnd, size_t bit, size_t len)

+{

+	struct rb_node *n, *n3;

+	struct e_node *e, *e3;

+	size_t end_in = bit + len;

+	size_t end3, end, new_key, new_len, max_new_len;

+

+	/* Try to find extent before 'bit' */

+	n = rb_lookup(&wnd->start_tree, bit);

+

+	if (!n)

+		return;

+

+	e = rb_entry(n, struct e_node, start.node);

+	end = e->start.key + e->count.key;

+

+	new_key = new_len = 0;

+	len = e->count.key;

+

+	/* Range [bit,end_in) must be inside 'e' or outside 'e' and 'n' */

+	if (e->start.key > bit)

+		;

+	else if (end_in <= end) {

+		/* Range [bit,end_in) inside 'e' */

+		new_key = end_in;

+		new_len = end - end_in;

+		len = bit - e->start.key;

+	} else if (bit > end) {

+		bool bmax = false;

+

+		n3 = rb_next(n);

+

+		while (n3) {

+			e3 = rb_entry(n3, struct e_node, start.node);

+			if (e3->start.key >= end_in)

+				break;

+

+			if (e3->count.key == wnd->extent_max)

+				bmax = true;

+

+			end3 = e3->start.key + e3->count.key;

+			if (end3 > end_in) {

+				e3->start.key = end_in;

+				rb_erase(&e3->count.node, &wnd->count_tree);

+				e3->count.key = end3 - end_in;

+				rb_insert_count(&wnd->count_tree, e3);

+				break;

+			}

+

+			n3 = rb_next(n3);

+			rb_erase(&e3->start.node, &wnd->start_tree);

+			rb_erase(&e3->count.node, &wnd->count_tree);

+			wnd->count -= 1;

+			kmem_cache_free(ntfs_enode_cachep, e3);

+		}

+		if (!bmax)

+			return;

+		n3 = rb_first(&wnd->count_tree);

+		wnd->extent_max =

+			n3 ? rb_entry(n3, struct e_node, count.node)->count.key

+			   : 0;

+		return;

+	}

+

+	if (e->count.key != wnd->extent_max) {

+		;

+	} else if (rb_prev(&e->count.node)) {

+		;

+	} else {

+		n3 = rb_next(&e->count.node);

+		max_new_len = len > new_len ? len : new_len;

+		if (!n3) {

+			wnd->extent_max = max_new_len;

+		} else {

+			e3 = rb_entry(n3, struct e_node, count.node);

+			wnd->extent_max = max(e3->count.key, max_new_len);

+		}

+	}

+

+	if (!len) {

+		if (new_len) {

+			e->start.key = new_key;

+			rb_erase(&e->count.node, &wnd->count_tree);

+			e->count.key = new_len;

+			rb_insert_count(&wnd->count_tree, e);

+		} else {

+			rb_erase(&e->start.node, &wnd->start_tree);

+			rb_erase(&e->count.node, &wnd->count_tree);

+			wnd->count -= 1;

+			kmem_cache_free(ntfs_enode_cachep, e);

+		}

+		goto out;

+	}

+	rb_erase(&e->count.node, &wnd->count_tree);

+	e->count.key = len;

+	rb_insert_count(&wnd->count_tree, e);

+

+	if (!new_len)

+		goto out;

+

+	if (wnd->count >= NTFS_MAX_WND_EXTENTS) {

+		wnd->uptodated = -1;

+

+		/* Get minimal extent */

+		e = rb_entry(rb_last(&wnd->count_tree), struct e_node,

+			     count.node);

+		if (e->count.key > new_len)

+			goto out;

+

+		/* Replace minimum */

+		rb_erase(&e->start.node, &wnd->start_tree);

+		rb_erase(&e->count.node, &wnd->count_tree);

+		wnd->count -= 1;

+	} else {

+		e = kmem_cache_alloc(ntfs_enode_cachep, GFP_ATOMIC);

+		if (!e)

+			wnd->uptodated = -1;

+	}

+

+	if (e) {

+		e->start.key = new_key;

+		e->count.key = new_len;

+		rb_insert_start(&wnd->start_tree, e);

+		rb_insert_count(&wnd->count_tree, e);

+		wnd->count += 1;

+	}

+

+out:

+	if (!wnd->count && 1 != wnd->uptodated)

+		wnd_rescan(wnd);

+}

+

+/*

+ * wnd_rescan

+ *

+ * Scan all bitmap. used while initialization.

+ */

+static int wnd_rescan(struct wnd_bitmap *wnd)

+{

+	int err = 0;

+	size_t prev_tail = 0;

+	struct super_block *sb = wnd->sb;

+	struct ntfs_sb_info *sbi = sb->s_fs_info;

+	u64 lbo, len = 0;

+	u32 blocksize = sb->s_blocksize;

+	u8 cluster_bits = sbi->cluster_bits;

+	u32 wbits = 8 * sb->s_blocksize;

+	u32 used, frb;

+	const ulong *buf;

+	size_t wpos, wbit, iw, vbo;

+	struct buffer_head *bh = NULL;

+	CLST lcn, clen;

+

+	wnd->uptodated = 0;

+	wnd->extent_max = 0;

+	wnd->extent_min = MINUS_ONE_T;

+	wnd->total_zeroes = 0;

+

+	vbo = 0;

+

+	for (iw = 0; iw < wnd->nwnd; iw++) {

+		if (iw + 1 == wnd->nwnd)

+			wbits = wnd->bits_last;

+

+		if (wnd->inited) {

+			if (!wnd->free_bits[iw]) {

+				/* all ones */

+				if (prev_tail) {

+					wnd_add_free_ext(wnd,

+							 vbo * 8 - prev_tail,

+							 prev_tail, true);

+					prev_tail = 0;

+				}

+				goto next_wnd;

+			}

+			if (wbits == wnd->free_bits[iw]) {

+				/* all zeroes */

+				prev_tail += wbits;

+				wnd->total_zeroes += wbits;

+				goto next_wnd;

+			}

+		}

+

+		if (!len) {

+			u32 off = vbo & sbi->cluster_mask;

+

+			if (!run_lookup_entry(&wnd->run, vbo >> cluster_bits,

+					      &lcn, &clen, NULL)) {

+				err = -ENOENT;

+				goto out;

+			}

+

+			lbo = ((u64)lcn << cluster_bits) + off;

+			len = ((u64)clen << cluster_bits) - off;

+		}

+

+		bh = ntfs_bread(sb, lbo >> sb->s_blocksize_bits);

+		if (!bh) {

+			err = -EIO;

+			goto out;

+		}

+

+		buf = (ulong *)bh->b_data;

+

+		used = __bitmap_weight(buf, wbits);

+		if (used < wbits) {

+			frb = wbits - used;

+			wnd->free_bits[iw] = frb;

+			wnd->total_zeroes += frb;

+		}

+

+		wpos = 0;

+		wbit = vbo * 8;

+

+		if (wbit + wbits > wnd->nbits)

+			wbits = wnd->nbits - wbit;

+

+		do {

+			used = find_next_zero_bit(buf, wbits, wpos);

+

+			if (used > wpos && prev_tail) {

+				wnd_add_free_ext(wnd, wbit + wpos - prev_tail,

+						 prev_tail, true);

+				prev_tail = 0;

+			}

+

+			wpos = used;

+

+			if (wpos >= wbits) {

+				/* No free blocks */

+				prev_tail = 0;

+				break;

+			}

+

+			frb = find_next_bit(buf, wbits, wpos);

+			if (frb >= wbits) {

+				/* keep last free block */

+				prev_tail += frb - wpos;

+				break;

+			}

+

+			wnd_add_free_ext(wnd, wbit + wpos - prev_tail,

+					 frb + prev_tail - wpos, true);

+

+			/* Skip free block and first '1' */

+			wpos = frb + 1;

+			/* Reset previous tail */

+			prev_tail = 0;

+		} while (wpos < wbits);

+

+next_wnd:

+

+		if (bh)

+			put_bh(bh);

+		bh = NULL;

+

+		vbo += blocksize;

+		if (len) {

+			len -= blocksize;

+			lbo += blocksize;

+		}

+	}

+

+	/* Add last block */

+	if (prev_tail)

+		wnd_add_free_ext(wnd, wnd->nbits - prev_tail, prev_tail, true);

+

+	/*

+	 * Before init cycle wnd->uptodated was 0

+	 * If any errors or limits occurs while initialization then

+	 * wnd->uptodated will be -1

+	 * If 'uptodated' is still 0 then Tree is really updated

+	 */

+	if (!wnd->uptodated)

+		wnd->uptodated = 1;

+

+	if (wnd->zone_bit != wnd->zone_end) {

+		size_t zlen = wnd->zone_end - wnd->zone_bit;

+

+		wnd->zone_end = wnd->zone_bit;

+		wnd_zone_set(wnd, wnd->zone_bit, zlen);

+	}

+

+out:

+	return err;

+}

+

+/*

+ * wnd_init

+ */

+int wnd_init(struct wnd_bitmap *wnd, struct super_block *sb, size_t nbits)

+{

+	int err;

+	u32 blocksize = sb->s_blocksize;

+	u32 wbits = blocksize * 8;

+

+	init_rwsem(&wnd->rw_lock);

+

+	wnd->sb = sb;

+	wnd->nbits = nbits;

+	wnd->total_zeroes = nbits;

+	wnd->extent_max = MINUS_ONE_T;

+	wnd->zone_bit = wnd->zone_end = 0;

+	wnd->nwnd = bytes_to_block(sb, bitmap_size(nbits));

+	wnd->bits_last = nbits & (wbits - 1);

+	if (!wnd->bits_last)

+		wnd->bits_last = wbits;

+

+	wnd->free_bits = ntfs_zalloc(wnd->nwnd * sizeof(u16));

+	if (!wnd->free_bits)

+		return -ENOMEM;

+

+	err = wnd_rescan(wnd);

+	if (err)

+		return err;

+

+	wnd->inited = true;

+

+	return 0;

+}

+

+/*

+ * wnd_map

+ *

+ * call sb_bread for requested window

+ */

+static struct buffer_head *wnd_map(struct wnd_bitmap *wnd, size_t iw)

+{

+	size_t vbo;

+	CLST lcn, clen;

+	struct super_block *sb = wnd->sb;

+	struct ntfs_sb_info *sbi;

+	struct buffer_head *bh;

+	u64 lbo;

+

+	sbi = sb->s_fs_info;

+	vbo = (u64)iw << sb->s_blocksize_bits;

+

+	if (!run_lookup_entry(&wnd->run, vbo >> sbi->cluster_bits, &lcn, &clen,

+			      NULL)) {

+		return ERR_PTR(-ENOENT);