[PATCH v3 08/18] xfs: helpers to convert holemask to/from generic bitmap

Brian Foster
2015-02-06T19:53:09Z

The inobt record holemask field is a condensed data type designed to fit
into the existing on-disk record and is zero based (allocated regions
are set to 0, sparse regions are set to 1) to provide backwards
compatibility. This makes the type somewhat complex for use in higher
level inode manipulations such as individual inode allocation, etc.

Rather than foist the complexity of dealing with this field to every bit
of logic that requires inode granular information, create the
xfs_inobt_ialloc_bitmap() helper to convert the holemask to an inode
allocation bitmap. The inode allocation bitmap is inode granularity
similar to the inobt record free mask and indicates which inodes of the
chunk are physically allocated on disk, irrespective of whether the
inode is considered allocated or free by the filesystem. The generic
bitmap type requires the use of generic kernel bitmap APIs.

The bitmap_to_u64() helper is provided to convert the bitmap back to a
native 64-bit type (for native bitwise operations). This is required
because the generic bitmap code represents a bitmap as an array of
unsigned long in a little endian style (though each array value is cpu
order). To ensure compatibility with various word sizes and endianness',
bitmap_to_u64() exports the bitmap to little endian and swaps back to
cpu byte order.

Signed-off-by: Brian Foster <bfoster@redhat.com>
---
fs/xfs/libxfs/xfs_ialloc.c | 69 ++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 69 insertions(+)

diff --git a/fs/xfs/libxfs/xfs_ialloc.c b/fs/xfs/libxfs/xfs_ialloc.c
index 72ade0e..fc001d9 100644
--- a/fs/xfs/libxfs/xfs_ialloc.c
+++ b/fs/xfs/libxfs/xfs_ialloc.c
@@ -39,6 +39,8 @@
#include "xfs_icache.h"
#include "xfs_trace.h"

+STATIC void
+xfs_inobt_ialloc_bitmap(unsigned long *, struct xfs_inobt_rec_incore *);

/*
* Allocation group level functions.
@@ -739,6 +741,73 @@ xfs_ialloc_get_rec(
return 0;
}

+static inline uint64_t
+bitmap_to_u64(
+ const unsigned long *bitmap,
+ int nbits)
+{
+ __le64 lebitmap;
+
+ ASSERT(nbits <= 64);
+
+ /*
+ * The bitmap format depends on the native word size. E.g., bit 0 could
+ * land in the middle of the 64 bits on a big endian 32-bit arch (see
+ * arch/powerpc/include/asm/bitops.h). To handle this, export the bitmap
+ * as 64-bit little endian and convert back to native byte order.
+ */
+ bitmap_copy_le(&lebitmap, bitmap, nbits);
+ return le64_to_cpu(lebitmap);
+}
+
+/*
+ * Convert the inode record holemask to an inode allocation bitmap. The inode
+ * allocation bitmap is inode granularity and specifies whether an inode is
+ * physically allocated on disk (not whether the inode is considered allocated
+ * or free by the fs).
+ *
+ * We have to be careful with regard to byte order and word size since the
+ * generic bitmap code uses primitive types.
+ */
+STATIC void
+xfs_inobt_ialloc_bitmap(
+ unsigned long *allocbmap,
+ struct xfs_inobt_rec_incore *rec)
+{
+ int nextbit;
+ DECLARE_BITMAP(holemask, 16);
+
+ bitmap_zero(allocbmap, 64);
+
+ /*
+ * bitmaps are represented as an array of unsigned long (each in cpu
+ * byte order). ir_holemask is only 16 bits, so direct assignment is
+ * safe.
+ */
+ ASSERT(sizeof(rec->ir_holemask) <= sizeof(holemask[0]));
+ holemask[0] = rec->ir_holemask;
+
+ /*
+ * holemask is a 16-bit bitmap and inode records span 64 inodes. Thus
+ * each holemask bit represents multiple (XFS_INODES_PER_HOLEMASK_BIT)
+ * inodes. Since holemask bits represent holes, each set bit represents
+ * a region of the physical chunk that is not tracked by the record.
+ *
+ * We want an inode granularity allocation bitmap. We have to invert the
+ * holemask and set XFS_INODES_PER_HOLEMASK_BIT bits for each set bit.
+ * We invert and expand simultaneously by walking the unset (zeroed)
+ * holemask bits. For each zero bit in holemask, set the corresponding
+ * XFS_INODES_PER_HOLEMASK_BIT bits in the allocation bitmap.
+ */
+ nextbit = find_first_zero_bit(holemask, 16);
+ while (nextbit < 16) {
+ bitmap_set(allocbmap, nextbit * XFS_INODES_PER_HOLEMASK_BIT,
+ XFS_INODES_PER_HOLEMASK_BIT);
+
+ nextbit = find_next_zero_bit(holemask, 16, nextbit + 1);
+ }
+}
+
/*
* Allocate an inode using the inobt-only algorithm.
*/
--
1.8.3.1