Whamcloud - gitweb
LU-7261 ldiskfs: clean up code style for large_xattr 78/16778/4
authorAndreas Dilger <andreas.dilger@intel.com>
Fri, 9 Oct 2015 06:37:03 +0000 (00:37 -0600)
committerOleg Drokin <oleg.drokin@intel.com>
Wed, 11 Nov 2015 15:26:17 +0000 (15:26 +0000)
Clean up the code style for the large_xattr patches to match the
upstream kernel style (use ! instead of == 0, and similar), and
the original style of the code before the earlier versions of the
patch was applied.

Signed-off-by: Andreas Dilger <andreas.dilger@intel.com>
Change-Id: Icffe339d1b002a55984856829afde9e3eae98bd9
Reviewed-on: http://review.whamcloud.com/16778
Tested-by: Jenkins
Reviewed-by: Jian Yu <jian.yu@intel.com>
Tested-by: Maloo <hpdd-maloo@intel.com>
Reviewed-by: Niu Yawei <yawei.niu@intel.com>
Reviewed-by: James Simmons <uja.ornl@yahoo.com>
Reviewed-by: Oleg Drokin <oleg.drokin@intel.com>
ldiskfs/kernel_patches/patches/rhel6.3/ext4-large-eas.patch
ldiskfs/kernel_patches/patches/rhel7/ext4-large-eas.patch
ldiskfs/kernel_patches/patches/sles11sp2/ext4-large-eas.patch
ldiskfs/kernel_patches/patches/sles12/ext4-large-eas.patch

index 0d93421..a09bf18 100644 (file)
@@ -57,11 +57,10 @@ Index: linux-stage/fs/ext4/xattr.c
        size_t value_size = le32_to_cpu(entry->e_value_size);
  
 -      if (entry->e_value_block != 0 || value_size > size ||
        size_t value_size = le32_to_cpu(entry->e_value_size);
  
 -      if (entry->e_value_block != 0 || value_size > size ||
--          le16_to_cpu(entry->e_value_offs) + value_size > size)
-+      if ((entry->e_value_inum == 0) &&
-+         (le16_to_cpu(entry->e_value_offs) + value_size > size))
++      if (!entry->e_value_inum &&
+           le16_to_cpu(entry->e_value_offs) + value_size > size)
 +              return -EIO;
 +              return -EIO;
-+      if (entry->e_value_inum != 0 &&
++      if (entry->e_value_inum &&
 +          (le32_to_cpu(entry->e_value_inum) < EXT4_FIRST_INO(inode->i_sb) ||
 +           le32_to_cpu(entry->e_value_inum) >
 +           le32_to_cpu(EXT4_SB(inode->i_sb)->s_es->s_inodes_count)))
 +          (le32_to_cpu(entry->e_value_inum) < EXT4_FIRST_INO(inode->i_sb) ||
 +           le32_to_cpu(entry->e_value_inum) >
 +           le32_to_cpu(EXT4_SB(inode->i_sb)->s_es->s_inodes_count)))
@@ -199,7 +198,7 @@ Index: linux-stage/fs/ext4/xattr.c
                        goto cleanup;
 -              memcpy(buffer, bh->b_data + le16_to_cpu(entry->e_value_offs),
 -                     size);
                        goto cleanup;
 -              memcpy(buffer, bh->b_data + le16_to_cpu(entry->e_value_offs),
 -                     size);
-+              if (entry->e_value_inum != 0) {
++              if (entry->e_value_inum) {
 +                      error = ext4_xattr_inode_get(inode,
 +                                           le32_to_cpu(entry->e_value_inum),
 +                                           buffer, &size);
 +                      error = ext4_xattr_inode_get(inode,
 +                                           le32_to_cpu(entry->e_value_inum),
 +                                           buffer, &size);
@@ -227,7 +226,7 @@ Index: linux-stage/fs/ext4/xattr.c
                        goto cleanup;
 -              memcpy(buffer, (void *)IFIRST(header) +
 -                     le16_to_cpu(entry->e_value_offs), size);
                        goto cleanup;
 -              memcpy(buffer, (void *)IFIRST(header) +
 -                     le16_to_cpu(entry->e_value_offs), size);
-+              if (entry->e_value_inum != 0) {
++              if (entry->e_value_inum) {
 +                      error = ext4_xattr_inode_get(inode,
 +                                           le32_to_cpu(entry->e_value_inum),
 +                                           buffer, &size);
 +                      error = ext4_xattr_inode_get(inode,
 +                                           le32_to_cpu(entry->e_value_inum),
 +                                           buffer, &size);
@@ -245,7 +244,7 @@ Index: linux-stage/fs/ext4/xattr.c
        for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
                *total += EXT4_XATTR_LEN(last->e_name_len);
 -              if (!last->e_value_block && last->e_value_size) {
        for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
                *total += EXT4_XATTR_LEN(last->e_name_len);
 -              if (!last->e_value_block && last->e_value_size) {
-+              if (last->e_value_inum == 0 && last->e_value_size > 0) {
++              if (!last->e_value_inum && last->e_value_size) {
                        size_t offs = le16_to_cpu(last->e_value_offs);
                        if (offs < *min_offs)
                                *min_offs = offs;
                        size_t offs = le16_to_cpu(last->e_value_offs);
                        if (offs < *min_offs)
                                *min_offs = offs;
@@ -432,7 +431,7 @@ Index: linux-stage/fs/ext4/xattr.c
        last = s->first;
        for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
 -              if (!last->e_value_block && last->e_value_size) {
        last = s->first;
        for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
 -              if (!last->e_value_block && last->e_value_size) {
-+              if (last->e_value_inum == 0 && last->e_value_size > 0) {
++              if (!last->e_value_inum && last->e_value_size) {
                        size_t offs = le16_to_cpu(last->e_value_offs);
                        if (offs < min_offs)
                                min_offs = offs;
                        size_t offs = le16_to_cpu(last->e_value_offs);
                        if (offs < min_offs)
                                min_offs = offs;
@@ -441,8 +440,8 @@ Index: linux-stage/fs/ext4/xattr.c
        free = min_offs - ((void *)last - s->base) - sizeof(__u32);
        if (!s->not_found) {
 -              if (!s->here->e_value_block && s->here->e_value_size) {
        free = min_offs - ((void *)last - s->base) - sizeof(__u32);
        if (!s->not_found) {
 -              if (!s->here->e_value_block && s->here->e_value_size) {
-+              if (!in_inode && s->here->e_value_inum == 0 &&
-+                  s->here->e_value_size > 0) {
++              if (!in_inode &&
++                  !s->here->e_value_inum && s->here->e_value_size) {
                        size_t size = le32_to_cpu(s->here->e_value_size);
                        free += EXT4_XATTR_SIZE(size);
                }
                        size_t size = le32_to_cpu(s->here->e_value_size);
                        free += EXT4_XATTR_SIZE(size);
                }
@@ -467,8 +466,8 @@ Index: linux-stage/fs/ext4/xattr.c
                memcpy(s->here->e_name, i->name, name_len);
        } else {
 -              if (!s->here->e_value_block && s->here->e_value_size) {
                memcpy(s->here->e_name, i->name, name_len);
        } else {
 -              if (!s->here->e_value_block && s->here->e_value_size) {
-+              if (s->here->e_value_offs > 0 && s->here->e_value_inum == 0 &&
-+                  s->here->e_value_size > 0) {
++              if (!s->here->e_value_inum && s->here->e_value_size &&
++                  s->here->e_value_offs > 0) {
                        void *first_val = s->base + min_offs;
                        size_t offs = le16_to_cpu(s->here->e_value_offs);
                        void *val = s->base + offs;
                        void *first_val = s->base + min_offs;
                        size_t offs = le16_to_cpu(s->here->e_value_offs);
                        void *val = s->base + offs;
@@ -484,7 +483,7 @@ Index: linux-stage/fs/ext4/xattr.c
                                last = EXT4_XATTR_NEXT(last);
                        }
                }
                                last = EXT4_XATTR_NEXT(last);
                        }
                }
-+              if (s->here->e_value_inum != 0) {
++              if (s->here->e_value_inum) {
 +                      ext4_xattr_inode_unlink(inode,
 +                                      le32_to_cpu(s->here->e_value_inum));
 +                      s->here->e_value_inum = 0;
 +                      ext4_xattr_inode_unlink(inode,
 +                                      le32_to_cpu(s->here->e_value_inum));
 +                      s->here->e_value_inum = 0;
@@ -631,7 +630,7 @@ Index: linux-stage/fs/ext4/xattr.c
        /* Adjust the value offsets of the entries */
        for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
 -              if (!last->e_value_block && last->e_value_size) {
        /* Adjust the value offsets of the entries */
        for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
 -              if (!last->e_value_block && last->e_value_size) {
-+              if (last->e_value_inum == 0 && last->e_value_size > 0) {
++              if (!last->e_value_inum && last->e_value_size) {
                        new_offs = le16_to_cpu(last->e_value_offs) +
                                                        value_offs_shift;
                        BUG_ON(new_offs + le32_to_cpu(last->e_value_size)
                        new_offs = le16_to_cpu(last->e_value_offs) +
                                                        value_offs_shift;
                        BUG_ON(new_offs + le32_to_cpu(last->e_value_size)
@@ -674,7 +673,7 @@ Index: linux-stage/fs/ext4/xattr.c
 +                      return -ENOMEM;
 +              memcpy(new_array, *lea_ino_array,
 +                     offsetof(struct ext4_xattr_ino_array,
 +                      return -ENOMEM;
 +              memcpy(new_array, *lea_ino_array,
 +                     offsetof(struct ext4_xattr_ino_array,
-+                              xia_inodes[count]));
++                              xia_inodes[count]));
 +              kfree(*lea_ino_array);
 +              *lea_ino_array = new_array;
 +      }
 +              kfree(*lea_ino_array);
 +              *lea_ino_array = new_array;
 +      }
@@ -753,9 +752,9 @@ Index: linux-stage/fs/ext4/xattr.c
 +              goto cleanup;
 +      raw_inode = ext4_raw_inode(&iloc);
 +      header = IHDR(inode, raw_inode);
 +              goto cleanup;
 +      raw_inode = ext4_raw_inode(&iloc);
 +      header = IHDR(inode, raw_inode);
-+      entry = IFIRST(header);
-+      for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry)) {
-+              if (entry->e_value_inum == 0)
++      for (entry = IFIRST(header); !IS_LAST_ENTRY(entry);
++           entry = EXT4_XATTR_NEXT(entry)) {
++              if (!entry->e_value_inum)
 +                      continue;
 +              if (ext4_expand_ino_array(lea_ino_array,
 +                                        entry->e_value_inum) != 0) {
 +                      continue;
 +              if (ext4_expand_ino_array(lea_ino_array,
 +                                        entry->e_value_inum) != 0) {
@@ -781,9 +780,9 @@ Index: linux-stage/fs/ext4/xattr.c
                goto cleanup;
        }
 +
                goto cleanup;
        }
 +
-+      entry = BFIRST(bh);
-+      for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry)) {
-+              if (entry->e_value_inum == 0)
++      for (entry = BFIRST(bh); !IS_LAST_ENTRY(entry);
++           entry = EXT4_XATTR_NEXT(entry)) {
++              if (!entry->e_value_inum)
 +                      continue;
 +              if (ext4_expand_ino_array(lea_ino_array,
 +                                        entry->e_value_inum) != 0)
 +                      continue;
 +              if (ext4_expand_ino_array(lea_ino_array,
 +                                        entry->e_value_inum) != 0)
@@ -865,7 +864,7 @@ Index: linux-stage/fs/ext4/xattr.c
        }
  
 -      if (entry->e_value_block == 0 && entry->e_value_size != 0) {
        }
  
 -      if (entry->e_value_block == 0 && entry->e_value_size != 0) {
-+      if (entry->e_value_inum == 0 && entry->e_value_size != 0) {
++      if (!entry->e_value_inum && entry->e_value_size) {
                __le32 *value = (__le32 *)((char *)header +
                        le16_to_cpu(entry->e_value_offs));
                for (n = (le32_to_cpu(entry->e_value_size) +
                __le32 *value = (__le32 *)((char *)header +
                        le16_to_cpu(entry->e_value_offs));
                for (n = (le32_to_cpu(entry->e_value_size) +
index 94af1fe..24976ee 100644 (file)
@@ -164,11 +164,10 @@ Index: linux-stage/fs/ext4/xattr.c
        size_t value_size = le32_to_cpu(entry->e_value_size);
  
 -      if (entry->e_value_block != 0 || value_size > size ||
        size_t value_size = le32_to_cpu(entry->e_value_size);
  
 -      if (entry->e_value_block != 0 || value_size > size ||
--          le16_to_cpu(entry->e_value_offs) + value_size > size)
-+      if ((entry->e_value_inum == 0) &&
-+         (le16_to_cpu(entry->e_value_offs) + value_size > size))
++      if (!entry->e_value_inum &&
+           le16_to_cpu(entry->e_value_offs) + value_size > size)
 +              return -EIO;
 +              return -EIO;
-+      if (entry->e_value_inum != 0 &&
++      if (entry->e_value_inum &&
 +          (le32_to_cpu(entry->e_value_inum) < EXT4_FIRST_INO(inode->i_sb) ||
 +           le32_to_cpu(entry->e_value_inum) >
 +           le32_to_cpu(EXT4_SB(inode->i_sb)->s_es->s_inodes_count)))
 +          (le32_to_cpu(entry->e_value_inum) < EXT4_FIRST_INO(inode->i_sb) ||
 +           le32_to_cpu(entry->e_value_inum) >
 +           le32_to_cpu(EXT4_SB(inode->i_sb)->s_es->s_inodes_count)))
@@ -306,7 +305,7 @@ Index: linux-stage/fs/ext4/xattr.c
                        goto cleanup;
 -              memcpy(buffer, bh->b_data + le16_to_cpu(entry->e_value_offs),
 -                     size);
                        goto cleanup;
 -              memcpy(buffer, bh->b_data + le16_to_cpu(entry->e_value_offs),
 -                     size);
-+              if (entry->e_value_inum != 0) {
++              if (entry->e_value_inum) {
 +                      error = ext4_xattr_inode_get(inode,
 +                                           le32_to_cpu(entry->e_value_inum),
 +                                           buffer, &size);
 +                      error = ext4_xattr_inode_get(inode,
 +                                           le32_to_cpu(entry->e_value_inum),
 +                                           buffer, &size);
@@ -334,7 +333,7 @@ Index: linux-stage/fs/ext4/xattr.c
                        goto cleanup;
 -              memcpy(buffer, (void *)IFIRST(header) +
 -                     le16_to_cpu(entry->e_value_offs), size);
                        goto cleanup;
 -              memcpy(buffer, (void *)IFIRST(header) +
 -                     le16_to_cpu(entry->e_value_offs), size);
-+              if (entry->e_value_inum != 0) {
++              if (entry->e_value_inum) {
 +                      error = ext4_xattr_inode_get(inode,
 +                                           le32_to_cpu(entry->e_value_inum),
 +                                           buffer, &size);
 +                      error = ext4_xattr_inode_get(inode,
 +                                           le32_to_cpu(entry->e_value_inum),
 +                                           buffer, &size);
@@ -352,7 +351,7 @@ Index: linux-stage/fs/ext4/xattr.c
  {
        for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
 -              if (!last->e_value_block && last->e_value_size) {
  {
        for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
 -              if (!last->e_value_block && last->e_value_size) {
-+              if (last->e_value_inum == 0 && last->e_value_size > 0) {
++              if (!last->e_value_inum && last->e_value_size) {
                        size_t offs = le16_to_cpu(last->e_value_offs);
                        if (offs < *min_offs)
                                *min_offs = offs;
                        size_t offs = le16_to_cpu(last->e_value_offs);
                        if (offs < *min_offs)
                                *min_offs = offs;
@@ -529,7 +528,7 @@ Index: linux-stage/fs/ext4/xattr.c
        last = s->first;
        for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
 -              if (!last->e_value_block && last->e_value_size) {
        last = s->first;
        for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
 -              if (!last->e_value_block && last->e_value_size) {
-+              if (last->e_value_inum == 0 && last->e_value_size > 0) {
++              if (!last->e_value_inum && last->e_value_size) {
                        size_t offs = le16_to_cpu(last->e_value_offs);
                        if (offs < min_offs)
                                min_offs = offs;
                        size_t offs = le16_to_cpu(last->e_value_offs);
                        if (offs < min_offs)
                                min_offs = offs;
@@ -538,8 +537,8 @@ Index: linux-stage/fs/ext4/xattr.c
        free = min_offs - ((void *)last - s->base) - sizeof(__u32);
        if (!s->not_found) {
 -              if (!s->here->e_value_block && s->here->e_value_size) {
        free = min_offs - ((void *)last - s->base) - sizeof(__u32);
        if (!s->not_found) {
 -              if (!s->here->e_value_block && s->here->e_value_size) {
-+              if (!in_inode && s->here->e_value_inum == 0 &&
-+                  s->here->e_value_size > 0) {
++              if (!in_inode &&
++                  !s->here->e_value_inum && s->here->e_value_size) {
                        size_t size = le32_to_cpu(s->here->e_value_size);
                        free += EXT4_XATTR_SIZE(size);
                }
                        size_t size = le32_to_cpu(s->here->e_value_size);
                        free += EXT4_XATTR_SIZE(size);
                }
@@ -564,8 +563,8 @@ Index: linux-stage/fs/ext4/xattr.c
                memcpy(s->here->e_name, i->name, name_len);
        } else {
 -              if (!s->here->e_value_block && s->here->e_value_size) {
                memcpy(s->here->e_name, i->name, name_len);
        } else {
 -              if (!s->here->e_value_block && s->here->e_value_size) {
-+              if (s->here->e_value_offs > 0 && s->here->e_value_inum == 0 &&
-+                  s->here->e_value_size > 0) {
++              if (!s->here->e_value_inum && s->here->e_value_size &&
++                  s->here->e_value_offs > 0) {
                        void *first_val = s->base + min_offs;
                        size_t offs = le16_to_cpu(s->here->e_value_offs);
                        void *val = s->base + offs;
                        void *first_val = s->base + min_offs;
                        size_t offs = le16_to_cpu(s->here->e_value_offs);
                        void *val = s->base + offs;
@@ -581,7 +580,7 @@ Index: linux-stage/fs/ext4/xattr.c
                                last = EXT4_XATTR_NEXT(last);
                        }
                }
                                last = EXT4_XATTR_NEXT(last);
                        }
                }
-+              if (s->here->e_value_inum != 0) {
++              if (s->here->e_value_inum) {
 +                      ext4_xattr_inode_unlink(inode,
 +                                      le32_to_cpu(s->here->e_value_inum));
 +                      s->here->e_value_inum = 0;
 +                      ext4_xattr_inode_unlink(inode,
 +                                      le32_to_cpu(s->here->e_value_inum));
 +                      s->here->e_value_inum = 0;
@@ -742,7 +741,7 @@ Index: linux-stage/fs/ext4/xattr.c
        /* Adjust the value offsets of the entries */
        for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
 -              if (!last->e_value_block && last->e_value_size) {
        /* Adjust the value offsets of the entries */
        for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
 -              if (!last->e_value_block && last->e_value_size) {
-+              if (last->e_value_inum == 0 && last->e_value_size > 0) {
++              if (!last->e_value_inum && last->e_value_size) {
                        new_offs = le16_to_cpu(last->e_value_offs) +
                                                        value_offs_shift;
                        BUG_ON(new_offs + le32_to_cpu(last->e_value_size)
                        new_offs = le16_to_cpu(last->e_value_offs) +
                                                        value_offs_shift;
                        BUG_ON(new_offs + le32_to_cpu(last->e_value_size)
@@ -864,9 +863,9 @@ Index: linux-stage/fs/ext4/xattr.c
                goto cleanup;
 +      raw_inode = ext4_raw_inode(&iloc);
 +      header = IHDR(inode, raw_inode);
                goto cleanup;
 +      raw_inode = ext4_raw_inode(&iloc);
 +      header = IHDR(inode, raw_inode);
-+      entry = IFIRST(header);
-+      for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry)) {
-+              if (entry->e_value_inum == 0)
++      for (entry = IFIRST(header); !IS_LAST_ENTRY(entry);
++           entry = EXT4_XATTR_NEXT(entry)) {
++              if (!entry->e_value_inum)
 +                      continue;
 +              if (ext4_expand_ino_array(lea_ino_array,
 +                                        entry->e_value_inum) != 0) {
 +                      continue;
 +              if (ext4_expand_ino_array(lea_ino_array,
 +                                        entry->e_value_inum) != 0) {
@@ -892,9 +891,9 @@ Index: linux-stage/fs/ext4/xattr.c
                goto cleanup;
        }
 +
                goto cleanup;
        }
 +
-+      entry = BFIRST(bh);
-+      for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry)) {
-+              if (entry->e_value_inum == 0)
++      for (entry = BFIRST(bh); !IS_LAST_ENTRY(entry);
++           entry = EXT4_XATTR_NEXT(entry)) {
++              if (!entry->e_value_inum)
 +                      continue;
 +              if (ext4_expand_ino_array(lea_ino_array,
 +                                        entry->e_value_inum) != 0)
 +                      continue;
 +              if (ext4_expand_ino_array(lea_ino_array,
 +                                        entry->e_value_inum) != 0)
@@ -974,7 +973,7 @@ Index: linux-stage/fs/ext4/xattr.c
        }
  
 -      if (entry->e_value_block == 0 && entry->e_value_size != 0) {
        }
  
 -      if (entry->e_value_block == 0 && entry->e_value_size != 0) {
-+      if (entry->e_value_inum == 0 && entry->e_value_size != 0) {
++      if (!entry->e_value_inum && entry->e_value_size) {
                __le32 *value = (__le32 *)((char *)header +
                        le16_to_cpu(entry->e_value_offs));
                for (n = (le32_to_cpu(entry->e_value_size) +
                __le32 *value = (__le32 *)((char *)header +
                        le16_to_cpu(entry->e_value_offs));
                for (n = (le32_to_cpu(entry->e_value_size) +
index 64d8547..f9f70a6 100644 (file)
@@ -158,11 +158,10 @@ Index: linux-stage/fs/ext4/xattr.c
        size_t value_size = le32_to_cpu(entry->e_value_size);
  
 -      if (entry->e_value_block != 0 || value_size > size ||
        size_t value_size = le32_to_cpu(entry->e_value_size);
  
 -      if (entry->e_value_block != 0 || value_size > size ||
--          le16_to_cpu(entry->e_value_offs) + value_size > size)
-+      if ((entry->e_value_inum == 0) &&
-+         (le16_to_cpu(entry->e_value_offs) + value_size > size))
++      if (!entry->e_value_inum &&
+           le16_to_cpu(entry->e_value_offs) + value_size > size)
 +              return -EIO;
 +              return -EIO;
-+      if (entry->e_value_inum != 0 &&
++      if (entry->e_value_inum &&
 +          (le32_to_cpu(entry->e_value_inum) < EXT4_FIRST_INO(inode->i_sb) ||
 +           le32_to_cpu(entry->e_value_inum) >
 +           le32_to_cpu(EXT4_SB(inode->i_sb)->s_es->s_inodes_count)))
 +          (le32_to_cpu(entry->e_value_inum) < EXT4_FIRST_INO(inode->i_sb) ||
 +           le32_to_cpu(entry->e_value_inum) >
 +           le32_to_cpu(EXT4_SB(inode->i_sb)->s_es->s_inodes_count)))
@@ -300,7 +299,7 @@ Index: linux-stage/fs/ext4/xattr.c
                        goto cleanup;
 -              memcpy(buffer, bh->b_data + le16_to_cpu(entry->e_value_offs),
 -                     size);
                        goto cleanup;
 -              memcpy(buffer, bh->b_data + le16_to_cpu(entry->e_value_offs),
 -                     size);
-+              if (entry->e_value_inum != 0) {
++              if (entry->e_value_inum) {
 +                      error = ext4_xattr_inode_get(inode,
 +                                           le32_to_cpu(entry->e_value_inum),
 +                                           buffer, &size);
 +                      error = ext4_xattr_inode_get(inode,
 +                                           le32_to_cpu(entry->e_value_inum),
 +                                           buffer, &size);
@@ -328,7 +327,7 @@ Index: linux-stage/fs/ext4/xattr.c
                        goto cleanup;
 -              memcpy(buffer, (void *)IFIRST(header) +
 -                     le16_to_cpu(entry->e_value_offs), size);
                        goto cleanup;
 -              memcpy(buffer, (void *)IFIRST(header) +
 -                     le16_to_cpu(entry->e_value_offs), size);
-+              if (entry->e_value_inum != 0) {
++              if (entry->e_value_inum) {
 +                      error = ext4_xattr_inode_get(inode,
 +                                           le32_to_cpu(entry->e_value_inum),
 +                                           buffer, &size);
 +                      error = ext4_xattr_inode_get(inode,
 +                                           le32_to_cpu(entry->e_value_inum),
 +                                           buffer, &size);
@@ -346,7 +345,7 @@ Index: linux-stage/fs/ext4/xattr.c
        for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
                *total += EXT4_XATTR_LEN(last->e_name_len);
 -              if (!last->e_value_block && last->e_value_size) {
        for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
                *total += EXT4_XATTR_LEN(last->e_name_len);
 -              if (!last->e_value_block && last->e_value_size) {
-+              if (last->e_value_inum == 0 && last->e_value_size > 0) {
++              if (!last->e_value_inum && last->e_value_size) {
                        size_t offs = le16_to_cpu(last->e_value_offs);
                        if (offs < *min_offs)
                                *min_offs = offs;
                        size_t offs = le16_to_cpu(last->e_value_offs);
                        if (offs < *min_offs)
                                *min_offs = offs;
@@ -536,7 +535,7 @@ Index: linux-stage/fs/ext4/xattr.c
        last = s->first;
        for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
 -              if (!last->e_value_block && last->e_value_size) {
        last = s->first;
        for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
 -              if (!last->e_value_block && last->e_value_size) {
-+              if (last->e_value_inum == 0 && last->e_value_size > 0) {
++              if (!last->e_value_inum && last->e_value_size) {
                        size_t offs = le16_to_cpu(last->e_value_offs);
                        if (offs < min_offs)
                                min_offs = offs;
                        size_t offs = le16_to_cpu(last->e_value_offs);
                        if (offs < min_offs)
                                min_offs = offs;
@@ -545,8 +544,8 @@ Index: linux-stage/fs/ext4/xattr.c
        free = min_offs - ((void *)last - s->base) - sizeof(__u32);
        if (!s->not_found) {
 -              if (!s->here->e_value_block && s->here->e_value_size) {
        free = min_offs - ((void *)last - s->base) - sizeof(__u32);
        if (!s->not_found) {
 -              if (!s->here->e_value_block && s->here->e_value_size) {
-+              if (!in_inode && s->here->e_value_inum == 0 &&
-+                  s->here->e_value_size > 0) {
++              if (!in_inode &&
++                  !s->here->e_value_inum && s->here->e_value_size) {
                        size_t size = le32_to_cpu(s->here->e_value_size);
                        free += EXT4_XATTR_SIZE(size);
                }
                        size_t size = le32_to_cpu(s->here->e_value_size);
                        free += EXT4_XATTR_SIZE(size);
                }
@@ -571,8 +570,8 @@ Index: linux-stage/fs/ext4/xattr.c
                memcpy(s->here->e_name, i->name, name_len);
        } else {
 -              if (!s->here->e_value_block && s->here->e_value_size) {
                memcpy(s->here->e_name, i->name, name_len);
        } else {
 -              if (!s->here->e_value_block && s->here->e_value_size) {
-+              if (s->here->e_value_offs > 0 && s->here->e_value_inum == 0 &&
-+                  s->here->e_value_size > 0) {
++              if (!s->here->e_value_inum && s->here->e_value_size &&
++                  s->here->e_value_offs > 0) {
                        void *first_val = s->base + min_offs;
                        size_t offs = le16_to_cpu(s->here->e_value_offs);
                        void *val = s->base + offs;
                        void *first_val = s->base + min_offs;
                        size_t offs = le16_to_cpu(s->here->e_value_offs);
                        void *val = s->base + offs;
@@ -588,7 +587,7 @@ Index: linux-stage/fs/ext4/xattr.c
                                last = EXT4_XATTR_NEXT(last);
                        }
                }
                                last = EXT4_XATTR_NEXT(last);
                        }
                }
-+              if (s->here->e_value_inum != 0) {
++              if (s->here->e_value_inum) {
 +                      ext4_xattr_inode_unlink(inode,
 +                                      le32_to_cpu(s->here->e_value_inum));
 +                      s->here->e_value_inum = 0;
 +                      ext4_xattr_inode_unlink(inode,
 +                                      le32_to_cpu(s->here->e_value_inum));
 +                      s->here->e_value_inum = 0;
@@ -735,7 +734,7 @@ Index: linux-stage/fs/ext4/xattr.c
        /* Adjust the value offsets of the entries */
        for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
 -              if (!last->e_value_block && last->e_value_size) {
        /* Adjust the value offsets of the entries */
        for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
 -              if (!last->e_value_block && last->e_value_size) {
-+              if (last->e_value_inum == 0 && last->e_value_size > 0) {
++              if (!last->e_value_inum && last->e_value_size) {
                        new_offs = le16_to_cpu(last->e_value_offs) +
                                                        value_offs_shift;
                        BUG_ON(new_offs + le32_to_cpu(last->e_value_size)
                        new_offs = le16_to_cpu(last->e_value_offs) +
                                                        value_offs_shift;
                        BUG_ON(new_offs + le32_to_cpu(last->e_value_size)
@@ -778,7 +777,7 @@ Index: linux-stage/fs/ext4/xattr.c
 +                      return -ENOMEM;
 +              memcpy(new_array, *lea_ino_array,
 +                     offsetof(struct ext4_xattr_ino_array,
 +                      return -ENOMEM;
 +              memcpy(new_array, *lea_ino_array,
 +                     offsetof(struct ext4_xattr_ino_array,
-+                              xia_inodes[count]));
++                              xia_inodes[count]));
 +              kfree(*lea_ino_array);
 +              *lea_ino_array = new_array;
 +      }
 +              kfree(*lea_ino_array);
 +              *lea_ino_array = new_array;
 +      }
@@ -857,9 +856,9 @@ Index: linux-stage/fs/ext4/xattr.c
                goto cleanup;
 +      raw_inode = ext4_raw_inode(&iloc);
 +      header = IHDR(inode, raw_inode);
                goto cleanup;
 +      raw_inode = ext4_raw_inode(&iloc);
 +      header = IHDR(inode, raw_inode);
-+      entry = IFIRST(header);
-+      for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry)) {
-+              if (entry->e_value_inum == 0)
++      for (entry = IFIRST(header); !IS_LAST_ENTRY(entry);
++           entry = EXT4_XATTR_NEXT(entry)) {
++              if (!entry->e_value_inum)
 +                      continue;
 +              if (ext4_expand_ino_array(lea_ino_array,
 +                                        entry->e_value_inum) != 0) {
 +                      continue;
 +              if (ext4_expand_ino_array(lea_ino_array,
 +                                        entry->e_value_inum) != 0) {
@@ -885,9 +884,9 @@ Index: linux-stage/fs/ext4/xattr.c
                goto cleanup;
        }
 +
                goto cleanup;
        }
 +
-+      entry = BFIRST(bh);
-+      for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry)) {
-+              if (entry->e_value_inum == 0)
++      for (entry = BFIRST(bh); !IS_LAST_ENTRY(entry);
++           entry = EXT4_XATTR_NEXT(entry)) {
++              if (!entry->e_value_inum)
 +                      continue;
 +              if (ext4_expand_ino_array(lea_ino_array,
 +                                        entry->e_value_inum) != 0)
 +                      continue;
 +              if (ext4_expand_ino_array(lea_ino_array,
 +                                        entry->e_value_inum) != 0)
@@ -967,7 +966,7 @@ Index: linux-stage/fs/ext4/xattr.c
        }
  
 -      if (entry->e_value_block == 0 && entry->e_value_size != 0) {
        }
  
 -      if (entry->e_value_block == 0 && entry->e_value_size != 0) {
-+      if (entry->e_value_inum == 0 && entry->e_value_size != 0) {
++      if (!entry->e_value_inum && entry->e_value_size) {
                __le32 *value = (__le32 *)((char *)header +
                        le16_to_cpu(entry->e_value_offs));
                for (n = (le32_to_cpu(entry->e_value_size) +
                __le32 *value = (__le32 *)((char *)header +
                        le16_to_cpu(entry->e_value_offs));
                for (n = (le32_to_cpu(entry->e_value_size) +
index f680882..6a18661 100644 (file)
@@ -156,11 +156,10 @@ Index: linux-stage/fs/ext4/xattr.c
        size_t value_size = le32_to_cpu(entry->e_value_size);
  
 -      if (entry->e_value_block != 0 || value_size > size ||
        size_t value_size = le32_to_cpu(entry->e_value_size);
  
 -      if (entry->e_value_block != 0 || value_size > size ||
--          le16_to_cpu(entry->e_value_offs) + value_size > size)
-+      if ((entry->e_value_inum == 0) &&
-+         (le16_to_cpu(entry->e_value_offs) + value_size > size))
++      if (!entry->e_value_inum &&
+           le16_to_cpu(entry->e_value_offs) + value_size > size)
 +              return -EIO;
 +              return -EIO;
-+      if (entry->e_value_inum != 0 &&
++      if (entry->e_value_inum &&
 +          (le32_to_cpu(entry->e_value_inum) < EXT4_FIRST_INO(inode->i_sb) ||
 +           le32_to_cpu(entry->e_value_inum) >
 +           le32_to_cpu(EXT4_SB(inode->i_sb)->s_es->s_inodes_count)))
 +          (le32_to_cpu(entry->e_value_inum) < EXT4_FIRST_INO(inode->i_sb) ||
 +           le32_to_cpu(entry->e_value_inum) >
 +           le32_to_cpu(EXT4_SB(inode->i_sb)->s_es->s_inodes_count)))
@@ -298,7 +297,7 @@ Index: linux-stage/fs/ext4/xattr.c
                        goto cleanup;
 -              memcpy(buffer, bh->b_data + le16_to_cpu(entry->e_value_offs),
 -                     size);
                        goto cleanup;
 -              memcpy(buffer, bh->b_data + le16_to_cpu(entry->e_value_offs),
 -                     size);
-+              if (entry->e_value_inum != 0) {
++              if (entry->e_value_inum) {
 +                      error = ext4_xattr_inode_get(inode,
 +                                           le32_to_cpu(entry->e_value_inum),
 +                                           buffer, &size);
 +                      error = ext4_xattr_inode_get(inode,
 +                                           le32_to_cpu(entry->e_value_inum),
 +                                           buffer, &size);
@@ -326,7 +325,7 @@ Index: linux-stage/fs/ext4/xattr.c
                        goto cleanup;
 -              memcpy(buffer, (void *)IFIRST(header) +
 -                     le16_to_cpu(entry->e_value_offs), size);
                        goto cleanup;
 -              memcpy(buffer, (void *)IFIRST(header) +
 -                     le16_to_cpu(entry->e_value_offs), size);
-+              if (entry->e_value_inum != 0) {
++              if (entry->e_value_inum) {
 +                      error = ext4_xattr_inode_get(inode,
 +                                           le32_to_cpu(entry->e_value_inum),
 +                                           buffer, &size);
 +                      error = ext4_xattr_inode_get(inode,
 +                                           le32_to_cpu(entry->e_value_inum),
 +                                           buffer, &size);
@@ -344,7 +343,7 @@ Index: linux-stage/fs/ext4/xattr.c
        for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
                *total += EXT4_XATTR_LEN(last->e_name_len);
 -              if (!last->e_value_block && last->e_value_size) {
        for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
                *total += EXT4_XATTR_LEN(last->e_name_len);
 -              if (!last->e_value_block && last->e_value_size) {
-+              if (last->e_value_inum == 0 && last->e_value_size > 0) {
++              if (!last->e_value_inum && last->e_value_size) {
                        size_t offs = le16_to_cpu(last->e_value_offs);
                        if (offs < *min_offs)
                                *min_offs = offs;
                        size_t offs = le16_to_cpu(last->e_value_offs);
                        if (offs < *min_offs)
                                *min_offs = offs;
@@ -519,7 +518,7 @@ Index: linux-stage/fs/ext4/xattr.c
        last = s->first;
        for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
 -              if (!last->e_value_block && last->e_value_size) {
        last = s->first;
        for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
 -              if (!last->e_value_block && last->e_value_size) {
-+              if (last->e_value_inum == 0 && last->e_value_size > 0) {
++              if (!last->e_value_inum && last->e_value_size) {
                        size_t offs = le16_to_cpu(last->e_value_offs);
                        if (offs < min_offs)
                                min_offs = offs;
                        size_t offs = le16_to_cpu(last->e_value_offs);
                        if (offs < min_offs)
                                min_offs = offs;
@@ -528,8 +527,8 @@ Index: linux-stage/fs/ext4/xattr.c
        free = min_offs - ((void *)last - s->base) - sizeof(__u32);
        if (!s->not_found) {
 -              if (!s->here->e_value_block && s->here->e_value_size) {
        free = min_offs - ((void *)last - s->base) - sizeof(__u32);
        if (!s->not_found) {
 -              if (!s->here->e_value_block && s->here->e_value_size) {
-+              if (!in_inode && s->here->e_value_inum == 0 &&
-+                  s->here->e_value_size > 0) {
++              if (!in_inode &&
++                  !s->here->e_value_inum && s->here->e_value_size) {
                        size_t size = le32_to_cpu(s->here->e_value_size);
                        free += EXT4_XATTR_SIZE(size);
                }
                        size_t size = le32_to_cpu(s->here->e_value_size);
                        free += EXT4_XATTR_SIZE(size);
                }
@@ -554,8 +553,8 @@ Index: linux-stage/fs/ext4/xattr.c
                memcpy(s->here->e_name, i->name, name_len);
        } else {
 -              if (!s->here->e_value_block && s->here->e_value_size) {
                memcpy(s->here->e_name, i->name, name_len);
        } else {
 -              if (!s->here->e_value_block && s->here->e_value_size) {
-+              if (s->here->e_value_offs > 0 && s->here->e_value_inum == 0 &&
-+                  s->here->e_value_size > 0) {
++              if (!s->here->e_value_inum && s->here->e_value_size &&
++                  s->here->e_value_offs > 0) {
                        void *first_val = s->base + min_offs;
                        size_t offs = le16_to_cpu(s->here->e_value_offs);
                        void *val = s->base + offs;
                        void *first_val = s->base + min_offs;
                        size_t offs = le16_to_cpu(s->here->e_value_offs);
                        void *val = s->base + offs;
@@ -571,7 +570,7 @@ Index: linux-stage/fs/ext4/xattr.c
                                last = EXT4_XATTR_NEXT(last);
                        }
                }
                                last = EXT4_XATTR_NEXT(last);
                        }
                }
-+              if (s->here->e_value_inum != 0) {
++              if (s->here->e_value_inum) {
 +                      ext4_xattr_inode_unlink(inode,
 +                                      le32_to_cpu(s->here->e_value_inum));
 +                      s->here->e_value_inum = 0;
 +                      ext4_xattr_inode_unlink(inode,
 +                                      le32_to_cpu(s->here->e_value_inum));
 +                      s->here->e_value_inum = 0;
@@ -732,7 +731,7 @@ Index: linux-stage/fs/ext4/xattr.c
        /* Adjust the value offsets of the entries */
        for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
 -              if (!last->e_value_block && last->e_value_size) {
        /* Adjust the value offsets of the entries */
        for (; !IS_LAST_ENTRY(last); last = EXT4_XATTR_NEXT(last)) {
 -              if (!last->e_value_block && last->e_value_size) {
-+              if (last->e_value_inum == 0 && last->e_value_size > 0) {
++              if (!last->e_value_inum && last->e_value_size) {
                        new_offs = le16_to_cpu(last->e_value_offs) +
                                                        value_offs_shift;
                        BUG_ON(new_offs + le32_to_cpu(last->e_value_size)
                        new_offs = le16_to_cpu(last->e_value_offs) +
                                                        value_offs_shift;
                        BUG_ON(new_offs + le32_to_cpu(last->e_value_size)
@@ -854,9 +853,9 @@ Index: linux-stage/fs/ext4/xattr.c
                goto cleanup;
 +      raw_inode = ext4_raw_inode(&iloc);
 +      header = IHDR(inode, raw_inode);
                goto cleanup;
 +      raw_inode = ext4_raw_inode(&iloc);
 +      header = IHDR(inode, raw_inode);
-+      entry = IFIRST(header);
-+      for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry)) {
-+              if (entry->e_value_inum == 0)
++      for (entry = IFIRST(header); !IS_LAST_ENTRY(entry);
++           entry = EXT4_XATTR_NEXT(entry)) {
++              if (!entry->e_value_inum)
 +                      continue;
 +              if (ext4_expand_ino_array(lea_ino_array,
 +                                        entry->e_value_inum) != 0) {
 +                      continue;
 +              if (ext4_expand_ino_array(lea_ino_array,
 +                                        entry->e_value_inum) != 0) {
@@ -882,9 +881,9 @@ Index: linux-stage/fs/ext4/xattr.c
                goto cleanup;
        }
 +
                goto cleanup;
        }
 +
-+      entry = BFIRST(bh);
-+      for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry)) {
-+              if (entry->e_value_inum == 0)
++      for (entry = BFIRST(bh); !IS_LAST_ENTRY(entry);
++           entry = EXT4_XATTR_NEXT(entry)) {
++              if (!entry->e_value_inum)
 +                      continue;
 +              if (ext4_expand_ino_array(lea_ino_array,
 +                                        entry->e_value_inum) != 0)
 +                      continue;
 +              if (ext4_expand_ino_array(lea_ino_array,
 +                                        entry->e_value_inum) != 0)
@@ -964,7 +963,7 @@ Index: linux-stage/fs/ext4/xattr.c
        }
  
 -      if (entry->e_value_block == 0 && entry->e_value_size != 0) {
        }
  
 -      if (entry->e_value_block == 0 && entry->e_value_size != 0) {
-+      if (entry->e_value_inum == 0 && entry->e_value_size != 0) {
++      if (!entry->e_value_inum && entry->e_value_size) {
                __le32 *value = (__le32 *)((char *)header +
                        le16_to_cpu(entry->e_value_offs));
                for (n = (le32_to_cpu(entry->e_value_size) +
                __le32 *value = (__le32 *)((char *)header +
                        le16_to_cpu(entry->e_value_offs));
                for (n = (le32_to_cpu(entry->e_value_size) +