[PATCH] posix_acl: resolve compile dependency in posix_acl.h

[PATCH] posix_acl: resolve compile dependency in posix_acl.h

[Benny Halevy]

[-- Attachment #1: Type: text/plain, Size: 1049 bytes --]

From: Benny Halevy <bhalevy-C4P08NqkoRlBDgjK7y7TUQ@public.gmane.org>

get_cached_acl is defined as inline in posix_acl.h
requiring the full definition of struct inode as it
dereferences its struct inode * parameter.

Cc: Alexander Viro <viro-RmSDqhL/yNMiFSDQTTA3OLVCufUGDwFn@public.gmane.org>
Cc: linux-fsdevel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
Cc: J. Bruce Fields <bfields-uC3wQj2KruNg9hUCZPvPmw@public.gmane.org>
Cc: Trond Myklebust <Trond.Myklebust-HgOvQuBEEgTQT0dZR+AlfA@public.gmane.org>
Signed-off-by: Benny Halevy <bhalevy-C4P08NqkoRlBDgjK7y7TUQ@public.gmane.org>
Signed-off-by: Benny Halevy <bhalevy-7I+n7zu2hftEKMMhf/gKZA@public.gmane.org>
---
 include/linux/posix_acl.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/include/linux/posix_acl.h b/include/linux/posix_acl.h
index 7931efe..a7d8b04 100644
--- a/include/linux/posix_acl.h
+++ b/include/linux/posix_acl.h
@@ -9,6 +9,7 @@
 #define __LINUX_POSIX_ACL_H

 #include <linux/bug.h>
+#include <linux/fs.h>
 #include <linux/slab.h>
 #include <linux/rcupdate.h>

-- 
1.8.3.1




[-- Attachment #2: Attached Message Part --]
[-- Type: text/plain, Size: 0 bytes --]

Re: [PATCH] posix_acl: resolve compile dependency in posix_acl.h

[Andrew Morton]

On Wed, 02 Oct 2013 17:36:29 +0300 Benny Halevy <bhalevy@primarydata.com> wrote:

> From: Benny Halevy <bhalevy@panasas.com>
> 
> get_cached_acl is defined as inline in posix_acl.h
> requiring the full definition of struct inode as it
> dereferences its struct inode * parameter.

That's very old code so you must have a peculiar config.  Please
describe the circumstances under which this occurs, because I'd like to
avoid merging this patch.

> --- a/include/linux/posix_acl.h
> +++ b/include/linux/posix_acl.h
> @@ -9,6 +9,7 @@
>  #define __LINUX_POSIX_ACL_H
> 
>  #include <linux/bug.h>
> +#include <linux/fs.h>
>  #include <linux/slab.h>
>  #include <linux/rcupdate.h>

A better fix is to undo all that crazy inlining in posix_acl.h.


From: Andrew Morton <akpm@linux-foundation.org>
Subject: posix_acl: uninlining

Uninline vast tracts of nested inline functions in
include/linux/posix_acl.h.

This reduces the text+data+bss size of x86_64 allyesconfig vmlinux by 8026
bytes.

Also fixes an obscure build error reported by Benny: get_cached_acl()
needs fs.h for struct inode internals.

The patch also regularises the positioning of the EXPORT_SYMBOLs in
posix_acl.c.

Reported-by:: Benny Halevy <bhalevy@panasas.com>
Cc: Alexander Viro <viro@zeniv.linux.org.uk>
Cc: J. Bruce Fields <bfields@fieldses.org>
Cc: Trond Myklebust <Trond.Myklebust@netapp.com>
Cc: Benny Halevy <bhalevy@primarydata.com>
Cc: Andreas Gruenbacher <agruen@suse.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
---

 fs/posix_acl.c            |   84 +++++++++++++++++++++++++++++++++---
 include/linux/posix_acl.h |   78 ++-------------------------------
 2 files changed, 85 insertions(+), 77 deletions(-)

diff -puN fs/posix_acl.c~posix_acl-uninlining fs/posix_acl.c
--- a/fs/posix_acl.c~posix_acl-uninlining
+++ a/fs/posix_acl.c
@@ -22,11 +22,80 @@
 
 #include <linux/errno.h>
 
-EXPORT_SYMBOL(posix_acl_init);
-EXPORT_SYMBOL(posix_acl_alloc);
-EXPORT_SYMBOL(posix_acl_valid);
-EXPORT_SYMBOL(posix_acl_equiv_mode);
-EXPORT_SYMBOL(posix_acl_from_mode);
+struct posix_acl **acl_by_type(struct inode *inode, int type)
+{
+	switch (type) {
+	case ACL_TYPE_ACCESS:
+		return &inode->i_acl;
+	case ACL_TYPE_DEFAULT:
+		return &inode->i_default_acl;
+	default:
+		BUG();
+	}
+}
+EXPORT_SYMBOL(acl_by_type);
+
+struct posix_acl *get_cached_acl(struct inode *inode, int type)
+{
+	struct posix_acl **p = acl_by_type(inode, type);
+	struct posix_acl *acl = ACCESS_ONCE(*p);
+	if (acl) {
+		spin_lock(&inode->i_lock);
+		acl = *p;
+		if (acl != ACL_NOT_CACHED)
+			acl = posix_acl_dup(acl);
+		spin_unlock(&inode->i_lock);
+	}
+	return acl;
+}
+EXPORT_SYMBOL(get_cached_acl);
+
+struct posix_acl *get_cached_acl_rcu(struct inode *inode, int type)
+{
+	return rcu_dereference(*acl_by_type(inode, type));
+}
+EXPORT_SYMBOL(get_cached_acl_rcu);
+
+void set_cached_acl(struct inode *inode, int type, struct posix_acl *acl)
+{
+	struct posix_acl **p = acl_by_type(inode, type);
+	struct posix_acl *old;
+	spin_lock(&inode->i_lock);
+	old = *p;
+	rcu_assign_pointer(*p, posix_acl_dup(acl));
+	spin_unlock(&inode->i_lock);
+	if (old != ACL_NOT_CACHED)
+		posix_acl_release(old);
+}
+EXPORT_SYMBOL(set_cached_acl);
+
+void forget_cached_acl(struct inode *inode, int type)
+{
+	struct posix_acl **p = acl_by_type(inode, type);
+	struct posix_acl *old;
+	spin_lock(&inode->i_lock);
+	old = *p;
+	*p = ACL_NOT_CACHED;
+	spin_unlock(&inode->i_lock);
+	if (old != ACL_NOT_CACHED)
+		posix_acl_release(old);
+}
+EXPORT_SYMBOL(forget_cached_acl);
+
+void forget_all_cached_acls(struct inode *inode)
+{
+	struct posix_acl *old_access, *old_default;
+	spin_lock(&inode->i_lock);
+	old_access = inode->i_acl;
+	old_default = inode->i_default_acl;
+	inode->i_acl = inode->i_default_acl = ACL_NOT_CACHED;
+	spin_unlock(&inode->i_lock);
+	if (old_access != ACL_NOT_CACHED)
+		posix_acl_release(old_access);
+	if (old_default != ACL_NOT_CACHED)
+		posix_acl_release(old_default);
+}
+EXPORT_SYMBOL(forget_all_cached_acls);
 
 /*
  * Init a fresh posix_acl
@@ -37,6 +106,7 @@ posix_acl_init(struct posix_acl *acl, in
 	atomic_set(&acl->a_refcount, 1);
 	acl->a_count = count;
 }
+EXPORT_SYMBOL(posix_acl_init);
 
 /*
  * Allocate a new ACL with the specified number of entries.
@@ -51,6 +121,7 @@ posix_acl_alloc(int count, gfp_t flags)
 		posix_acl_init(acl, count);
 	return acl;
 }
+EXPORT_SYMBOL(posix_acl_alloc);
 
 /*
  * Clone an ACL.
@@ -146,6 +217,7 @@ posix_acl_valid(const struct posix_acl *
 		return 0;
 	return -EINVAL;
 }
+EXPORT_SYMBOL(posix_acl_valid);
 
 /*
  * Returns 0 if the acl can be exactly represented in the traditional
@@ -186,6 +258,7 @@ posix_acl_equiv_mode(const struct posix_
                 *mode_p = (*mode_p & ~S_IRWXUGO) | mode;
         return not_equiv;
 }
+EXPORT_SYMBOL(posix_acl_equiv_mode);
 
 /*
  * Create an ACL representing the file mode permission bits of an inode.
@@ -207,6 +280,7 @@ posix_acl_from_mode(umode_t mode, gfp_t
 	acl->a_entries[2].e_perm = (mode & S_IRWXO);
 	return acl;
 }
+EXPORT_SYMBOL(posix_acl_from_mode);
 
 /*
  * Return 0 if current is granted want access to the inode
diff -puN include/linux/posix_acl.h~posix_acl-uninlining include/linux/posix_acl.h
--- a/include/linux/posix_acl.h~posix_acl-uninlining
+++ a/include/linux/posix_acl.h
@@ -94,78 +94,12 @@ extern int posix_acl_chmod(struct posix_
 extern struct posix_acl *get_posix_acl(struct inode *, int);
 extern int set_posix_acl(struct inode *, int, struct posix_acl *);
 
-#ifdef CONFIG_FS_POSIX_ACL
-static inline struct posix_acl **acl_by_type(struct inode *inode, int type)
-{
-	switch (type) {
-	case ACL_TYPE_ACCESS:
-		return &inode->i_acl;
-	case ACL_TYPE_DEFAULT:
-		return &inode->i_default_acl;
-	default:
-		BUG();
-	}
-}
-
-static inline struct posix_acl *get_cached_acl(struct inode *inode, int type)
-{
-	struct posix_acl **p = acl_by_type(inode, type);
-	struct posix_acl *acl = ACCESS_ONCE(*p);
-	if (acl) {
-		spin_lock(&inode->i_lock);
-		acl = *p;
-		if (acl != ACL_NOT_CACHED)
-			acl = posix_acl_dup(acl);
-		spin_unlock(&inode->i_lock);
-	}
-	return acl;
-}
-
-static inline struct posix_acl *get_cached_acl_rcu(struct inode *inode, int type)
-{
-	return rcu_dereference(*acl_by_type(inode, type));
-}
-
-static inline void set_cached_acl(struct inode *inode,
-				  int type,
-				  struct posix_acl *acl)
-{
-	struct posix_acl **p = acl_by_type(inode, type);
-	struct posix_acl *old;
-	spin_lock(&inode->i_lock);
-	old = *p;
-	rcu_assign_pointer(*p, posix_acl_dup(acl));
-	spin_unlock(&inode->i_lock);
-	if (old != ACL_NOT_CACHED)
-		posix_acl_release(old);
-}
-
-static inline void forget_cached_acl(struct inode *inode, int type)
-{
-	struct posix_acl **p = acl_by_type(inode, type);
-	struct posix_acl *old;
-	spin_lock(&inode->i_lock);
-	old = *p;
-	*p = ACL_NOT_CACHED;
-	spin_unlock(&inode->i_lock);
-	if (old != ACL_NOT_CACHED)
-		posix_acl_release(old);
-}
-
-static inline void forget_all_cached_acls(struct inode *inode)
-{
-	struct posix_acl *old_access, *old_default;
-	spin_lock(&inode->i_lock);
-	old_access = inode->i_acl;
-	old_default = inode->i_default_acl;
-	inode->i_acl = inode->i_default_acl = ACL_NOT_CACHED;
-	spin_unlock(&inode->i_lock);
-	if (old_access != ACL_NOT_CACHED)
-		posix_acl_release(old_access);
-	if (old_default != ACL_NOT_CACHED)
-		posix_acl_release(old_default);
-}
-#endif
+struct posix_acl **acl_by_type(struct inode *inode, int type);
+struct posix_acl *get_cached_acl(struct inode *inode, int type);
+struct posix_acl *get_cached_acl_rcu(struct inode *inode, int type);
+void set_cached_acl(struct inode *inode, int type, struct posix_acl *acl);
+void forget_cached_acl(struct inode *inode, int type);
+void forget_all_cached_acls(struct inode *inode);
 
 static inline void cache_no_acl(struct inode *inode)
 {
_

Re: [PATCH] posix_acl: resolve compile dependency in posix_acl.h

[Benny Halevy]

On 2013-10-10 01:41, Andrew Morton wrote:
> On Wed, 02 Oct 2013 17:36:29 +0300 Benny Halevy <bhalevy-7I+n7zu2hftEKMMhf/gKZA@public.gmane.org> wrote:
> 
>> From: Benny Halevy <bhalevy-C4P08NqkoRlBDgjK7y7TUQ@public.gmane.org>
>>
>> get_cached_acl is defined as inline in posix_acl.h
>> requiring the full definition of struct inode as it
>> dereferences its struct inode * parameter.
> 
> That's very old code so you must have a peculiar config.  Please
> describe the circumstances under which this occurs, because I'd like to
> avoid merging this patch.
> 

Wow, sorry, you're right.  It originated in 2.6.33 as far as I can see
and it is no longer needed.

>> --- a/include/linux/posix_acl.h
>> +++ b/include/linux/posix_acl.h
>> @@ -9,6 +9,7 @@
>>  #define __LINUX_POSIX_ACL_H
>>
>>  #include <linux/bug.h>
>> +#include <linux/fs.h>
>>  #include <linux/slab.h>
>>  #include <linux/rcupdate.h>
> 
> A better fix is to undo all that crazy inlining in posix_acl.h.
> 
> 
> From: Andrew Morton <akpm-de/tnXTf+JLsfHDXvbKv3WD2FQJk+8+b@public.gmane.org>
> Subject: posix_acl: uninlining
> 
> Uninline vast tracts of nested inline functions in
> include/linux/posix_acl.h.
> 
> This reduces the text+data+bss size of x86_64 allyesconfig vmlinux by 8026
> bytes.
> 
> Also fixes an obscure build error reported by Benny: get_cached_acl()
> needs fs.h for struct inode internals.

Sorry for the stale report, I have no problem with 3.12-rc3.

> 
> The patch also regularises the positioning of the EXPORT_SYMBOLs in
> posix_acl.c.
> 
> Reported-by:: Benny Halevy <bhalevy-C4P08NqkoRlBDgjK7y7TUQ@public.gmane.org>

ditto.

> Cc: Alexander Viro <viro-RmSDqhL/yNMiFSDQTTA3OLVCufUGDwFn@public.gmane.org>
> Cc: J. Bruce Fields <bfields-uC3wQj2KruNg9hUCZPvPmw@public.gmane.org>
> Cc: Trond Myklebust <Trond.Myklebust-HgOvQuBEEgTQT0dZR+AlfA@public.gmane.org>
> Cc: Benny Halevy <bhalevy-7I+n7zu2hftEKMMhf/gKZA@public.gmane.org>
> Cc: Andreas Gruenbacher <agruen-l3A5Bk7waGM@public.gmane.org>
> Signed-off-by: Andrew Morton <akpm-de/tnXTf+JLsfHDXvbKv3WD2FQJk+8+b@public.gmane.org>

FWIW, I tested my linux-pnfs 3.12-rc3 tree with this patch
and it builds and causes no regression with the connectathon test suite over pnfs.

Benny

> ---
> 
>  fs/posix_acl.c            |   84 +++++++++++++++++++++++++++++++++---
>  include/linux/posix_acl.h |   78 ++-------------------------------
>  2 files changed, 85 insertions(+), 77 deletions(-)
> 
> diff -puN fs/posix_acl.c~posix_acl-uninlining fs/posix_acl.c
> --- a/fs/posix_acl.c~posix_acl-uninlining
> +++ a/fs/posix_acl.c
> @@ -22,11 +22,80 @@
>  
>  #include <linux/errno.h>
>  
> -EXPORT_SYMBOL(posix_acl_init);
> -EXPORT_SYMBOL(posix_acl_alloc);
> -EXPORT_SYMBOL(posix_acl_valid);
> -EXPORT_SYMBOL(posix_acl_equiv_mode);
> -EXPORT_SYMBOL(posix_acl_from_mode);
> +struct posix_acl **acl_by_type(struct inode *inode, int type)
> +{
> +	switch (type) {
> +	case ACL_TYPE_ACCESS:
> +		return &inode->i_acl;
> +	case ACL_TYPE_DEFAULT:
> +		return &inode->i_default_acl;
> +	default:
> +		BUG();
> +	}
> +}
> +EXPORT_SYMBOL(acl_by_type);
> +
> +struct posix_acl *get_cached_acl(struct inode *inode, int type)
> +{
> +	struct posix_acl **p = acl_by_type(inode, type);
> +	struct posix_acl *acl = ACCESS_ONCE(*p);
> +	if (acl) {
> +		spin_lock(&inode->i_lock);
> +		acl = *p;
> +		if (acl != ACL_NOT_CACHED)
> +			acl = posix_acl_dup(acl);
> +		spin_unlock(&inode->i_lock);
> +	}
> +	return acl;
> +}
> +EXPORT_SYMBOL(get_cached_acl);
> +
> +struct posix_acl *get_cached_acl_rcu(struct inode *inode, int type)
> +{
> +	return rcu_dereference(*acl_by_type(inode, type));
> +}
> +EXPORT_SYMBOL(get_cached_acl_rcu);
> +
> +void set_cached_acl(struct inode *inode, int type, struct posix_acl *acl)
> +{
> +	struct posix_acl **p = acl_by_type(inode, type);
> +	struct posix_acl *old;
> +	spin_lock(&inode->i_lock);
> +	old = *p;
> +	rcu_assign_pointer(*p, posix_acl_dup(acl));
> +	spin_unlock(&inode->i_lock);
> +	if (old != ACL_NOT_CACHED)
> +		posix_acl_release(old);
> +}
> +EXPORT_SYMBOL(set_cached_acl);
> +
> +void forget_cached_acl(struct inode *inode, int type)
> +{
> +	struct posix_acl **p = acl_by_type(inode, type);
> +	struct posix_acl *old;
> +	spin_lock(&inode->i_lock);
> +	old = *p;
> +	*p = ACL_NOT_CACHED;
> +	spin_unlock(&inode->i_lock);
> +	if (old != ACL_NOT_CACHED)
> +		posix_acl_release(old);
> +}
> +EXPORT_SYMBOL(forget_cached_acl);
> +
> +void forget_all_cached_acls(struct inode *inode)
> +{
> +	struct posix_acl *old_access, *old_default;
> +	spin_lock(&inode->i_lock);
> +	old_access = inode->i_acl;
> +	old_default = inode->i_default_acl;
> +	inode->i_acl = inode->i_default_acl = ACL_NOT_CACHED;
> +	spin_unlock(&inode->i_lock);
> +	if (old_access != ACL_NOT_CACHED)
> +		posix_acl_release(old_access);
> +	if (old_default != ACL_NOT_CACHED)
> +		posix_acl_release(old_default);
> +}
> +EXPORT_SYMBOL(forget_all_cached_acls);
>  
>  /*
>   * Init a fresh posix_acl
> @@ -37,6 +106,7 @@ posix_acl_init(struct posix_acl *acl, in
>  	atomic_set(&acl->a_refcount, 1);
>  	acl->a_count = count;
>  }
> +EXPORT_SYMBOL(posix_acl_init);
>  
>  /*
>   * Allocate a new ACL with the specified number of entries.
> @@ -51,6 +121,7 @@ posix_acl_alloc(int count, gfp_t flags)
>  		posix_acl_init(acl, count);
>  	return acl;
>  }
> +EXPORT_SYMBOL(posix_acl_alloc);
>  
>  /*
>   * Clone an ACL.
> @@ -146,6 +217,7 @@ posix_acl_valid(const struct posix_acl *
>  		return 0;
>  	return -EINVAL;
>  }
> +EXPORT_SYMBOL(posix_acl_valid);
>  
>  /*
>   * Returns 0 if the acl can be exactly represented in the traditional
> @@ -186,6 +258,7 @@ posix_acl_equiv_mode(const struct posix_
>                  *mode_p = (*mode_p & ~S_IRWXUGO) | mode;
>          return not_equiv;
>  }
> +EXPORT_SYMBOL(posix_acl_equiv_mode);
>  
>  /*
>   * Create an ACL representing the file mode permission bits of an inode.
> @@ -207,6 +280,7 @@ posix_acl_from_mode(umode_t mode, gfp_t
>  	acl->a_entries[2].e_perm = (mode & S_IRWXO);
>  	return acl;
>  }
> +EXPORT_SYMBOL(posix_acl_from_mode);
>  
>  /*
>   * Return 0 if current is granted want access to the inode
> diff -puN include/linux/posix_acl.h~posix_acl-uninlining include/linux/posix_acl.h
> --- a/include/linux/posix_acl.h~posix_acl-uninlining
> +++ a/include/linux/posix_acl.h
> @@ -94,78 +94,12 @@ extern int posix_acl_chmod(struct posix_
>  extern struct posix_acl *get_posix_acl(struct inode *, int);
>  extern int set_posix_acl(struct inode *, int, struct posix_acl *);
>  
> -#ifdef CONFIG_FS_POSIX_ACL
> -static inline struct posix_acl **acl_by_type(struct inode *inode, int type)
> -{
> -	switch (type) {
> -	case ACL_TYPE_ACCESS:
> -		return &inode->i_acl;
> -	case ACL_TYPE_DEFAULT:
> -		return &inode->i_default_acl;
> -	default:
> -		BUG();
> -	}
> -}
> -
> -static inline struct posix_acl *get_cached_acl(struct inode *inode, int type)
> -{
> -	struct posix_acl **p = acl_by_type(inode, type);
> -	struct posix_acl *acl = ACCESS_ONCE(*p);
> -	if (acl) {
> -		spin_lock(&inode->i_lock);
> -		acl = *p;
> -		if (acl != ACL_NOT_CACHED)
> -			acl = posix_acl_dup(acl);
> -		spin_unlock(&inode->i_lock);
> -	}
> -	return acl;
> -}
> -
> -static inline struct posix_acl *get_cached_acl_rcu(struct inode *inode, int type)
> -{
> -	return rcu_dereference(*acl_by_type(inode, type));
> -}
> -
> -static inline void set_cached_acl(struct inode *inode,
> -				  int type,
> -				  struct posix_acl *acl)
> -{
> -	struct posix_acl **p = acl_by_type(inode, type);
> -	struct posix_acl *old;
> -	spin_lock(&inode->i_lock);
> -	old = *p;
> -	rcu_assign_pointer(*p, posix_acl_dup(acl));
> -	spin_unlock(&inode->i_lock);
> -	if (old != ACL_NOT_CACHED)
> -		posix_acl_release(old);
> -}
> -
> -static inline void forget_cached_acl(struct inode *inode, int type)
> -{
> -	struct posix_acl **p = acl_by_type(inode, type);
> -	struct posix_acl *old;
> -	spin_lock(&inode->i_lock);
> -	old = *p;
> -	*p = ACL_NOT_CACHED;
> -	spin_unlock(&inode->i_lock);
> -	if (old != ACL_NOT_CACHED)
> -		posix_acl_release(old);
> -}
> -
> -static inline void forget_all_cached_acls(struct inode *inode)
> -{
> -	struct posix_acl *old_access, *old_default;
> -	spin_lock(&inode->i_lock);
> -	old_access = inode->i_acl;
> -	old_default = inode->i_default_acl;
> -	inode->i_acl = inode->i_default_acl = ACL_NOT_CACHED;
> -	spin_unlock(&inode->i_lock);
> -	if (old_access != ACL_NOT_CACHED)
> -		posix_acl_release(old_access);
> -	if (old_default != ACL_NOT_CACHED)
> -		posix_acl_release(old_default);
> -}
> -#endif
> +struct posix_acl **acl_by_type(struct inode *inode, int type);
> +struct posix_acl *get_cached_acl(struct inode *inode, int type);
> +struct posix_acl *get_cached_acl_rcu(struct inode *inode, int type);
> +void set_cached_acl(struct inode *inode, int type, struct posix_acl *acl);
> +void forget_cached_acl(struct inode *inode, int type);
> +void forget_all_cached_acls(struct inode *inode);
>  
>  static inline void cache_no_acl(struct inode *inode)
>  {
> _
> 
--
To unsubscribe from this list: send the line "unsubscribe linux-nfs" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html