xfs: remove struct xfs_attr_shortform

Source kernel commit: 414147225400a0c4562ebfb0fdd40f065099ede4

sparse complains about struct xfs_attr_shortform because it embeds a
structure with a variable sized array in a variable sized array.

Given that xfs_attr_shortform is not a very useful structure, and the
dir2 equivalent has been removed a long time ago, remove it as well.

Provide a xfs_attr_sf_firstentry helper that returns the first
xfs_attr_sf_entry behind a xfs_attr_sf_hdr to replace the structure
dereference.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: "Darrick J. Wong" <djwong@kernel.org>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Chandan Babu R <chandanbabu@kernel.org>
Reviewed-by: Bill O'Donnell <bodonnel@redhat.com>

diff --git a/db/attrshort.c b/db/attrshort.c
index e234fbd83653c1294dc8a9d9a1c3294c5df66c25..c98b90be3ec0b9ce07b7d50249e53f4005731396 100644 (file)
--- a/db/attrshort.c
+++ b/db/attrshort.c
@@ -18,9 +18,8 @@ static int    attr_sf_entry_value_offset(void *obj, int startoff, int idx);
 static int     attr_shortform_list_count(void *obj, int startoff);
 static int     attr_shortform_list_offset(void *obj, int startoff, int idx);
 
-#define        OFF(f)  bitize(offsetof(struct xfs_attr_shortform, f))
 const field_t  attr_shortform_flds[] = {
-       { "hdr", FLDT_ATTR_SF_HDR, OI(OFF(hdr)), C1, 0, TYP_NONE },
+       { "hdr", FLDT_ATTR_SF_HDR, OI(0), C1, 0, TYP_NONE },
        { "list", FLDT_ATTR_SF_ENTRY, attr_shortform_list_offset,
          attr_shortform_list_count, FLD_ARRAY|FLD_COUNT|FLD_OFFSET, TYP_NONE },
        { NULL }
@@ -71,11 +70,11 @@ attr_sf_entry_size(
 {
        struct xfs_attr_sf_entry        *e;
        int                             i;
-       struct xfs_attr_shortform       *sf;
+       struct xfs_attr_sf_hdr          *hdr;
 
        ASSERT(bitoffs(startoff) == 0);
-       sf = (struct xfs_attr_shortform *)((char *)obj + byteize(startoff));
-       e = &sf->list[0];
+       hdr = (struct xfs_attr_sf_hdr *)((char *)obj + byteize(startoff));
+       e = libxfs_attr_sf_firstentry(hdr);
        for (i = 0; i < idx; i++)
                e = xfs_attr_sf_nextentry(e);
        return bitize((int)xfs_attr_sf_entsize(e));
@@ -113,11 +112,11 @@ attr_shortform_list_count(
        void                            *obj,
        int                             startoff)
 {
-       struct xfs_attr_shortform       *sf;
+       struct xfs_attr_sf_hdr          *hdr;
 
        ASSERT(bitoffs(startoff) == 0);
-       sf = (struct xfs_attr_shortform *)((char *)obj + byteize(startoff));
-       return sf->hdr.count;
+       hdr = (struct xfs_attr_sf_hdr *)((char *)obj + byteize(startoff));
+       return hdr->count;
 }
 
 static int
@@ -128,14 +127,14 @@ attr_shortform_list_offset(
 {
        struct xfs_attr_sf_entry        *e;
        int                             i;
-       struct xfs_attr_shortform       *sf;
+       struct xfs_attr_sf_hdr          *hdr;
 
        ASSERT(bitoffs(startoff) == 0);
-       sf = (struct xfs_attr_shortform *)((char *)obj + byteize(startoff));
-       e = &sf->list[0];
+       hdr = (struct xfs_attr_sf_hdr *)((char *)obj + byteize(startoff));
+       e = libxfs_attr_sf_firstentry(hdr);
        for (i = 0; i < idx; i++)
                e = xfs_attr_sf_nextentry(e);
-       return bitize((int)((char *)e - (char *)sf));
+       return bitize((int)((char *)e - (char *)hdr));
 }
 
 /*ARGSUSED*/
@@ -147,13 +146,13 @@ attrshort_size(
 {
        struct xfs_attr_sf_entry        *e;
        int                             i;
-       struct xfs_attr_shortform       *sf;
+       struct xfs_attr_sf_hdr          *hdr;
 
        ASSERT(bitoffs(startoff) == 0);
        ASSERT(idx == 0);
-       sf = (struct xfs_attr_shortform *)((char *)obj + byteize(startoff));
-       e = &sf->list[0];
-       for (i = 0; i < sf->hdr.count; i++)
+       hdr = (struct xfs_attr_sf_hdr *)((char *)obj + byteize(startoff));
+       e = libxfs_attr_sf_firstentry(hdr);
+       for (i = 0; i < hdr->count; i++)
                e = xfs_attr_sf_nextentry(e);
-       return bitize((int)((char *)e - (char *)sf));
+       return bitize((int)((char *)e - (char *)hdr));
 }

diff --git a/db/check.c b/db/check.c
index 91d0c094064bd756995cef51e929636903195de5..0a53ab7dfde6ba031d5eac802fc73d5dd6f63cb7 100644 (file)
--- a/db/check.c
+++ b/db/check.c
@@ -3069,7 +3069,7 @@ process_lclinode(
        blkmap_t                        **blkmapp,
        int                             whichfork)
 {
-       struct xfs_attr_shortform       *asf;
+       struct xfs_attr_sf_hdr          *hdr;
        xfs_fsblock_t                   bno;
 
        bno = XFS_INO_TO_FSB(mp, id->ino);
@@ -3082,12 +3082,12 @@ process_lclinode(
                error++;
        }
        else if (whichfork == XFS_ATTR_FORK) {
-               asf = (struct xfs_attr_shortform *)XFS_DFORK_APTR(dip);
-               if (be16_to_cpu(asf->hdr.totsize) > XFS_DFORK_ASIZE(dip, mp)) {
+               hdr = XFS_DFORK_APTR(dip);
+               if (be16_to_cpu(hdr->totsize) > XFS_DFORK_ASIZE(dip, mp)) {
                        if (!sflag || id->ilist || CHECK_BLIST(bno))
                                dbprintf(_("local inode %lld attr is too large "
                                         "(size %d)\n"),
-                                       id->ino, be16_to_cpu(asf->hdr.totsize));
+                                       id->ino, be16_to_cpu(hdr->totsize));
                        error++;
                }
        }

diff --git a/db/inode.c b/db/inode.c
index c9b506b905d03ae2811c3f7d9d0a6af98218dff6..7a5f5a0cb987aa6be765a51aee3f91543efcda9b 100644 (file)
--- a/db/inode.c
+++ b/db/inode.c
@@ -356,7 +356,7 @@ inode_a_size(
        int                             startoff,
        int                             idx)
 {
-       struct xfs_attr_shortform       *asf;
+       struct xfs_attr_sf_hdr          *hdr;
        struct xfs_dinode               *dip;
 
        ASSERT(startoff == 0);
@@ -364,8 +364,8 @@ inode_a_size(
        dip = obj;
        switch (dip->di_aformat) {
        case XFS_DINODE_FMT_LOCAL:
-               asf = (struct xfs_attr_shortform *)XFS_DFORK_APTR(dip);
-               return bitize(be16_to_cpu(asf->hdr.totsize));
+               hdr = XFS_DFORK_APTR(dip);
+               return bitize(be16_to_cpu(hdr->totsize));
        case XFS_DINODE_FMT_EXTENTS:
                return (int)xfs_dfork_attr_extents(dip) * bitsz(xfs_bmbt_rec_t);
        case XFS_DINODE_FMT_BTREE:

diff --git a/db/metadump.c b/db/metadump.c
index bac35b9cc68c10404b115a63f206fa2021be2c3d..536d089fbac6cf46c707c9b9e5ac84ca3efd3ac2 100644 (file)
--- a/db/metadump.c
+++ b/db/metadump.c
@@ -1035,16 +1035,15 @@ process_sf_attr(
         * values with 'v' (to see a valid string length, as opposed to NULLs)
         */
 
-       struct xfs_attr_shortform       *asfp;
-       struct xfs_attr_sf_entry        *asfep;
+       struct xfs_attr_sf_hdr          *hdr = XFS_DFORK_APTR(dip);
+       struct xfs_attr_sf_entry        *asfep = libxfs_attr_sf_firstentry(hdr);
        int                             ino_attr_size;
        int                             i;
 
-       asfp = (struct xfs_attr_shortform *)XFS_DFORK_APTR(dip);
-       if (asfp->hdr.count == 0)
+       if (hdr->count == 0)
                return;
 
-       ino_attr_size = be16_to_cpu(asfp->hdr.totsize);
+       ino_attr_size = be16_to_cpu(hdr->totsize);
        if (ino_attr_size > XFS_DFORK_ASIZE(dip, mp)) {
                ino_attr_size = XFS_DFORK_ASIZE(dip, mp);
                if (metadump.show_warnings)
@@ -1052,9 +1051,8 @@ process_sf_attr(
                                        (long long)metadump.cur_ino);
        }
 
-       asfep = &asfp->list[0];
-       for (i = 0; (i < asfp->hdr.count) &&
-                       ((char *)asfep - (char *)asfp < ino_attr_size); i++) {
+       for (i = 0; (i < hdr->count) &&
+                       ((char *)asfep - (char *)hdr < ino_attr_size); i++) {
 
                int     namelen = asfep->namelen;
 
@@ -1063,7 +1061,7 @@ process_sf_attr(
                                print_warning("zero length attr entry in inode "
                                        "%llu", (long long)metadump.cur_ino);
                        break;
-               } else if ((char *)asfep - (char *)asfp +
+               } else if ((char *)asfep - (char *)hdr +
                                xfs_attr_sf_entsize(asfep) > ino_attr_size) {
                        if (metadump.show_warnings)
                                print_warning("attr entry length in inode %llu "

diff --git a/libxfs/libxfs_api_defs.h b/libxfs/libxfs_api_defs.h
index 7c055e8aa61ec4184cf67f9169fae7e5ad12ae91..36afc5d0234de321bedc29772727d8348501087a 100644 (file)
--- a/libxfs/libxfs_api_defs.h
+++ b/libxfs/libxfs_api_defs.h
@@ -40,6 +40,8 @@
 #define xfs_attr_leaf_newentsize       libxfs_attr_leaf_newentsize
 #define xfs_attr_namecheck             libxfs_attr_namecheck
 #define xfs_attr_set                   libxfs_attr_set
+#define xfs_attr_sf_firstentry         libxfs_attr_sf_firstentry
+#define xfs_attr_shortform_verify      libxfs_attr_shortform_verify
 
 #define __xfs_bmap_add_free            __libxfs_bmap_add_free
 #define xfs_bmapi_read                 libxfs_bmapi_read

diff --git a/libxfs/xfs_attr.c b/libxfs/xfs_attr.c
index a383024dbd7f93d8681ce631443c0571d6055782..055d204101a5bd0d39f7c705acf97d6468b0fdb8 100644 (file)
--- a/libxfs/xfs_attr.c
+++ b/libxfs/xfs_attr.c
@@ -1050,9 +1050,9 @@ out_trans_cancel:
 
 static inline int xfs_attr_sf_totsize(struct xfs_inode *dp)
 {
-       struct xfs_attr_shortform *sf = dp->i_af.if_data;
+       struct xfs_attr_sf_hdr *sf = dp->i_af.if_data;
 
-       return be16_to_cpu(sf->hdr.totsize);
+       return be16_to_cpu(sf->totsize);
 }
 
 /*

diff --git a/libxfs/xfs_attr_leaf.c b/libxfs/xfs_attr_leaf.c
index 9b6dcff349c9b0b7ba8f3c23b90ac501e0aa8e82..cf172b6ea4ab8ab88397cfafcfded18ab55d69f9 100644 (file)
--- a/libxfs/xfs_attr_leaf.c
+++ b/libxfs/xfs_attr_leaf.c
@@ -701,10 +701,10 @@ struct xfs_attr_sf_entry *
 xfs_attr_sf_findname(
        struct xfs_da_args              *args)
 {
-       struct xfs_attr_shortform       *sf = args->dp->i_af.if_data;
+       struct xfs_attr_sf_hdr          *sf = args->dp->i_af.if_data;
        struct xfs_attr_sf_entry        *sfe;
 
-       for (sfe = &sf->list[0];
+       for (sfe = xfs_attr_sf_firstentry(sf);
             sfe < xfs_attr_sf_endptr(sf);
             sfe = xfs_attr_sf_nextentry(sfe)) {
                if (xfs_attr_match(args, sfe->namelen, sfe->nameval,
@@ -727,7 +727,7 @@ xfs_attr_shortform_add(
        struct xfs_inode                *dp = args->dp;
        struct xfs_mount                *mp = dp->i_mount;
        struct xfs_ifork                *ifp = &dp->i_af;
-       struct xfs_attr_shortform       *sf = ifp->if_data;
+       struct xfs_attr_sf_hdr          *sf = ifp->if_data;
        struct xfs_attr_sf_entry        *sfe;
        int                             size;
 
@@ -747,8 +747,8 @@ xfs_attr_shortform_add(
        sfe->flags = args->attr_filter;
        memcpy(sfe->nameval, args->name, args->namelen);
        memcpy(&sfe->nameval[args->namelen], args->value, args->valuelen);
-       sf->hdr.count++;
-       be16_add_cpu(&sf->hdr.totsize, size);
+       sf->count++;
+       be16_add_cpu(&sf->totsize, size);
        xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE | XFS_ILOG_ADATA);
 
        xfs_sbversion_add_attr2(mp, args->trans);
@@ -779,9 +779,9 @@ xfs_attr_sf_removename(
 {
        struct xfs_inode                *dp = args->dp;
        struct xfs_mount                *mp = dp->i_mount;
-       struct xfs_attr_shortform       *sf = dp->i_af.if_data;
+       struct xfs_attr_sf_hdr          *sf = dp->i_af.if_data;
        struct xfs_attr_sf_entry        *sfe;
-       uint16_t                        totsize = be16_to_cpu(sf->hdr.totsize);
+       uint16_t                        totsize = be16_to_cpu(sf->totsize);
        void                            *next, *end;
        int                             size = 0;
 
@@ -806,9 +806,9 @@ xfs_attr_sf_removename(
        end = xfs_attr_sf_endptr(sf);
        if (next < end)
                memmove(sfe, next, end - next);
-       sf->hdr.count--;
+       sf->count--;
        totsize -= size;
-       sf->hdr.totsize = cpu_to_be16(totsize);
+       sf->totsize = cpu_to_be16(totsize);
 
        /*
         * Fix up the start offset of the attribute fork
@@ -865,21 +865,21 @@ xfs_attr_shortform_to_leaf(
 {
        struct xfs_inode                *dp = args->dp;
        struct xfs_ifork                *ifp = &dp->i_af;
-       struct xfs_attr_shortform       *sf = ifp->if_data;
+       struct xfs_attr_sf_hdr          *sf = ifp->if_data;
        struct xfs_attr_sf_entry        *sfe;
+       int                             size = be16_to_cpu(sf->totsize);
        struct xfs_da_args              nargs;
        char                            *tmpbuffer;
-       int                             error, i, size;
+       int                             error, i;
        xfs_dablk_t                     blkno;
        struct xfs_buf                  *bp;
 
        trace_xfs_attr_sf_to_leaf(args);
 
-       size = be16_to_cpu(sf->hdr.totsize);
        tmpbuffer = kmem_alloc(size, 0);
        ASSERT(tmpbuffer != NULL);
        memcpy(tmpbuffer, ifp->if_data, size);
-       sf = (struct xfs_attr_shortform *)tmpbuffer;
+       sf = (struct xfs_attr_sf_hdr *)tmpbuffer;
 
        xfs_idata_realloc(dp, -size, XFS_ATTR_FORK);
        xfs_bmap_local_to_extents_empty(args->trans, dp, XFS_ATTR_FORK);
@@ -902,8 +902,8 @@ xfs_attr_shortform_to_leaf(
        nargs.trans = args->trans;
        nargs.op_flags = XFS_DA_OP_OKNOENT;
 
-       sfe = &sf->list[0];
-       for (i = 0; i < sf->hdr.count; i++) {
+       sfe = xfs_attr_sf_firstentry(sf);
+       for (i = 0; i < sf->count; i++) {
                nargs.name = sfe->nameval;
                nargs.namelen = sfe->namelen;
                nargs.value = &sfe->nameval[nargs.namelen];
@@ -970,10 +970,10 @@ xfs_attr_shortform_allfit(
 /* Verify the consistency of a raw inline attribute fork. */
 xfs_failaddr_t
 xfs_attr_shortform_verify(
-       struct xfs_attr_shortform       *sfp,
+       struct xfs_attr_sf_hdr          *sfp,
        size_t                          size)
 {
-       struct xfs_attr_sf_entry        *sfep;
+       struct xfs_attr_sf_entry        *sfep = xfs_attr_sf_firstentry(sfp);
        struct xfs_attr_sf_entry        *next_sfep;
        char                            *endp;
        int                             i;
@@ -987,8 +987,7 @@ xfs_attr_shortform_verify(
        endp = (char *)sfp + size;
 
        /* Check all reported entries */
-       sfep = &sfp->list[0];
-       for (i = 0; i < sfp->hdr.count; i++) {
+       for (i = 0; i < sfp->count; i++) {
                /*
                 * struct xfs_attr_sf_entry has a variable length.
                 * Check the fixed-offset parts of the structure are

diff --git a/libxfs/xfs_attr_leaf.h b/libxfs/xfs_attr_leaf.h
index 35e668ae744fb14bef8d39a6e051b0b4c014762f..9b9948639c0fb34f20c503eb9e0d6ed3e17817e4 100644 (file)
--- a/libxfs/xfs_attr_leaf.h
+++ b/libxfs/xfs_attr_leaf.h
@@ -53,7 +53,7 @@ int   xfs_attr_sf_removename(struct xfs_da_args *args);
 struct xfs_attr_sf_entry *xfs_attr_sf_findname(struct xfs_da_args *args);
 int    xfs_attr_shortform_allfit(struct xfs_buf *bp, struct xfs_inode *dp);
 int    xfs_attr_shortform_bytesfit(struct xfs_inode *dp, int bytes);
-xfs_failaddr_t xfs_attr_shortform_verify(struct xfs_attr_shortform *sfp,
+xfs_failaddr_t xfs_attr_shortform_verify(struct xfs_attr_sf_hdr *sfp,
                size_t size);
 void   xfs_attr_fork_remove(struct xfs_inode *ip, struct xfs_trans *tp);
 

diff --git a/libxfs/xfs_attr_sf.h b/libxfs/xfs_attr_sf.h
index a774d4d87763543a99b28fd82407893c2c229e9e..9abf7de95465f5aad5c92d9e780221bbc19f7e42 100644 (file)
--- a/libxfs/xfs_attr_sf.h
+++ b/libxfs/xfs_attr_sf.h
@@ -41,7 +41,14 @@ static inline int xfs_attr_sf_entsize(struct xfs_attr_sf_entry *sfep)
        return struct_size(sfep, nameval, sfep->namelen + sfep->valuelen);
 }
 
-/* next entry in struct */
+/* first entry in the SF attr fork */
+static inline struct xfs_attr_sf_entry *
+xfs_attr_sf_firstentry(struct xfs_attr_sf_hdr *hdr)
+{
+       return (struct xfs_attr_sf_entry *)(hdr + 1);
+}
+
+/* next entry after sfep */
 static inline struct xfs_attr_sf_entry *
 xfs_attr_sf_nextentry(struct xfs_attr_sf_entry *sfep)
 {
@@ -50,9 +57,9 @@ xfs_attr_sf_nextentry(struct xfs_attr_sf_entry *sfep)
 
 /* pointer to the space after the last entry, e.g. for adding a new one */
 static inline struct xfs_attr_sf_entry *
-xfs_attr_sf_endptr(struct xfs_attr_shortform *sf)
+xfs_attr_sf_endptr(struct xfs_attr_sf_hdr *sf)
 {
-       return (void *)sf + be16_to_cpu(sf->hdr.totsize);
+       return (void *)sf + be16_to_cpu(sf->totsize);
 }
 
 #endif /* __XFS_ATTR_SF_H__ */

diff --git a/libxfs/xfs_da_format.h b/libxfs/xfs_da_format.h
index f9015f88eca70679e6a5e915f43eddaf0cb6a299..24f9d1461f9a6f72442da9acbed5ed7251d908c0 100644 (file)
--- a/libxfs/xfs_da_format.h
+++ b/libxfs/xfs_da_format.h
@@ -578,20 +578,25 @@ xfs_dir2_block_leaf_p(struct xfs_dir2_block_tail *btp)
 #define XFS_ATTR_LEAF_MAPSIZE  3       /* how many freespace slots */
 
 /*
- * Entries are packed toward the top as tight as possible.
- */
-struct xfs_attr_shortform {
-       struct xfs_attr_sf_hdr {        /* constant-structure header block */
-               __be16  totsize;        /* total bytes in shortform list */
-               __u8    count;  /* count of active entries */
-               __u8    padding;
-       } hdr;
-       struct xfs_attr_sf_entry {
-               uint8_t namelen;        /* actual length of name (no NULL) */
-               uint8_t valuelen;       /* actual length of value (no NULL) */
-               uint8_t flags;  /* flags bits (see xfs_attr_leaf.h) */
-               uint8_t nameval[];      /* name & value bytes concatenated */
-       } list[];                       /* variable sized array */
+ * Attribute storage when stored inside the inode.
+ *
+ * Small attribute lists are packed as tightly as possible so as to fit into the
+ * literal area of the inode.
+ *
+ * These "shortform" attribute forks consist of a single xfs_attr_sf_hdr header
+ * followed by zero or more xfs_attr_sf_entry structures.
+ */
+struct xfs_attr_sf_hdr {       /* constant-structure header block */
+       __be16  totsize;        /* total bytes in shortform list */
+       __u8    count;          /* count of active entries */
+       __u8    padding;
+};
+
+struct xfs_attr_sf_entry {
+       __u8    namelen;        /* actual length of name (no NULL) */
+       __u8    valuelen;       /* actual length of value (no NULL) */
+       __u8    flags;          /* flags bits (XFS_ATTR_*) */
+       __u8    nameval[];      /* name & value bytes concatenated */
 };
 
 typedef struct xfs_attr_leaf_map {     /* RLE map of free bytes */

diff --git a/libxfs/xfs_inode_fork.c b/libxfs/xfs_inode_fork.c
index c95abd43ab0b9d5a202da5ffe301a0318d6d2f56..208b283ba3384a9b378a97e16f3344d1cf3ee9cf 100644 (file)
--- a/libxfs/xfs_inode_fork.c
+++ b/libxfs/xfs_inode_fork.c
@@ -277,10 +277,9 @@ static uint16_t
 xfs_dfork_attr_shortform_size(
        struct xfs_dinode               *dip)
 {
-       struct xfs_attr_shortform       *atp =
-               (struct xfs_attr_shortform *)XFS_DFORK_APTR(dip);
+       struct xfs_attr_sf_hdr          *sf = XFS_DFORK_APTR(dip);
 
-       return be16_to_cpu(atp->hdr.totsize);
+       return be16_to_cpu(sf->totsize);
 }
 
 void

diff --git a/libxfs/xfs_ondisk.h b/libxfs/xfs_ondisk.h
index d9c988c5ad692eb87a3a2767c0da4ca3d1192c6d..81885a6a028ed71ae3ae1b8f8e7fa2df9b51ca8a 100644 (file)
--- a/libxfs/xfs_ondisk.h
+++ b/libxfs/xfs_ondisk.h
@@ -93,13 +93,13 @@ xfs_check_ondisk_structs(void)
        XFS_CHECK_OFFSET(xfs_attr_leaf_name_remote_t, namelen,  8);
        XFS_CHECK_OFFSET(xfs_attr_leaf_name_remote_t, name,     9);
        XFS_CHECK_STRUCT_SIZE(xfs_attr_leafblock_t,             32);
-       XFS_CHECK_STRUCT_SIZE(struct xfs_attr_shortform,        4);
-       XFS_CHECK_OFFSET(struct xfs_attr_shortform, hdr.totsize, 0);
-       XFS_CHECK_OFFSET(struct xfs_attr_shortform, hdr.count,   2);
-       XFS_CHECK_OFFSET(struct xfs_attr_shortform, list[0].namelen,    4);
-       XFS_CHECK_OFFSET(struct xfs_attr_shortform, list[0].valuelen,   5);
-       XFS_CHECK_OFFSET(struct xfs_attr_shortform, list[0].flags,      6);
-       XFS_CHECK_OFFSET(struct xfs_attr_shortform, list[0].nameval,    7);
+       XFS_CHECK_STRUCT_SIZE(struct xfs_attr_sf_hdr,           4);
+       XFS_CHECK_OFFSET(struct xfs_attr_sf_hdr, totsize,       0);
+       XFS_CHECK_OFFSET(struct xfs_attr_sf_hdr, count,         2);
+       XFS_CHECK_OFFSET(struct xfs_attr_sf_entry, namelen,     0);
+       XFS_CHECK_OFFSET(struct xfs_attr_sf_entry, valuelen,    1);
+       XFS_CHECK_OFFSET(struct xfs_attr_sf_entry, flags,       2);
+       XFS_CHECK_OFFSET(struct xfs_attr_sf_entry, nameval,     3);
        XFS_CHECK_STRUCT_SIZE(xfs_da_blkinfo_t,                 12);
        XFS_CHECK_STRUCT_SIZE(xfs_da_intnode_t,                 16);
        XFS_CHECK_STRUCT_SIZE(xfs_da_node_entry_t,              8);

diff --git a/repair/attr_repair.c b/repair/attr_repair.c
index c3a6d50267e242b7dffaa03fb3e85b919d0a8c30..31c50c127d418f8169286822c5f2d35d372b6311 100644 (file)
--- a/repair/attr_repair.c
+++ b/repair/attr_repair.c
@@ -210,27 +210,25 @@ process_shortform_attr(
        struct xfs_dinode               *dip,
        int                             *repair)
 {
-       struct xfs_attr_shortform       *asf;
+       struct xfs_attr_sf_hdr          *hdr = XFS_DFORK_APTR(dip);
        struct xfs_attr_sf_entry        *currententry, *nextentry, *tempentry;
        int                             i, junkit;
        int                             currentsize, remainingspace;
 
        *repair = 0;
 
-       asf = (struct xfs_attr_shortform *) XFS_DFORK_APTR(dip);
-
        /* Assumption: hdr.totsize is less than a leaf block and was checked
         * by lclinode for valid sizes. Check the count though.
        */
-       if (asf->hdr.count == 0)
+       if (hdr->count == 0)
                /* then the total size should just be the header length */
-               if (be16_to_cpu(asf->hdr.totsize) != sizeof(xfs_attr_sf_hdr_t)) {
+               if (be16_to_cpu(hdr->totsize) != sizeof(xfs_attr_sf_hdr_t)) {
                        /* whoops there's a discrepancy. Clear the hdr */
                        if (!no_modify) {
                                do_warn(
        _("there are no attributes in the fork for inode %" PRIu64 "\n"),
                                        ino);
-                               asf->hdr.totsize =
+                               hdr->totsize =
                                        cpu_to_be16(sizeof(xfs_attr_sf_hdr_t));
                                *repair = 1;
                                return(1);
@@ -243,15 +241,15 @@ process_shortform_attr(
                }
 
        currentsize = sizeof(xfs_attr_sf_hdr_t);
-       remainingspace = be16_to_cpu(asf->hdr.totsize) - currentsize;
-       nextentry = &asf->list[0];
-       for (i = 0; i < asf->hdr.count; i++)  {
+       remainingspace = be16_to_cpu(hdr->totsize) - currentsize;
+       nextentry = libxfs_attr_sf_firstentry(hdr);
+       for (i = 0; i < hdr->count; i++)  {
                currententry = nextentry;
                junkit = 0;
 
                /* don't go off the end if the hdr.count was off */
                if ((currentsize + (sizeof(struct xfs_attr_sf_entry) - 1)) >
-                                               be16_to_cpu(asf->hdr.totsize))
+                                               be16_to_cpu(hdr->totsize))
                        break; /* get out and reset count and totSize */
 
                /* if the namelen is 0, can't get to the rest of the entries */
@@ -326,7 +324,7 @@ process_shortform_attr(
                                        ((intptr_t) currententry +
                                         xfs_attr_sf_entsize(currententry));
                                memmove(currententry,tempentry,remainingspace);
-                               asf->hdr.count -= 1;
+                               hdr->count -= 1;
                                i--; /* no worries, it will wrap back to 0 */
                                *repair = 1;
                                continue; /* go back up now */
@@ -344,33 +342,33 @@ process_shortform_attr(
 
        } /* end the loop */
 
-       if (asf->hdr.count != i)  {
+       if (hdr->count != i)  {
                if (no_modify)  {
                        do_warn(
        _("would have corrected attribute entry count in inode %" PRIu64 " from %d to %d\n"),
-                               ino, asf->hdr.count, i);
+                               ino, hdr->count, i);
                } else  {
                        do_warn(
        _("corrected attribute entry count in inode %" PRIu64 ", was %d, now %d\n"),
-                               ino, asf->hdr.count, i);
-                       asf->hdr.count = i;
+                               ino, hdr->count, i);
+                       hdr->count = i;
                        *repair = 1;
                }
        }
 
        /* ASSUMPTION: currentsize <= totsize */
-       if (be16_to_cpu(asf->hdr.totsize) != currentsize)  {
+       if (be16_to_cpu(hdr->totsize) != currentsize)  {
                if (no_modify)  {
                        do_warn(
        _("would have corrected attribute totsize in inode %" PRIu64 " from %d to %d\n"),
-                               ino, be16_to_cpu(asf->hdr.totsize),
+                               ino, be16_to_cpu(hdr->totsize),
                                currentsize);
                } else  {
                        do_warn(
        _("corrected attribute entry totsize in inode %" PRIu64 ", was %d, now %d\n"),
-                               ino, be16_to_cpu(asf->hdr.totsize),
+                               ino, be16_to_cpu(hdr->totsize),
                                currentsize);
-                       asf->hdr.totsize = cpu_to_be16(currentsize);
+                       hdr->totsize = cpu_to_be16(currentsize);
                        *repair = 1;
                }
        }
@@ -1232,14 +1230,12 @@ process_attributes(
        int                     err;
        __u8                    aformat = dip->di_aformat;
 #ifdef DEBUG
-       struct xfs_attr_shortform *asf;
-
-       asf = (struct xfs_attr_shortform *) XFS_DFORK_APTR(dip);
+       struct xfs_attr_sf_hdr  *hdr = XFS_DFORK_APTR(dip);
 #endif
 
        if (aformat == XFS_DINODE_FMT_LOCAL) {
-               ASSERT(be16_to_cpu(asf->hdr.totsize) <=
-                       XFS_DFORK_ASIZE(dip, mp));
+               ASSERT(be16_to_cpu(hdr->totsize) <= XFS_DFORK_ASIZE(dip, mp));
+
                err = process_shortform_attr(mp, ino, dip, repair);
        } else if (aformat == XFS_DINODE_FMT_EXTENTS ||
                                        aformat == XFS_DINODE_FMT_BTREE)  {

diff --git a/repair/dinode.c b/repair/dinode.c
index c1cfadc8833e00f24f8d5b12ca7288b68089efe4..636e753fc74496080cbf8d9ffe1f9efe60eb17ca 100644 (file)
--- a/repair/dinode.c
+++ b/repair/dinode.c
@@ -99,10 +99,10 @@ _("would have cleared inode %" PRIu64 " attributes\n"), ino_num);
         */
 
        if (!no_modify) {
-               struct xfs_attr_shortform *asf = (struct xfs_attr_shortform *)
-                               XFS_DFORK_APTR(dino);
-               asf->hdr.totsize = cpu_to_be16(sizeof(xfs_attr_sf_hdr_t));
-               asf->hdr.count = 0;
+               struct xfs_attr_sf_hdr  *hdr = XFS_DFORK_APTR(dino);
+
+               hdr->totsize = cpu_to_be16(sizeof(struct xfs_attr_sf_hdr));
+               hdr->count = 0;
                dino->di_forkoff = 0;  /* got to do this after asf is set */
        }
 
@@ -993,7 +993,7 @@ process_lclinode(
        struct xfs_dinode               *dip,
        int                             whichfork)
 {
-       struct xfs_attr_shortform       *asf;
+       struct xfs_attr_sf_hdr          *hdr;
        xfs_ino_t                       lino;
 
        lino = XFS_AGINO_TO_INO(mp, agno, ino);
@@ -1005,18 +1005,19 @@ process_lclinode(
                        XFS_DFORK_DSIZE(dip, mp));
                return(1);
        } else if (whichfork == XFS_ATTR_FORK) {
-               asf = (struct xfs_attr_shortform *)XFS_DFORK_APTR(dip);
-               if (be16_to_cpu(asf->hdr.totsize) > XFS_DFORK_ASIZE(dip, mp)) {
+               hdr = XFS_DFORK_APTR(dip);
+
+               if (be16_to_cpu(hdr->totsize) > XFS_DFORK_ASIZE(dip, mp)) {
                        do_warn(
        _("local inode %" PRIu64 " attr fork too large (size %d, max = %zu)\n"),
-                               lino, be16_to_cpu(asf->hdr.totsize),
+                               lino, be16_to_cpu(hdr->totsize),
                                XFS_DFORK_ASIZE(dip, mp));
                        return(1);
                }
-               if (be16_to_cpu(asf->hdr.totsize) < sizeof(xfs_attr_sf_hdr_t)) {
+               if (be16_to_cpu(hdr->totsize) < sizeof(xfs_attr_sf_hdr_t)) {
                        do_warn(
        _("local inode %" PRIu64 " attr too small (size = %d, min size = %zd)\n"),
-                               lino, be16_to_cpu(asf->hdr.totsize),
+                               lino, be16_to_cpu(hdr->totsize),
                                sizeof(xfs_attr_sf_hdr_t));
                        return(1);
                }