Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-11-28 07:01:32 +00:00
Code Issues Packages Projects Releases Wiki Activity

posix_acl: xattr representation cleanups

Browse Source 
Remove the unnecessary typedefs and the zero-length a_entries array in
struct posix_acl_xattr_header.

Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
This commit is contained in:
Andreas Gruenbacher 2016-09-27 13:03:22 +02:00 committed by Al Viro
parent de04e76935
commit 2211d5ba5c
6 changed files with 51 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
drivers/staging/lustre/lustre/include/lustre_acl.h
View File

@ -38,8 +38,8 @@
#include <linux/posix_acl_xattr.h> #include <linux/posix_acl_xattr.h>
#define LUSTRE_POSIX_ACL_MAX_ENTRIES 32 #define LUSTRE_POSIX_ACL_MAX_ENTRIES 32
#define LUSTRE_POSIX_ACL_MAX_SIZE \ #define LUSTRE_POSIX_ACL_MAX_SIZE \
(sizeof(posix_acl_xattr_header) + \ (sizeof(struct posix_acl_xattr_header) + \
LUSTRE_POSIX_ACL_MAX_ENTRIES * sizeof(posix_acl_xattr_entry)) LUSTRE_POSIX_ACL_MAX_ENTRIES * sizeof(struct posix_acl_xattr_entry))
#endif #endif

44
drivers/staging/lustre/lustre/ptlrpc/wiretest.c
View File

@ -3745,32 +3745,28 @@ void lustre_assert_wire_constants(void)
CLASSERT(FIEMAP_EXTENT_NET == 0x80000000); CLASSERT(FIEMAP_EXTENT_NET == 0x80000000);
/* Checks for type posix_acl_xattr_entry */ /* Checks for type posix_acl_xattr_entry */
LASSERTF((int)sizeof(posix_acl_xattr_entry) == 8, "found %lld\n", LASSERTF((int)sizeof(struct posix_acl_xattr_entry) == 8, "found %lld\n",
(long long)(int)sizeof(posix_acl_xattr_entry)); (long long)(int)sizeof(struct posix_acl_xattr_entry));
LASSERTF((int)offsetof(posix_acl_xattr_entry, e_tag) == 0, "found %lld\n", LASSERTF((int)offsetof(struct posix_acl_xattr_entry, e_tag) == 0, "found %lld\n",
(long long)(int)offsetof(posix_acl_xattr_entry, e_tag)); (long long)(int)offsetof(struct posix_acl_xattr_entry, e_tag));
LASSERTF((int)sizeof(((posix_acl_xattr_entry *)0)->e_tag) == 2, "found %lld\n", LASSERTF((int)sizeof(((struct posix_acl_xattr_entry *)0)->e_tag) == 2, "found %lld\n",
(long long)(int)sizeof(((posix_acl_xattr_entry *)0)->e_tag)); (long long)(int)sizeof(((struct posix_acl_xattr_entry *)0)->e_tag));
LASSERTF((int)offsetof(posix_acl_xattr_entry, e_perm) == 2, "found %lld\n", LASSERTF((int)offsetof(struct posix_acl_xattr_entry, e_perm) == 2, "found %lld\n",
(long long)(int)offsetof(posix_acl_xattr_entry, e_perm)); (long long)(int)offsetof(struct posix_acl_xattr_entry, e_perm));
LASSERTF((int)sizeof(((posix_acl_xattr_entry *)0)->e_perm) == 2, "found %lld\n", LASSERTF((int)sizeof(((struct posix_acl_xattr_entry *)0)->e_perm) == 2, "found %lld\n",
(long long)(int)sizeof(((posix_acl_xattr_entry *)0)->e_perm)); (long long)(int)sizeof(((struct posix_acl_xattr_entry *)0)->e_perm));
LASSERTF((int)offsetof(posix_acl_xattr_entry, e_id) == 4, "found %lld\n", LASSERTF((int)offsetof(struct posix_acl_xattr_entry, e_id) == 4, "found %lld\n",
(long long)(int)offsetof(posix_acl_xattr_entry, e_id)); (long long)(int)offsetof(struct posix_acl_xattr_entry, e_id));
LASSERTF((int)sizeof(((posix_acl_xattr_entry *)0)->e_id) == 4, "found %lld\n", LASSERTF((int)sizeof(((struct posix_acl_xattr_entry *)0)->e_id) == 4, "found %lld\n",
(long long)(int)sizeof(((posix_acl_xattr_entry *)0)->e_id)); (long long)(int)sizeof(((struct posix_acl_xattr_entry *)0)->e_id));
/* Checks for type posix_acl_xattr_header */ /* Checks for type posix_acl_xattr_header */
LASSERTF((int)sizeof(posix_acl_xattr_header) == 4, "found %lld\n", LASSERTF((int)sizeof(struct posix_acl_xattr_header) == 4, "found %lld\n",
(long long)(int)sizeof(posix_acl_xattr_header)); (long long)(int)sizeof(struct posix_acl_xattr_header));
LASSERTF((int)offsetof(posix_acl_xattr_header, a_version) == 0, "found %lld\n", LASSERTF((int)offsetof(struct posix_acl_xattr_header, a_version) == 0, "found %lld\n",
(long long)(int)offsetof(posix_acl_xattr_header, a_version)); (long long)(int)offsetof(struct posix_acl_xattr_header, a_version));
LASSERTF((int)sizeof(((posix_acl_xattr_header *)0)->a_version) == 4, "found %lld\n", LASSERTF((int)sizeof(((struct posix_acl_xattr_header *)0)->a_version) == 4, "found %lld\n",
(long long)(int)sizeof(((posix_acl_xattr_header *)0)->a_version)); (long long)(int)sizeof(((struct posix_acl_xattr_header *)0)->a_version));
LASSERTF((int)offsetof(posix_acl_xattr_header, a_entries) == 4, "found %lld\n",
(long long)(int)offsetof(posix_acl_xattr_header, a_entries));
LASSERTF((int)sizeof(((posix_acl_xattr_header *)0)->a_entries) == 0, "found %lld\n",
(long long)(int)sizeof(((posix_acl_xattr_header *)0)->a_entries));
/* Checks for struct link_ea_header */ /* Checks for struct link_ea_header */
LASSERTF((int)sizeof(struct link_ea_header) == 24, "found %lld\n", LASSERTF((int)sizeof(struct link_ea_header) == 24, "found %lld\n",

2
fs/btrfs/send.c
View File

@ -4329,7 +4329,7 @@ static int __process_new_xattr(int num, struct btrfs_key *di_key,
int ret; int ret;
struct send_ctx *sctx = ctx; struct send_ctx *sctx = ctx;
struct fs_path *p; struct fs_path *p;
posix_acl_xattr_header dummy_acl; struct posix_acl_xattr_header dummy_acl;
p = fs_path_alloc(); p = fs_path_alloc();
if (!p) if (!p)

14
fs/cifs/cifssmb.c
View File

@ -3334,7 +3334,7 @@ CIFSSMB_set_compression(const unsigned int xid, struct cifs_tcon *tcon,
#ifdef CONFIG_CIFS_POSIX #ifdef CONFIG_CIFS_POSIX
/*Convert an Access Control Entry from wire format to local POSIX xattr format*/ /*Convert an Access Control Entry from wire format to local POSIX xattr format*/
static void cifs_convert_ace(posix_acl_xattr_entry *ace, static void cifs_convert_ace(struct posix_acl_xattr_entry *ace,
struct cifs_posix_ace *cifs_ace) struct cifs_posix_ace *cifs_ace)
{ {
/* u8 cifs fields do not need le conversion */ /* u8 cifs fields do not need le conversion */
@ -3358,7 +3358,7 @@ static int cifs_copy_posix_acl(char *trgt, char *src, const int buflen,
__u16 count; __u16 count;
struct cifs_posix_ace *pACE; struct cifs_posix_ace *pACE;
struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)src; struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)src;
posix_acl_xattr_header *local_acl = (posix_acl_xattr_header *)trgt; struct posix_acl_xattr_header *local_acl = (void *)trgt;
if (le16_to_cpu(cifs_acl->version) != CIFS_ACL_VERSION) if (le16_to_cpu(cifs_acl->version) != CIFS_ACL_VERSION)
return -EOPNOTSUPP; return -EOPNOTSUPP;
@ -3396,9 +3396,11 @@ static int cifs_copy_posix_acl(char *trgt, char *src, const int buflen,
} else if (size > buflen) { } else if (size > buflen) {
return -ERANGE; return -ERANGE;
} else /* buffer big enough */ { } else /* buffer big enough */ {
struct posix_acl_xattr_entry *ace = (void *)(local_acl + 1);
local_acl->a_version = cpu_to_le32(POSIX_ACL_XATTR_VERSION); local_acl->a_version = cpu_to_le32(POSIX_ACL_XATTR_VERSION);
for (i = 0; i < count ; i++) { for (i = 0; i < count ; i++) {
cifs_convert_ace(&local_acl->a_entries[i], pACE); cifs_convert_ace(&ace[i], pACE);
pACE++; pACE++;
} }
} }
@ -3406,7 +3408,7 @@ static int cifs_copy_posix_acl(char *trgt, char *src, const int buflen,
} }
static __u16 convert_ace_to_cifs_ace(struct cifs_posix_ace *cifs_ace, static __u16 convert_ace_to_cifs_ace(struct cifs_posix_ace *cifs_ace,
const posix_acl_xattr_entry *local_ace) const struct posix_acl_xattr_entry *local_ace)
{ {
__u16 rc = 0; /* 0 = ACL converted ok */ __u16 rc = 0; /* 0 = ACL converted ok */
@ -3431,7 +3433,7 @@ static __u16 ACL_to_cifs_posix(char *parm_data, const char *pACL,
{ {
__u16 rc = 0; __u16 rc = 0;
struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)parm_data; struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)parm_data;
posix_acl_xattr_header *local_acl = (posix_acl_xattr_header *)pACL; struct posix_acl_xattr_header *local_acl = (void *)pACL;
int count; int count;
int i; int i;
@ -3459,7 +3461,7 @@ static __u16 ACL_to_cifs_posix(char *parm_data, const char *pACL,
} }
for (i = 0; i < count; i++) { for (i = 0; i < count; i++) {
rc = convert_ace_to_cifs_ace(&cifs_acl->ace_array[i], rc = convert_ace_to_cifs_ace(&cifs_acl->ace_array[i],
&local_acl->a_entries[i]); (struct posix_acl_xattr_entry *)(local_acl + 1));
if (rc != 0) { if (rc != 0) {
/* ACE not converted */ /* ACE not converted */
break; break;

18
fs/posix_acl.c
View File

@ -633,15 +633,15 @@ static void posix_acl_fix_xattr_userns(
struct user_namespace *to, struct user_namespace *from, struct user_namespace *to, struct user_namespace *from,
void *value, size_t size) void *value, size_t size)
{ {
posix_acl_xattr_header *header = (posix_acl_xattr_header *)value; struct posix_acl_xattr_header *header = value;
posix_acl_xattr_entry *entry = (posix_acl_xattr_entry *)(header+1), *end; struct posix_acl_xattr_entry *entry = (void *)(header + 1), *end;
int count; int count;
kuid_t uid; kuid_t uid;
kgid_t gid; kgid_t gid;
if (!value) if (!value)
return; return;
if (size < sizeof(posix_acl_xattr_header)) if (size < sizeof(struct posix_acl_xattr_header))
return; return;
if (header->a_version != cpu_to_le32(POSIX_ACL_XATTR_VERSION)) if (header->a_version != cpu_to_le32(POSIX_ACL_XATTR_VERSION))
return; return;
@ -691,15 +691,15 @@ struct posix_acl *
posix_acl_from_xattr(struct user_namespace *user_ns, posix_acl_from_xattr(struct user_namespace *user_ns,
const void *value, size_t size) const void *value, size_t size)
{ {
posix_acl_xattr_header *header = (posix_acl_xattr_header *)value; const struct posix_acl_xattr_header *header = value;
posix_acl_xattr_entry *entry = (posix_acl_xattr_entry *)(header+1), *end; const struct posix_acl_xattr_entry *entry = (const void *)(header + 1), *end;
int count; int count;
struct posix_acl *acl; struct posix_acl *acl;
struct posix_acl_entry *acl_e; struct posix_acl_entry *acl_e;
if (!value) if (!value)
return NULL; return NULL;
if (size < sizeof(posix_acl_xattr_header)) if (size < sizeof(struct posix_acl_xattr_header))
return ERR_PTR(-EINVAL); return ERR_PTR(-EINVAL);
if (header->a_version != cpu_to_le32(POSIX_ACL_XATTR_VERSION)) if (header->a_version != cpu_to_le32(POSIX_ACL_XATTR_VERSION))
return ERR_PTR(-EOPNOTSUPP); return ERR_PTR(-EOPNOTSUPP);
@ -760,8 +760,8 @@ int
posix_acl_to_xattr(struct user_namespace *user_ns, const struct posix_acl *acl, posix_acl_to_xattr(struct user_namespace *user_ns, const struct posix_acl *acl,
void *buffer, size_t size) void *buffer, size_t size)
{ {
posix_acl_xattr_header *ext_acl = (posix_acl_xattr_header *)buffer; struct posix_acl_xattr_header *ext_acl = buffer;
posix_acl_xattr_entry *ext_entry; struct posix_acl_xattr_entry *ext_entry;
int real_size, n; int real_size, n;
real_size = posix_acl_xattr_size(acl->a_count); real_size = posix_acl_xattr_size(acl->a_count);
@ -770,7 +770,7 @@ posix_acl_to_xattr(struct user_namespace *user_ns, const struct posix_acl *acl,
if (real_size > size) if (real_size > size)
return -ERANGE; return -ERANGE;
ext_entry = ext_acl->a_entries; ext_entry = (void *)(ext_acl + 1);
ext_acl->a_version = cpu_to_le32(POSIX_ACL_XATTR_VERSION); ext_acl->a_version = cpu_to_le32(POSIX_ACL_XATTR_VERSION);
for (n=0; n < acl->a_count; n++, ext_entry++) { for (n=0; n < acl->a_count; n++, ext_entry++) {

21
include/linux/posix_acl_xattr.h
View File

@ -18,34 +18,33 @@
/* An undefined entry e_id value */ /* An undefined entry e_id value */
#define ACL_UNDEFINED_ID (-1) #define ACL_UNDEFINED_ID (-1)
typedef struct { struct posix_acl_xattr_entry {
__le16 e_tag; __le16 e_tag;
__le16 e_perm; __le16 e_perm;
__le32 e_id; __le32 e_id;
} posix_acl_xattr_entry; };
typedef struct { struct posix_acl_xattr_header {
__le32 a_version; __le32 a_version;
posix_acl_xattr_entry a_entries[0]; };
} posix_acl_xattr_header;
static inline size_t static inline size_t
posix_acl_xattr_size(int count) posix_acl_xattr_size(int count)
{ {
return (sizeof(posix_acl_xattr_header) + return (sizeof(struct posix_acl_xattr_header) +
(count * sizeof(posix_acl_xattr_entry))); (count * sizeof(struct posix_acl_xattr_entry)));
} }
static inline int static inline int
posix_acl_xattr_count(size_t size) posix_acl_xattr_count(size_t size)
{ {
if (size < sizeof(posix_acl_xattr_header)) if (size < sizeof(struct posix_acl_xattr_header))
return -1; return -1;
size -= sizeof(posix_acl_xattr_header); size -= sizeof(struct posix_acl_xattr_header);
if (size % sizeof(posix_acl_xattr_entry)) if (size % sizeof(struct posix_acl_xattr_entry))
return -1; return -1;
return size / sizeof(posix_acl_xattr_entry); return size / sizeof(struct posix_acl_xattr_entry);
} }
#ifdef CONFIG_FS_POSIX_ACL #ifdef CONFIG_FS_POSIX_ACL