Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 2211d5ba authored by Andreas Gruenbacher's avatar Andreas Gruenbacher Committed by Al Viro
Browse files

posix_acl: xattr representation cleanups 



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

Signed-off-by: default avatarAndreas Gruenbacher <agruenba@redhat.com>
Signed-off-by: default avatarAl Viro <viro@zeniv.linux.org.uk>
parent de04e769

drivers/staging/lustre/lustre/include/lustre_acl.h

+3 −3
Original line number Diff line number Diff line
@@ -39,7 +39,7 @@ 


#define LUSTRE_POSIX_ACL_MAX_ENTRIES	32

#define LUSTRE_POSIX_ACL_MAX_SIZE						\

	(sizeof(posix_acl_xattr_header) +				\

	 LUSTRE_POSIX_ACL_MAX_ENTRIES * sizeof(posix_acl_xattr_entry))

	(sizeof(struct posix_acl_xattr_header) +				\

	 LUSTRE_POSIX_ACL_MAX_ENTRIES * sizeof(struct posix_acl_xattr_entry))



#endif

drivers/staging/lustre/lustre/ptlrpc/wiretest.c

+20 −24
Original line number Diff line number Diff line
@@ -3745,32 +3745,28 @@ void lustre_assert_wire_constants(void) 
	CLASSERT(FIEMAP_EXTENT_NET == 0x80000000);



	/* Checks for type posix_acl_xattr_entry */

	LASSERTF((int)sizeof(posix_acl_xattr_entry) == 8, "found %lld\n",

		 (long long)(int)sizeof(posix_acl_xattr_entry));

	LASSERTF((int)offsetof(posix_acl_xattr_entry, e_tag) == 0, "found %lld\n",

		 (long long)(int)offsetof(posix_acl_xattr_entry, e_tag));

	LASSERTF((int)sizeof(((posix_acl_xattr_entry *)0)->e_tag) == 2, "found %lld\n",

		 (long long)(int)sizeof(((posix_acl_xattr_entry *)0)->e_tag));

	LASSERTF((int)offsetof(posix_acl_xattr_entry, e_perm) == 2, "found %lld\n",

		 (long long)(int)offsetof(posix_acl_xattr_entry, e_perm));

	LASSERTF((int)sizeof(((posix_acl_xattr_entry *)0)->e_perm) == 2, "found %lld\n",

		 (long long)(int)sizeof(((posix_acl_xattr_entry *)0)->e_perm));

	LASSERTF((int)offsetof(posix_acl_xattr_entry, e_id) == 4, "found %lld\n",

		 (long long)(int)offsetof(posix_acl_xattr_entry, e_id));

	LASSERTF((int)sizeof(((posix_acl_xattr_entry *)0)->e_id) == 4, "found %lld\n",

		 (long long)(int)sizeof(((posix_acl_xattr_entry *)0)->e_id));

	LASSERTF((int)sizeof(struct posix_acl_xattr_entry) == 8, "found %lld\n",

		 (long long)(int)sizeof(struct posix_acl_xattr_entry));

	LASSERTF((int)offsetof(struct posix_acl_xattr_entry, e_tag) == 0, "found %lld\n",

		 (long long)(int)offsetof(struct posix_acl_xattr_entry, e_tag));

	LASSERTF((int)sizeof(((struct posix_acl_xattr_entry *)0)->e_tag) == 2, "found %lld\n",

		 (long long)(int)sizeof(((struct posix_acl_xattr_entry *)0)->e_tag));

	LASSERTF((int)offsetof(struct posix_acl_xattr_entry, e_perm) == 2, "found %lld\n",

		 (long long)(int)offsetof(struct posix_acl_xattr_entry, e_perm));

	LASSERTF((int)sizeof(((struct posix_acl_xattr_entry *)0)->e_perm) == 2, "found %lld\n",

		 (long long)(int)sizeof(((struct posix_acl_xattr_entry *)0)->e_perm));

	LASSERTF((int)offsetof(struct posix_acl_xattr_entry, e_id) == 4, "found %lld\n",

		 (long long)(int)offsetof(struct posix_acl_xattr_entry, e_id));

	LASSERTF((int)sizeof(((struct posix_acl_xattr_entry *)0)->e_id) == 4, "found %lld\n",

		 (long long)(int)sizeof(((struct posix_acl_xattr_entry *)0)->e_id));



	/* Checks for type posix_acl_xattr_header */

	LASSERTF((int)sizeof(posix_acl_xattr_header) == 4, "found %lld\n",

		 (long long)(int)sizeof(posix_acl_xattr_header));

	LASSERTF((int)offsetof(posix_acl_xattr_header, a_version) == 0, "found %lld\n",

		 (long long)(int)offsetof(posix_acl_xattr_header, a_version));

	LASSERTF((int)sizeof(((posix_acl_xattr_header *)0)->a_version) == 4, "found %lld\n",

		 (long long)(int)sizeof(((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));

	LASSERTF((int)sizeof(struct posix_acl_xattr_header) == 4, "found %lld\n",

		 (long long)(int)sizeof(struct posix_acl_xattr_header));

	LASSERTF((int)offsetof(struct posix_acl_xattr_header, a_version) == 0, "found %lld\n",

		 (long long)(int)offsetof(struct posix_acl_xattr_header, a_version));

	LASSERTF((int)sizeof(((struct posix_acl_xattr_header *)0)->a_version) == 4, "found %lld\n",

		 (long long)(int)sizeof(((struct posix_acl_xattr_header *)0)->a_version));



	/* Checks for struct link_ea_header */

	LASSERTF((int)sizeof(struct link_ea_header) == 24, "found %lld\n",

fs/btrfs/send.c

+1 −1
Original line number Diff line number Diff line
@@ -4329,7 +4329,7 @@ static int __process_new_xattr(int num, struct btrfs_key *di_key, 
	int ret;

	struct send_ctx *sctx = ctx;

	struct fs_path *p;

	posix_acl_xattr_header dummy_acl;

	struct posix_acl_xattr_header dummy_acl;



	p = fs_path_alloc();

	if (!p)

fs/cifs/cifssmb.c

+8 −6
Original line number Diff line number Diff line
@@ -3334,7 +3334,7 @@ CIFSSMB_set_compression(const unsigned int xid, struct cifs_tcon *tcon, 
#ifdef CONFIG_CIFS_POSIX



/*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)

{

	/* 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;

	struct cifs_posix_ace *pACE;

	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)

		return -EOPNOTSUPP;
@@ -3396,9 +3396,11 @@ static int cifs_copy_posix_acl(char *trgt, char *src, const int buflen, 
	} else if (size > buflen) {

		return -ERANGE;

	} 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);

		for (i = 0; i < count ; i++) {

			cifs_convert_ace(&local_acl->a_entries[i], pACE);

			cifs_convert_ace(&ace[i], 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,

				     const posix_acl_xattr_entry *local_ace)

				     const struct posix_acl_xattr_entry *local_ace)

{

	__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;

	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 i;
@@ -3459,7 +3461,7 @@ static __u16 ACL_to_cifs_posix(char *parm_data, const char *pACL, 
	}

	for (i = 0; i < count; 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) {

			/* ACE not converted */

			break;

fs/posix_acl.c

+9 −9
Original line number Diff line number Diff line
@@ -633,15 +633,15 @@ static void posix_acl_fix_xattr_userns( 
	struct user_namespace *to, struct user_namespace *from,

	void *value, size_t size)

{

	posix_acl_xattr_header *header = (posix_acl_xattr_header *)value;

	posix_acl_xattr_entry *entry = (posix_acl_xattr_entry *)(header+1), *end;

	struct posix_acl_xattr_header *header = value;

	struct posix_acl_xattr_entry *entry = (void *)(header + 1), *end;

	int count;

	kuid_t uid;

	kgid_t gid;



	if (!value)

		return;

	if (size < sizeof(posix_acl_xattr_header))

	if (size < sizeof(struct posix_acl_xattr_header))

		return;

	if (header->a_version != cpu_to_le32(POSIX_ACL_XATTR_VERSION))

		return;
@@ -691,15 +691,15 @@ struct posix_acl * 
posix_acl_from_xattr(struct user_namespace *user_ns,

		     const void *value, size_t size)

{

	posix_acl_xattr_header *header = (posix_acl_xattr_header *)value;

	posix_acl_xattr_entry *entry = (posix_acl_xattr_entry *)(header+1), *end;

	const struct posix_acl_xattr_header *header = value;

	const struct posix_acl_xattr_entry *entry = (const void *)(header + 1), *end;

	int count;

	struct posix_acl *acl;

	struct posix_acl_entry *acl_e;



	if (!value)

		return NULL;

	if (size < sizeof(posix_acl_xattr_header))

	if (size < sizeof(struct posix_acl_xattr_header))

		 return ERR_PTR(-EINVAL);

	if (header->a_version != cpu_to_le32(POSIX_ACL_XATTR_VERSION))

		return ERR_PTR(-EOPNOTSUPP);
@@ -760,8 +760,8 @@ int 
posix_acl_to_xattr(struct user_namespace *user_ns, const struct posix_acl *acl,

		   void *buffer, size_t size)

{

	posix_acl_xattr_header *ext_acl = (posix_acl_xattr_header *)buffer;

	posix_acl_xattr_entry *ext_entry;

	struct posix_acl_xattr_header *ext_acl = buffer;

	struct posix_acl_xattr_entry *ext_entry;

	int real_size, n;



	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)

		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);



	for (n=0; n < acl->a_count; n++, ext_entry++) {