xfs
[Top] [All Lists]

[PATCH] xfs_db: fix the setting of unaligned directory fields

To: xfs@xxxxxxxxxxx
Subject: [PATCH] xfs_db: fix the setting of unaligned directory fields
From: Mark Tinguely <tinguely@xxxxxxx>
Date: Fri, 07 Feb 2014 16:03:42 -0600
Delivered-to: xfs@xxxxxxxxxxx
User-agent: quilt/0.51-1
Setting the directory startoff, startblock, and blockcount
bit fields is difficult on both big and little endian machines.
The setting of extentflag bit field was completely broken.

big endian test:
xfs_db> write u.bmx[0].startblock 12
u.bmx[0].startblock = 0
xfs_db> write u.bmx[0].startblock 0xc0000
u.bmx[0].startblock = 192

little endian test:
xfs_db> write u.bmx[0].startblock 12
u.bmx[0].startblock = 211106232532992
xfs_db> write u.bmx[0].startblock 0xc0000
u.bmx[0].startblock = 3221225472

Since these output fields and the lengths are not aligned to a byte,
setbitval requires them to be entered in big endian and properly
byte/nibble shifted. The extentflag out field is aligned to a byte
boundary but was not shifted correctly.

Convert the input to big endian on little endian machines and
bit/byte shift on all platforms so setbitval can set the bits
correctly. As noted in the comment, the bit shift must be done
before doing the endian conversion or end result will be shifted
in the wrong direction..

Clean some whitespace while in the setbitbal() function.

Signed-off-by: Mark Tinguely <tinguely@xxxxxxx>
---
 db/bit.c   |   68 ++++++++++++++++---------------------------------------------
 db/write.c |   25 +++++++++++++---------
 2 files changed, 33 insertions(+), 60 deletions(-)

Index: b/db/bit.c
===================================================================
--- a/db/bit.c
+++ b/db/bit.c
@@ -130,55 +130,23 @@ getbitval(
 
 void
 setbitval(
-       void *obuf,      /* buffer to write into */
-       int bitoff,      /* bit offset of where to write */
-       int nbits,       /* number of bits to write */
-       void *ibuf)      /* source bits */
+       void    *obuf,          /* buffer to write into */
+       int     bitoff,         /* bit offset of where to write */
+       int     nbits,          /* number of bits to write */
+       void    *ibuf)          /* source bits */
 {
-       char    *in           = (char *)ibuf;
-       char    *out          = (char *)obuf;
-
-       int     bit;
-
-#if BYTE_ORDER == LITTLE_ENDIAN
-       int     big           = 0;
-#else
-       int     big           = 1;
-#endif
-
-       /* only need to swap LE integers */
-       if (big || (nbits!=16 && nbits!=32 && nbits!=64) ) {
-               /* We don't have type info, so we can only assume
-                * that 2,4 & 8 byte values are integers. sigh.
-                */
-
-               /* byte aligned ? */
-               if (bitoff%NBBY) {
-                       /* no - bit copy */
-                       for (bit=0; bit<nbits; bit++)
-                               setbit(out, bit+bitoff, getbit(in, bit));
-               } else {
-                       /* yes - byte copy */
-                       memcpy(out+byteize(bitoff), in, byteize(nbits));
-               }
-
-       } else {
-               int     ibit;
-               int     obit;
-
-               /* we need to endian swap this value */
-
-               out+=byteize(bitoff);
-               obit=bitoffs(bitoff);
-
-               ibit=nbits-NBBY;
-
-               for (bit=0; bit<nbits; bit++) {
-                       setbit(out, bit+obit, getbit(in, ibit));
-                       if (ibit%NBBY==NBBY-1)
-                               ibit-=NBBY*2-1;
-                       else
-                               ibit++;
-               }
-       }
+       char    *in     = (char *)ibuf;
+       char    *out    = (char *)obuf;
+       int     bit;
+
+       /*
+        * The input data is in big endian and aligned to the bit length.
+        * Set the individual bits if the destination field or the source
+        * end are not aligned.
+        */
+       if (bitoff % NBBY || nbits % NBBY) {
+               for (bit=0; bit<nbits; bit++)
+                       setbit(out, bit+bitoff, getbit(in, bit));
+       } else
+               memcpy(out+byteize(bitoff), in, byteize(nbits));
 }
Index: b/db/write.c
===================================================================
--- a/db/write.c
+++ b/db/write.c
@@ -451,6 +451,7 @@ convert_arg(
        int alloc_size;
        char *ostr;
        int octval, ret;
+       int offadj;
 
        if (bit_length <= 64)
                alloc_size = 8;
@@ -526,16 +527,20 @@ convert_arg(
                 */
                *value = strtoll(arg, NULL, 0);
 
-#if __BYTE_ORDER == BIG_ENDIAN
-               /* hackery for big endian */
-               if (bit_length <= 8) {
-                       rbuf += 7;
-               } else if (bit_length <= 16) {
-                       rbuf += 6;
-               } else if (bit_length <= 32) {
-                       rbuf += 4;
-               }
-#endif
+               /*
+                * Align the significant bits in the result length.
+                * Must be done before the endian conversion.
+                */
+               offadj = bit_length % NBBY;
+               if (offadj)
+                       *value <<= (8 - offadj);
+
+               /* convert to big endian */
+               *value = cpu_to_be64(*value);
+
+               /* Align the signifant bytes in the result length. */
+               offadj = 7 - (bit_length - 1)/ 8;
+               rbuf += offadj;
                return rbuf;
        }
 }


<Prev in Thread] Current Thread [Next in Thread>