Patchwork [v4] fs/ext*,f2fs,jffs2,reiserfs: give comments for acl size and count calculation

login
register
mail settings
Submitter Chen Gang
Date Jan. 11, 2013, 8:58 a.m.
Message ID <50EFD427.8060100@asianux.com>
Download mbox | patch
Permalink /patch/211242/
State New
Headers show

Comments

Chen Gang - Jan. 11, 2013, 8:58 a.m.
give comments (by Theodore Ts'o)

    ACL_USER_OBJ ACL_USER*[1] ACL_GROUP_OBJ ACL_GROUP*[1] ACL_MASK[2] ACL_OTHER

    [1] Where * is the regexp sense of "0 or more times"
    [2] ...

  give comments (by Jan Kara)
    posix_acl_valid() makes sure that if there are <= 4 ACL entries, then
    all of them are short. Otherwise exactly 4 entries are short ones and
    other have full length. See comment before that function for exact ACL
    format.
    also correct the '[2]' comments:
      [2] If ACL_USER or ACL_GROUP is present, then ACL_MASK must be present.

  use macro instead of hard code number (by Chen Gang)

Signed-off-by: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Jan Kara <jack@suse.cz>
Signed-off-by: Chen Gang <gang.chen@asianux.com>
---
 fs/ext2/acl.h             |   10 +++++-----
 fs/ext3/acl.h             |   10 +++++-----
 fs/ext4/acl.h             |   10 +++++-----
 fs/f2fs/acl.c             |   12 +++++++-----
 fs/jffs2/acl.c            |   15 +++++++++------
 fs/posix_acl.c            |    7 +++++++
 fs/reiserfs/acl.h         |   10 +++++-----
 include/linux/posix_acl.h |    8 ++++++++
 8 files changed, 51 insertions(+), 31 deletions(-)
Chen Gang - Jan. 20, 2013, 7:02 a.m.
Hello all:

consult:
  excuse me, I wonder who is the final applier of this patch ?
    it seems too many relative members are in this mailing list.
      (it is why I also included torvalds@linux-foundation.org as 'THE REST')

  thanks.

  :-)


by the way:
  originally, I send this mail by checking MAINTAINERS file, mannualy.
  and this time (now), I reply this mail by using scripts/get_maintainers.pl.
    (but still add torvalds@linux-foundation.org as 'THE REST')


  Regards

gchen.

于 2013年01月11日 16:58, Chen Gang 写道:
> 
>   give comments (by Theodore Ts'o)
> 
>     ACL_USER_OBJ ACL_USER*[1] ACL_GROUP_OBJ ACL_GROUP*[1] ACL_MASK[2] ACL_OTHER
> 
>     [1] Where * is the regexp sense of "0 or more times"
>     [2] ...
> 
>   give comments (by Jan Kara)
>     posix_acl_valid() makes sure that if there are <= 4 ACL entries, then
>     all of them are short. Otherwise exactly 4 entries are short ones and
>     other have full length. See comment before that function for exact ACL
>     format.
>     also correct the '[2]' comments:
>       [2] If ACL_USER or ACL_GROUP is present, then ACL_MASK must be present.
> 
>   use macro instead of hard code number (by Chen Gang)
> 
> Signed-off-by: Theodore Ts'o <tytso@mit.edu>
> Signed-off-by: Jan Kara <jack@suse.cz>
> Signed-off-by: Chen Gang <gang.chen@asianux.com>
> ---
>  fs/ext2/acl.h             |   10 +++++-----
>  fs/ext3/acl.h             |   10 +++++-----
>  fs/ext4/acl.h             |   10 +++++-----
>  fs/f2fs/acl.c             |   12 +++++++-----
>  fs/jffs2/acl.c            |   15 +++++++++------
>  fs/posix_acl.c            |    7 +++++++
>  fs/reiserfs/acl.h         |   10 +++++-----
>  include/linux/posix_acl.h |    8 ++++++++
>  8 files changed, 51 insertions(+), 31 deletions(-)
> 
> diff --git a/fs/ext2/acl.h b/fs/ext2/acl.h
> index 503bfb0..9af79d0 100644
> --- a/fs/ext2/acl.h
> +++ b/fs/ext2/acl.h
> @@ -25,13 +25,13 @@ typedef struct {
>  
>  static inline size_t ext2_acl_size(int count)
>  {
> -	if (count <= 4) {
> +	if (count <= ACL_MAX_SHORT_ENTRY) {
>  		return sizeof(ext2_acl_header) +
>  		       count * sizeof(ext2_acl_entry_short);
>  	} else {
>  		return sizeof(ext2_acl_header) +
> -		       4 * sizeof(ext2_acl_entry_short) +
> -		       (count - 4) * sizeof(ext2_acl_entry);
> +		       ACL_MAX_SHORT_ENTRY * sizeof(ext2_acl_entry_short) +
> +		       (count - ACL_MAX_SHORT_ENTRY) * sizeof(ext2_acl_entry);
>  	}
>  }
>  
> @@ -39,7 +39,7 @@ static inline int ext2_acl_count(size_t size)
>  {
>  	ssize_t s;
>  	size -= sizeof(ext2_acl_header);
> -	s = size - 4 * sizeof(ext2_acl_entry_short);
> +	s = size - ACL_MAX_SHORT_ENTRY * sizeof(ext2_acl_entry_short);
>  	if (s < 0) {
>  		if (size % sizeof(ext2_acl_entry_short))
>  			return -1;
> @@ -47,7 +47,7 @@ static inline int ext2_acl_count(size_t size)
>  	} else {
>  		if (s % sizeof(ext2_acl_entry))
>  			return -1;
> -		return s / sizeof(ext2_acl_entry) + 4;
> +		return s / sizeof(ext2_acl_entry) + ACL_MAX_SHORT_ENTRY;
>  	}
>  }
>  
> diff --git a/fs/ext3/acl.h b/fs/ext3/acl.h
> index dbc921e..b1cf2c0 100644
> --- a/fs/ext3/acl.h
> +++ b/fs/ext3/acl.h
> @@ -25,13 +25,13 @@ typedef struct {
>  
>  static inline size_t ext3_acl_size(int count)
>  {
> -	if (count <= 4) {
> +	if (count <= ACL_MAX_SHORT_ENTRY) {
>  		return sizeof(ext3_acl_header) +
>  		       count * sizeof(ext3_acl_entry_short);
>  	} else {
>  		return sizeof(ext3_acl_header) +
> -		       4 * sizeof(ext3_acl_entry_short) +
> -		       (count - 4) * sizeof(ext3_acl_entry);
> +		       ACL_MAX_SHORT_ENTRY * sizeof(ext3_acl_entry_short) +
> +		       (count - ACL_MAX_SHORT_ENTRY) * sizeof(ext3_acl_entry);
>  	}
>  }
>  
> @@ -39,7 +39,7 @@ static inline int ext3_acl_count(size_t size)
>  {
>  	ssize_t s;
>  	size -= sizeof(ext3_acl_header);
> -	s = size - 4 * sizeof(ext3_acl_entry_short);
> +	s = size - ACL_MAX_SHORT_ENTRY * sizeof(ext3_acl_entry_short);
>  	if (s < 0) {
>  		if (size % sizeof(ext3_acl_entry_short))
>  			return -1;
> @@ -47,7 +47,7 @@ static inline int ext3_acl_count(size_t size)
>  	} else {
>  		if (s % sizeof(ext3_acl_entry))
>  			return -1;
> -		return s / sizeof(ext3_acl_entry) + 4;
> +		return s / sizeof(ext3_acl_entry) + ACL_MAX_SHORT_ENTRY;
>  	}
>  }
>  
> diff --git a/fs/ext4/acl.h b/fs/ext4/acl.h
> index 18cb39e..66d1fa3 100644
> --- a/fs/ext4/acl.h
> +++ b/fs/ext4/acl.h
> @@ -25,13 +25,13 @@ typedef struct {
>  
>  static inline size_t ext4_acl_size(int count)
>  {
> -	if (count <= 4) {
> +	if (count <= ACL_MAX_SHORT_ENTRY) {
>  		return sizeof(ext4_acl_header) +
>  		       count * sizeof(ext4_acl_entry_short);
>  	} else {
>  		return sizeof(ext4_acl_header) +
> -		       4 * sizeof(ext4_acl_entry_short) +
> -		       (count - 4) * sizeof(ext4_acl_entry);
> +		       ACL_MAX_SHORT_ENTRY * sizeof(ext4_acl_entry_short) +
> +		       (count - ACL_MAX_SHORT_ENTRY) * sizeof(ext4_acl_entry);
>  	}
>  }
>  
> @@ -39,7 +39,7 @@ static inline int ext4_acl_count(size_t size)
>  {
>  	ssize_t s;
>  	size -= sizeof(ext4_acl_header);
> -	s = size - 4 * sizeof(ext4_acl_entry_short);
> +	s = size - ACL_MAX_SHORT_ENTRY * sizeof(ext4_acl_entry_short);
>  	if (s < 0) {
>  		if (size % sizeof(ext4_acl_entry_short))
>  			return -1;
> @@ -47,7 +47,7 @@ static inline int ext4_acl_count(size_t size)
>  	} else {
>  		if (s % sizeof(ext4_acl_entry))
>  			return -1;
> -		return s / sizeof(ext4_acl_entry) + 4;
> +		return s / sizeof(ext4_acl_entry) + ACL_MAX_SHORT_ENTRY;
>  	}
>  }
>  
> diff --git a/fs/f2fs/acl.c b/fs/f2fs/acl.c
> index 137af42..3e5a717 100644
> --- a/fs/f2fs/acl.c
> +++ b/fs/f2fs/acl.c
> @@ -22,13 +22,15 @@
>  
>  static inline size_t f2fs_acl_size(int count)
>  {
> -	if (count <= 4) {
> +	if (count <= ACL_MAX_SHORT_ENTRY) {
>  		return sizeof(struct f2fs_acl_header) +
>  			count * sizeof(struct f2fs_acl_entry_short);
>  	} else {
>  		return sizeof(struct f2fs_acl_header) +
> -			4 * sizeof(struct f2fs_acl_entry_short) +
> -			(count - 4) * sizeof(struct f2fs_acl_entry);
> +			ACL_MAX_SHORT_ENTRY
> +			 * sizeof(struct f2fs_acl_entry_short) +
> +			(count - ACL_MAX_SHORT_ENTRY)
> +			 * sizeof(struct f2fs_acl_entry);
>  	}
>  }
>  
> @@ -36,7 +38,7 @@ static inline int f2fs_acl_count(size_t size)
>  {
>  	ssize_t s;
>  	size -= sizeof(struct f2fs_acl_header);
> -	s = size - 4 * sizeof(struct f2fs_acl_entry_short);
> +	s = size - ACL_MAX_SHORT_ENTRY * sizeof(struct f2fs_acl_entry_short);
>  	if (s < 0) {
>  		if (size % sizeof(struct f2fs_acl_entry_short))
>  			return -1;
> @@ -44,7 +46,7 @@ static inline int f2fs_acl_count(size_t size)
>  	} else {
>  		if (s % sizeof(struct f2fs_acl_entry))
>  			return -1;
> -		return s / sizeof(struct f2fs_acl_entry) + 4;
> +		return s / sizeof(struct f2fs_acl_entry) + ACL_MAX_SHORT_ENTRY;
>  	}
>  }
>  
> diff --git a/fs/jffs2/acl.c b/fs/jffs2/acl.c
> index 223283c..48ef4b8 100644
> --- a/fs/jffs2/acl.c
> +++ b/fs/jffs2/acl.c
> @@ -25,13 +25,15 @@
>  
>  static size_t jffs2_acl_size(int count)
>  {
> -	if (count <= 4) {
> +	if (count <= ACL_MAX_SHORT_ENTRY) {
>  		return sizeof(struct jffs2_acl_header)
>  		       + count * sizeof(struct jffs2_acl_entry_short);
>  	} else {
>  		return sizeof(struct jffs2_acl_header)
> -		       + 4 * sizeof(struct jffs2_acl_entry_short)
> -		       + (count - 4) * sizeof(struct jffs2_acl_entry);
> +		       + ACL_MAX_SHORT_ENTRY
> +				 * sizeof(struct jffs2_acl_entry_short)
> +		       + (count - ACL_MAX_SHORT_ENTRY)
> +				 * sizeof(struct jffs2_acl_entry);
>  	}
>  }
>  
> @@ -40,15 +42,16 @@ static int jffs2_acl_count(size_t size)
>  	size_t s;
>  
>  	size -= sizeof(struct jffs2_acl_header);
> -	if (size < 4 * sizeof(struct jffs2_acl_entry_short)) {
> +	if (size < ACL_MAX_SHORT_ENTRY * sizeof(struct jffs2_acl_entry_short)) {
>  		if (size % sizeof(struct jffs2_acl_entry_short))
>  			return -1;
>  		return size / sizeof(struct jffs2_acl_entry_short);
>  	} else {
> -		s = size - 4 * sizeof(struct jffs2_acl_entry_short);
> +		s = size - ACL_MAX_SHORT_ENTRY
> +				 * sizeof(struct jffs2_acl_entry_short);
>  		if (s % sizeof(struct jffs2_acl_entry))
>  			return -1;
> -		return s / sizeof(struct jffs2_acl_entry) + 4;
> +		return s / sizeof(struct jffs2_acl_entry) + ACL_MAX_SHORT_ENTRY;
>  	}
>  }
>  
> diff --git a/fs/posix_acl.c b/fs/posix_acl.c
> index 8bd2135..15b1b0c 100644
> --- a/fs/posix_acl.c
> +++ b/fs/posix_acl.c
> @@ -72,6 +72,13 @@ posix_acl_clone(const struct posix_acl *acl, gfp_t flags)
>  
>  /*
>   * Check if an acl is valid. Returns 0 if it is, or -E... otherwise.
> + *
> + * make sure ACL format is the following:
> + *
> + *   ACL_USER_OBJ ACL_USER*[1] ACL_GROUP_OBJ ACL_GROUP*[1] ACL_MASK[2] ACL_OTHER
> + *
> + *   [1] Where * is the regexp sense of "0 or more times"
> + *   [2] If ACL_USER or ACL_GROUP is present, then ACL_MASK must be present.
>   */
>  int
>  posix_acl_valid(const struct posix_acl *acl)
> diff --git a/fs/reiserfs/acl.h b/fs/reiserfs/acl.h
> index f096b80..cb967a3 100644
> --- a/fs/reiserfs/acl.h
> +++ b/fs/reiserfs/acl.h
> @@ -20,13 +20,13 @@ typedef struct {
>  
>  static inline size_t reiserfs_acl_size(int count)
>  {
> -	if (count <= 4) {
> +	if (count <= ACL_MAX_SHORT_ENTRY) {
>  		return sizeof(reiserfs_acl_header) +
>  		    count * sizeof(reiserfs_acl_entry_short);
>  	} else {
>  		return sizeof(reiserfs_acl_header) +
> -		    4 * sizeof(reiserfs_acl_entry_short) +
> -		    (count - 4) * sizeof(reiserfs_acl_entry);
> +		    ACL_MAX_SHORT_ENTRY * sizeof(reiserfs_acl_entry_short) +
> +		    (count - ACL_MAX_SHORT_ENTRY) * sizeof(reiserfs_acl_entry);
>  	}
>  }
>  
> @@ -34,7 +34,7 @@ static inline int reiserfs_acl_count(size_t size)
>  {
>  	ssize_t s;
>  	size -= sizeof(reiserfs_acl_header);
> -	s = size - 4 * sizeof(reiserfs_acl_entry_short);
> +	s = size - ACL_MAX_SHORT_ENTRY * sizeof(reiserfs_acl_entry_short);
>  	if (s < 0) {
>  		if (size % sizeof(reiserfs_acl_entry_short))
>  			return -1;
> @@ -42,7 +42,7 @@ static inline int reiserfs_acl_count(size_t size)
>  	} else {
>  		if (s % sizeof(reiserfs_acl_entry))
>  			return -1;
> -		return s / sizeof(reiserfs_acl_entry) + 4;
> +		return s / sizeof(reiserfs_acl_entry) + ACL_MAX_SHORT_ENTRY;
>  	}
>  }
>  
> diff --git a/include/linux/posix_acl.h b/include/linux/posix_acl.h
> index 7931efe..2c5609c 100644
> --- a/include/linux/posix_acl.h
> +++ b/include/linux/posix_acl.h
> @@ -26,6 +26,14 @@
>  #define ACL_MASK		(0x10)
>  #define ACL_OTHER		(0x20)
>  
> +/*
> + * posix_acl_valid() makes sure that if there are <= 4 ACL entries, then
> + * all of them are short. Otherwise exactly 4 entries are short ones and
> + * other have full length. See comment before that function for exact ACL
> + * format.
> + */
> +#define ACL_MAX_SHORT_ENTRY	4
> +
>  /* permissions in the e_perm field */
>  #define ACL_READ		(0x04)
>  #define ACL_WRITE		(0x02)
>
Jan Kara - Jan. 21, 2013, 10:24 a.m.
On Sun 20-01-13 15:02:46, Chen Gang wrote:
> Hello all:
> 
> consult:
>   excuse me, I wonder who is the final applier of this patch ?
>     it seems too many relative members are in this mailing list.
>       (it is why I also included torvalds@linux-foundation.org as 'THE REST')
> 
>   thanks.
> 
>   :-)
> 
> 
> by the way:
>   originally, I send this mail by checking MAINTAINERS file, mannualy.
>   and this time (now), I reply this mail by using scripts/get_maintainers.pl.
>     (but still add torvalds@linux-foundation.org as 'THE REST')
  Al Viro (you have him on CC list) is the right guy to merge this patch.
But he's not very responsive at times... You can also check whether he just
didn't silently merge your patch into his tree -
http://git.kernel.org/?p=linux/kernel/git/viro/vfs.git
I don't see the patch there right now, last update to the tree has
happened 3 weeks ago. Maybe he's on vacation...

								Honza
> 于 2013年01月11日 16:58, Chen Gang 写道:
> > 
> >   give comments (by Theodore Ts'o)
> > 
> >     ACL_USER_OBJ ACL_USER*[1] ACL_GROUP_OBJ ACL_GROUP*[1] ACL_MASK[2] ACL_OTHER
> > 
> >     [1] Where * is the regexp sense of "0 or more times"
> >     [2] ...
> > 
> >   give comments (by Jan Kara)
> >     posix_acl_valid() makes sure that if there are <= 4 ACL entries, then
> >     all of them are short. Otherwise exactly 4 entries are short ones and
> >     other have full length. See comment before that function for exact ACL
> >     format.
> >     also correct the '[2]' comments:
> >       [2] If ACL_USER or ACL_GROUP is present, then ACL_MASK must be present.
> > 
> >   use macro instead of hard code number (by Chen Gang)
> > 
> > Signed-off-by: Theodore Ts'o <tytso@mit.edu>
> > Signed-off-by: Jan Kara <jack@suse.cz>
> > Signed-off-by: Chen Gang <gang.chen@asianux.com>
> > ---
> >  fs/ext2/acl.h             |   10 +++++-----
> >  fs/ext3/acl.h             |   10 +++++-----
> >  fs/ext4/acl.h             |   10 +++++-----
> >  fs/f2fs/acl.c             |   12 +++++++-----
> >  fs/jffs2/acl.c            |   15 +++++++++------
> >  fs/posix_acl.c            |    7 +++++++
> >  fs/reiserfs/acl.h         |   10 +++++-----
> >  include/linux/posix_acl.h |    8 ++++++++
> >  8 files changed, 51 insertions(+), 31 deletions(-)
> > 
> > diff --git a/fs/ext2/acl.h b/fs/ext2/acl.h
> > index 503bfb0..9af79d0 100644
> > --- a/fs/ext2/acl.h
> > +++ b/fs/ext2/acl.h
> > @@ -25,13 +25,13 @@ typedef struct {
> >  
> >  static inline size_t ext2_acl_size(int count)
> >  {
> > -	if (count <= 4) {
> > +	if (count <= ACL_MAX_SHORT_ENTRY) {
> >  		return sizeof(ext2_acl_header) +
> >  		       count * sizeof(ext2_acl_entry_short);
> >  	} else {
> >  		return sizeof(ext2_acl_header) +
> > -		       4 * sizeof(ext2_acl_entry_short) +
> > -		       (count - 4) * sizeof(ext2_acl_entry);
> > +		       ACL_MAX_SHORT_ENTRY * sizeof(ext2_acl_entry_short) +
> > +		       (count - ACL_MAX_SHORT_ENTRY) * sizeof(ext2_acl_entry);
> >  	}
> >  }
> >  
> > @@ -39,7 +39,7 @@ static inline int ext2_acl_count(size_t size)
> >  {
> >  	ssize_t s;
> >  	size -= sizeof(ext2_acl_header);
> > -	s = size - 4 * sizeof(ext2_acl_entry_short);
> > +	s = size - ACL_MAX_SHORT_ENTRY * sizeof(ext2_acl_entry_short);
> >  	if (s < 0) {
> >  		if (size % sizeof(ext2_acl_entry_short))
> >  			return -1;
> > @@ -47,7 +47,7 @@ static inline int ext2_acl_count(size_t size)
> >  	} else {
> >  		if (s % sizeof(ext2_acl_entry))
> >  			return -1;
> > -		return s / sizeof(ext2_acl_entry) + 4;
> > +		return s / sizeof(ext2_acl_entry) + ACL_MAX_SHORT_ENTRY;
> >  	}
> >  }
> >  
> > diff --git a/fs/ext3/acl.h b/fs/ext3/acl.h
> > index dbc921e..b1cf2c0 100644
> > --- a/fs/ext3/acl.h
> > +++ b/fs/ext3/acl.h
> > @@ -25,13 +25,13 @@ typedef struct {
> >  
> >  static inline size_t ext3_acl_size(int count)
> >  {
> > -	if (count <= 4) {
> > +	if (count <= ACL_MAX_SHORT_ENTRY) {
> >  		return sizeof(ext3_acl_header) +
> >  		       count * sizeof(ext3_acl_entry_short);
> >  	} else {
> >  		return sizeof(ext3_acl_header) +
> > -		       4 * sizeof(ext3_acl_entry_short) +
> > -		       (count - 4) * sizeof(ext3_acl_entry);
> > +		       ACL_MAX_SHORT_ENTRY * sizeof(ext3_acl_entry_short) +
> > +		       (count - ACL_MAX_SHORT_ENTRY) * sizeof(ext3_acl_entry);
> >  	}
> >  }
> >  
> > @@ -39,7 +39,7 @@ static inline int ext3_acl_count(size_t size)
> >  {
> >  	ssize_t s;
> >  	size -= sizeof(ext3_acl_header);
> > -	s = size - 4 * sizeof(ext3_acl_entry_short);
> > +	s = size - ACL_MAX_SHORT_ENTRY * sizeof(ext3_acl_entry_short);
> >  	if (s < 0) {
> >  		if (size % sizeof(ext3_acl_entry_short))
> >  			return -1;
> > @@ -47,7 +47,7 @@ static inline int ext3_acl_count(size_t size)
> >  	} else {
> >  		if (s % sizeof(ext3_acl_entry))
> >  			return -1;
> > -		return s / sizeof(ext3_acl_entry) + 4;
> > +		return s / sizeof(ext3_acl_entry) + ACL_MAX_SHORT_ENTRY;
> >  	}
> >  }
> >  
> > diff --git a/fs/ext4/acl.h b/fs/ext4/acl.h
> > index 18cb39e..66d1fa3 100644
> > --- a/fs/ext4/acl.h
> > +++ b/fs/ext4/acl.h
> > @@ -25,13 +25,13 @@ typedef struct {
> >  
> >  static inline size_t ext4_acl_size(int count)
> >  {
> > -	if (count <= 4) {
> > +	if (count <= ACL_MAX_SHORT_ENTRY) {
> >  		return sizeof(ext4_acl_header) +
> >  		       count * sizeof(ext4_acl_entry_short);
> >  	} else {
> >  		return sizeof(ext4_acl_header) +
> > -		       4 * sizeof(ext4_acl_entry_short) +
> > -		       (count - 4) * sizeof(ext4_acl_entry);
> > +		       ACL_MAX_SHORT_ENTRY * sizeof(ext4_acl_entry_short) +
> > +		       (count - ACL_MAX_SHORT_ENTRY) * sizeof(ext4_acl_entry);
> >  	}
> >  }
> >  
> > @@ -39,7 +39,7 @@ static inline int ext4_acl_count(size_t size)
> >  {
> >  	ssize_t s;
> >  	size -= sizeof(ext4_acl_header);
> > -	s = size - 4 * sizeof(ext4_acl_entry_short);
> > +	s = size - ACL_MAX_SHORT_ENTRY * sizeof(ext4_acl_entry_short);
> >  	if (s < 0) {
> >  		if (size % sizeof(ext4_acl_entry_short))
> >  			return -1;
> > @@ -47,7 +47,7 @@ static inline int ext4_acl_count(size_t size)
> >  	} else {
> >  		if (s % sizeof(ext4_acl_entry))
> >  			return -1;
> > -		return s / sizeof(ext4_acl_entry) + 4;
> > +		return s / sizeof(ext4_acl_entry) + ACL_MAX_SHORT_ENTRY;
> >  	}
> >  }
> >  
> > diff --git a/fs/f2fs/acl.c b/fs/f2fs/acl.c
> > index 137af42..3e5a717 100644
> > --- a/fs/f2fs/acl.c
> > +++ b/fs/f2fs/acl.c
> > @@ -22,13 +22,15 @@
> >  
> >  static inline size_t f2fs_acl_size(int count)
> >  {
> > -	if (count <= 4) {
> > +	if (count <= ACL_MAX_SHORT_ENTRY) {
> >  		return sizeof(struct f2fs_acl_header) +
> >  			count * sizeof(struct f2fs_acl_entry_short);
> >  	} else {
> >  		return sizeof(struct f2fs_acl_header) +
> > -			4 * sizeof(struct f2fs_acl_entry_short) +
> > -			(count - 4) * sizeof(struct f2fs_acl_entry);
> > +			ACL_MAX_SHORT_ENTRY
> > +			 * sizeof(struct f2fs_acl_entry_short) +
> > +			(count - ACL_MAX_SHORT_ENTRY)
> > +			 * sizeof(struct f2fs_acl_entry);
> >  	}
> >  }
> >  
> > @@ -36,7 +38,7 @@ static inline int f2fs_acl_count(size_t size)
> >  {
> >  	ssize_t s;
> >  	size -= sizeof(struct f2fs_acl_header);
> > -	s = size - 4 * sizeof(struct f2fs_acl_entry_short);
> > +	s = size - ACL_MAX_SHORT_ENTRY * sizeof(struct f2fs_acl_entry_short);
> >  	if (s < 0) {
> >  		if (size % sizeof(struct f2fs_acl_entry_short))
> >  			return -1;
> > @@ -44,7 +46,7 @@ static inline int f2fs_acl_count(size_t size)
> >  	} else {
> >  		if (s % sizeof(struct f2fs_acl_entry))
> >  			return -1;
> > -		return s / sizeof(struct f2fs_acl_entry) + 4;
> > +		return s / sizeof(struct f2fs_acl_entry) + ACL_MAX_SHORT_ENTRY;
> >  	}
> >  }
> >  
> > diff --git a/fs/jffs2/acl.c b/fs/jffs2/acl.c
> > index 223283c..48ef4b8 100644
> > --- a/fs/jffs2/acl.c
> > +++ b/fs/jffs2/acl.c
> > @@ -25,13 +25,15 @@
> >  
> >  static size_t jffs2_acl_size(int count)
> >  {
> > -	if (count <= 4) {
> > +	if (count <= ACL_MAX_SHORT_ENTRY) {
> >  		return sizeof(struct jffs2_acl_header)
> >  		       + count * sizeof(struct jffs2_acl_entry_short);
> >  	} else {
> >  		return sizeof(struct jffs2_acl_header)
> > -		       + 4 * sizeof(struct jffs2_acl_entry_short)
> > -		       + (count - 4) * sizeof(struct jffs2_acl_entry);
> > +		       + ACL_MAX_SHORT_ENTRY
> > +				 * sizeof(struct jffs2_acl_entry_short)
> > +		       + (count - ACL_MAX_SHORT_ENTRY)
> > +				 * sizeof(struct jffs2_acl_entry);
> >  	}
> >  }
> >  
> > @@ -40,15 +42,16 @@ static int jffs2_acl_count(size_t size)
> >  	size_t s;
> >  
> >  	size -= sizeof(struct jffs2_acl_header);
> > -	if (size < 4 * sizeof(struct jffs2_acl_entry_short)) {
> > +	if (size < ACL_MAX_SHORT_ENTRY * sizeof(struct jffs2_acl_entry_short)) {
> >  		if (size % sizeof(struct jffs2_acl_entry_short))
> >  			return -1;
> >  		return size / sizeof(struct jffs2_acl_entry_short);
> >  	} else {
> > -		s = size - 4 * sizeof(struct jffs2_acl_entry_short);
> > +		s = size - ACL_MAX_SHORT_ENTRY
> > +				 * sizeof(struct jffs2_acl_entry_short);
> >  		if (s % sizeof(struct jffs2_acl_entry))
> >  			return -1;
> > -		return s / sizeof(struct jffs2_acl_entry) + 4;
> > +		return s / sizeof(struct jffs2_acl_entry) + ACL_MAX_SHORT_ENTRY;
> >  	}
> >  }
> >  
> > diff --git a/fs/posix_acl.c b/fs/posix_acl.c
> > index 8bd2135..15b1b0c 100644
> > --- a/fs/posix_acl.c
> > +++ b/fs/posix_acl.c
> > @@ -72,6 +72,13 @@ posix_acl_clone(const struct posix_acl *acl, gfp_t flags)
> >  
> >  /*
> >   * Check if an acl is valid. Returns 0 if it is, or -E... otherwise.
> > + *
> > + * make sure ACL format is the following:
> > + *
> > + *   ACL_USER_OBJ ACL_USER*[1] ACL_GROUP_OBJ ACL_GROUP*[1] ACL_MASK[2] ACL_OTHER
> > + *
> > + *   [1] Where * is the regexp sense of "0 or more times"
> > + *   [2] If ACL_USER or ACL_GROUP is present, then ACL_MASK must be present.
> >   */
> >  int
> >  posix_acl_valid(const struct posix_acl *acl)
> > diff --git a/fs/reiserfs/acl.h b/fs/reiserfs/acl.h
> > index f096b80..cb967a3 100644
> > --- a/fs/reiserfs/acl.h
> > +++ b/fs/reiserfs/acl.h
> > @@ -20,13 +20,13 @@ typedef struct {
> >  
> >  static inline size_t reiserfs_acl_size(int count)
> >  {
> > -	if (count <= 4) {
> > +	if (count <= ACL_MAX_SHORT_ENTRY) {
> >  		return sizeof(reiserfs_acl_header) +
> >  		    count * sizeof(reiserfs_acl_entry_short);
> >  	} else {
> >  		return sizeof(reiserfs_acl_header) +
> > -		    4 * sizeof(reiserfs_acl_entry_short) +
> > -		    (count - 4) * sizeof(reiserfs_acl_entry);
> > +		    ACL_MAX_SHORT_ENTRY * sizeof(reiserfs_acl_entry_short) +
> > +		    (count - ACL_MAX_SHORT_ENTRY) * sizeof(reiserfs_acl_entry);
> >  	}
> >  }
> >  
> > @@ -34,7 +34,7 @@ static inline int reiserfs_acl_count(size_t size)
> >  {
> >  	ssize_t s;
> >  	size -= sizeof(reiserfs_acl_header);
> > -	s = size - 4 * sizeof(reiserfs_acl_entry_short);
> > +	s = size - ACL_MAX_SHORT_ENTRY * sizeof(reiserfs_acl_entry_short);
> >  	if (s < 0) {
> >  		if (size % sizeof(reiserfs_acl_entry_short))
> >  			return -1;
> > @@ -42,7 +42,7 @@ static inline int reiserfs_acl_count(size_t size)
> >  	} else {
> >  		if (s % sizeof(reiserfs_acl_entry))
> >  			return -1;
> > -		return s / sizeof(reiserfs_acl_entry) + 4;
> > +		return s / sizeof(reiserfs_acl_entry) + ACL_MAX_SHORT_ENTRY;
> >  	}
> >  }
> >  
> > diff --git a/include/linux/posix_acl.h b/include/linux/posix_acl.h
> > index 7931efe..2c5609c 100644
> > --- a/include/linux/posix_acl.h
> > +++ b/include/linux/posix_acl.h
> > @@ -26,6 +26,14 @@
> >  #define ACL_MASK		(0x10)
> >  #define ACL_OTHER		(0x20)
> >  
> > +/*
> > + * posix_acl_valid() makes sure that if there are <= 4 ACL entries, then
> > + * all of them are short. Otherwise exactly 4 entries are short ones and
> > + * other have full length. See comment before that function for exact ACL
> > + * format.
> > + */
> > +#define ACL_MAX_SHORT_ENTRY	4
> > +
> >  /* permissions in the e_perm field */
> >  #define ACL_READ		(0x04)
> >  #define ACL_WRITE		(0x02)
> > 
> 
> 
> -- 
> Chen Gang
> 
> Asianux Corporation
Chen Gang - Jan. 21, 2013, 10:40 a.m.
于 2013年01月21日 18:24, Jan Kara 写道:
>   Al Viro (you have him on CC list) is the right guy to merge this patch.
> But he's not very responsive at times... You can also check whether he just
> didn't silently merge your patch into his tree -
> http://git.kernel.org/?p=linux/kernel/git/viro/vfs.git
> I don't see the patch there right now, last update to the tree has
> happened 3 weeks ago. Maybe he's on vacation...

  thank you very much for your patient details replying.

  sorry, it is my fault for my original mail address not including Viro 
    so it is necessary to wait additional week for getting his response.

  next time, I need only use ./script/get_maintainers.pl to get mail address.

  :-(
Chen Gang - Jan. 29, 2013, 8:24 a.m.
Hello Al Viro:

  could you give a glance for this comment patch when you have time ?

    (at least for me, most of comment patches are valuable for integrating)


  thanks.

gchen.


于 2013年01月21日 18:40, Chen Gang 写道:
> 于 2013年01月21日 18:24, Jan Kara 写道:
>>   Al Viro (you have him on CC list) is the right guy to merge this patch.
>> But he's not very responsive at times... You can also check whether he just
>> didn't silently merge your patch into his tree -
>> http://git.kernel.org/?p=linux/kernel/git/viro/vfs.git
>> I don't see the patch there right now, last update to the tree has
>> happened 3 weeks ago. Maybe he's on vacation...
> 
>   thank you very much for your patient details replying.
> 
>   sorry, it is my fault for my original mail address not including Viro 
>     so it is necessary to wait additional week for getting his response.
> 
>   next time, I need only use ./script/get_maintainers.pl to get mail address.
> 
>   :-(
> 
>
Chen Gang - Feb. 2, 2013, 5:10 a.m.
Hello Al Viro:


  could you give a glance for this comment patch when you have time ?
    I am so sorry for not including your mail address for this patch, originally
      (it is really my fault, although the comment patch itself is innocence)

    I should notice next time.
      (and now, I always use ./script/get_maintainers.pl to get mail address)


  maybe, the comment patch seems quite minor.
    but at least for me, I think most of comment patches are not minor.
      (in correct place, providing correct comments are not minor)

    I also plan to provide more comment patches, in 2nd half of this year.
      (if it seems not a good idea, please tell me, thanks)

    if you have another opinions, welcome to discussion.


  whether this patch will be applied or not, I still thank to relative members:
    Theodore Ts'o: always give helpful responses at key point time.
                     (not only for this patch).

    Jan Kara:      provide more useful informations in action.
                     (not only for this patch).


  thanks.

gchen.

于 2013年01月29日 16:24, Chen Gang 写道:
> Hello Al Viro:
> 
>   could you give a glance for this comment patch when you have time ?
> 
>     (at least for me, most of comment patches are valuable for integrating)
> 
> 
>   thanks.
> 
> gchen.

Patch

diff --git a/fs/ext2/acl.h b/fs/ext2/acl.h
index 503bfb0..9af79d0 100644
--- a/fs/ext2/acl.h
+++ b/fs/ext2/acl.h
@@ -25,13 +25,13 @@  typedef struct {
 
 static inline size_t ext2_acl_size(int count)
 {
-	if (count <= 4) {
+	if (count <= ACL_MAX_SHORT_ENTRY) {
 		return sizeof(ext2_acl_header) +
 		       count * sizeof(ext2_acl_entry_short);
 	} else {
 		return sizeof(ext2_acl_header) +
-		       4 * sizeof(ext2_acl_entry_short) +
-		       (count - 4) * sizeof(ext2_acl_entry);
+		       ACL_MAX_SHORT_ENTRY * sizeof(ext2_acl_entry_short) +
+		       (count - ACL_MAX_SHORT_ENTRY) * sizeof(ext2_acl_entry);
 	}
 }
 
@@ -39,7 +39,7 @@  static inline int ext2_acl_count(size_t size)
 {
 	ssize_t s;
 	size -= sizeof(ext2_acl_header);
-	s = size - 4 * sizeof(ext2_acl_entry_short);
+	s = size - ACL_MAX_SHORT_ENTRY * sizeof(ext2_acl_entry_short);
 	if (s < 0) {
 		if (size % sizeof(ext2_acl_entry_short))
 			return -1;
@@ -47,7 +47,7 @@  static inline int ext2_acl_count(size_t size)
 	} else {
 		if (s % sizeof(ext2_acl_entry))
 			return -1;
-		return s / sizeof(ext2_acl_entry) + 4;
+		return s / sizeof(ext2_acl_entry) + ACL_MAX_SHORT_ENTRY;
 	}
 }
 
diff --git a/fs/ext3/acl.h b/fs/ext3/acl.h
index dbc921e..b1cf2c0 100644
--- a/fs/ext3/acl.h
+++ b/fs/ext3/acl.h
@@ -25,13 +25,13 @@  typedef struct {
 
 static inline size_t ext3_acl_size(int count)
 {
-	if (count <= 4) {
+	if (count <= ACL_MAX_SHORT_ENTRY) {
 		return sizeof(ext3_acl_header) +
 		       count * sizeof(ext3_acl_entry_short);
 	} else {
 		return sizeof(ext3_acl_header) +
-		       4 * sizeof(ext3_acl_entry_short) +
-		       (count - 4) * sizeof(ext3_acl_entry);
+		       ACL_MAX_SHORT_ENTRY * sizeof(ext3_acl_entry_short) +
+		       (count - ACL_MAX_SHORT_ENTRY) * sizeof(ext3_acl_entry);
 	}
 }
 
@@ -39,7 +39,7 @@  static inline int ext3_acl_count(size_t size)
 {
 	ssize_t s;
 	size -= sizeof(ext3_acl_header);
-	s = size - 4 * sizeof(ext3_acl_entry_short);
+	s = size - ACL_MAX_SHORT_ENTRY * sizeof(ext3_acl_entry_short);
 	if (s < 0) {
 		if (size % sizeof(ext3_acl_entry_short))
 			return -1;
@@ -47,7 +47,7 @@  static inline int ext3_acl_count(size_t size)
 	} else {
 		if (s % sizeof(ext3_acl_entry))
 			return -1;
-		return s / sizeof(ext3_acl_entry) + 4;
+		return s / sizeof(ext3_acl_entry) + ACL_MAX_SHORT_ENTRY;
 	}
 }
 
diff --git a/fs/ext4/acl.h b/fs/ext4/acl.h
index 18cb39e..66d1fa3 100644
--- a/fs/ext4/acl.h
+++ b/fs/ext4/acl.h
@@ -25,13 +25,13 @@  typedef struct {
 
 static inline size_t ext4_acl_size(int count)
 {
-	if (count <= 4) {
+	if (count <= ACL_MAX_SHORT_ENTRY) {
 		return sizeof(ext4_acl_header) +
 		       count * sizeof(ext4_acl_entry_short);
 	} else {
 		return sizeof(ext4_acl_header) +
-		       4 * sizeof(ext4_acl_entry_short) +
-		       (count - 4) * sizeof(ext4_acl_entry);
+		       ACL_MAX_SHORT_ENTRY * sizeof(ext4_acl_entry_short) +
+		       (count - ACL_MAX_SHORT_ENTRY) * sizeof(ext4_acl_entry);
 	}
 }
 
@@ -39,7 +39,7 @@  static inline int ext4_acl_count(size_t size)
 {
 	ssize_t s;
 	size -= sizeof(ext4_acl_header);
-	s = size - 4 * sizeof(ext4_acl_entry_short);
+	s = size - ACL_MAX_SHORT_ENTRY * sizeof(ext4_acl_entry_short);
 	if (s < 0) {
 		if (size % sizeof(ext4_acl_entry_short))
 			return -1;
@@ -47,7 +47,7 @@  static inline int ext4_acl_count(size_t size)
 	} else {
 		if (s % sizeof(ext4_acl_entry))
 			return -1;
-		return s / sizeof(ext4_acl_entry) + 4;
+		return s / sizeof(ext4_acl_entry) + ACL_MAX_SHORT_ENTRY;
 	}
 }
 
diff --git a/fs/f2fs/acl.c b/fs/f2fs/acl.c
index 137af42..3e5a717 100644
--- a/fs/f2fs/acl.c
+++ b/fs/f2fs/acl.c
@@ -22,13 +22,15 @@ 
 
 static inline size_t f2fs_acl_size(int count)
 {
-	if (count <= 4) {
+	if (count <= ACL_MAX_SHORT_ENTRY) {
 		return sizeof(struct f2fs_acl_header) +
 			count * sizeof(struct f2fs_acl_entry_short);
 	} else {
 		return sizeof(struct f2fs_acl_header) +
-			4 * sizeof(struct f2fs_acl_entry_short) +
-			(count - 4) * sizeof(struct f2fs_acl_entry);
+			ACL_MAX_SHORT_ENTRY
+			 * sizeof(struct f2fs_acl_entry_short) +
+			(count - ACL_MAX_SHORT_ENTRY)
+			 * sizeof(struct f2fs_acl_entry);
 	}
 }
 
@@ -36,7 +38,7 @@  static inline int f2fs_acl_count(size_t size)
 {
 	ssize_t s;
 	size -= sizeof(struct f2fs_acl_header);
-	s = size - 4 * sizeof(struct f2fs_acl_entry_short);
+	s = size - ACL_MAX_SHORT_ENTRY * sizeof(struct f2fs_acl_entry_short);
 	if (s < 0) {
 		if (size % sizeof(struct f2fs_acl_entry_short))
 			return -1;
@@ -44,7 +46,7 @@  static inline int f2fs_acl_count(size_t size)
 	} else {
 		if (s % sizeof(struct f2fs_acl_entry))
 			return -1;
-		return s / sizeof(struct f2fs_acl_entry) + 4;
+		return s / sizeof(struct f2fs_acl_entry) + ACL_MAX_SHORT_ENTRY;
 	}
 }
 
diff --git a/fs/jffs2/acl.c b/fs/jffs2/acl.c
index 223283c..48ef4b8 100644
--- a/fs/jffs2/acl.c
+++ b/fs/jffs2/acl.c
@@ -25,13 +25,15 @@ 
 
 static size_t jffs2_acl_size(int count)
 {
-	if (count <= 4) {
+	if (count <= ACL_MAX_SHORT_ENTRY) {
 		return sizeof(struct jffs2_acl_header)
 		       + count * sizeof(struct jffs2_acl_entry_short);
 	} else {
 		return sizeof(struct jffs2_acl_header)
-		       + 4 * sizeof(struct jffs2_acl_entry_short)
-		       + (count - 4) * sizeof(struct jffs2_acl_entry);
+		       + ACL_MAX_SHORT_ENTRY
+				 * sizeof(struct jffs2_acl_entry_short)
+		       + (count - ACL_MAX_SHORT_ENTRY)
+				 * sizeof(struct jffs2_acl_entry);
 	}
 }
 
@@ -40,15 +42,16 @@  static int jffs2_acl_count(size_t size)
 	size_t s;
 
 	size -= sizeof(struct jffs2_acl_header);
-	if (size < 4 * sizeof(struct jffs2_acl_entry_short)) {
+	if (size < ACL_MAX_SHORT_ENTRY * sizeof(struct jffs2_acl_entry_short)) {
 		if (size % sizeof(struct jffs2_acl_entry_short))
 			return -1;
 		return size / sizeof(struct jffs2_acl_entry_short);
 	} else {
-		s = size - 4 * sizeof(struct jffs2_acl_entry_short);
+		s = size - ACL_MAX_SHORT_ENTRY
+				 * sizeof(struct jffs2_acl_entry_short);
 		if (s % sizeof(struct jffs2_acl_entry))
 			return -1;
-		return s / sizeof(struct jffs2_acl_entry) + 4;
+		return s / sizeof(struct jffs2_acl_entry) + ACL_MAX_SHORT_ENTRY;
 	}
 }
 
diff --git a/fs/posix_acl.c b/fs/posix_acl.c
index 8bd2135..15b1b0c 100644
--- a/fs/posix_acl.c
+++ b/fs/posix_acl.c
@@ -72,6 +72,13 @@  posix_acl_clone(const struct posix_acl *acl, gfp_t flags)
 
 /*
  * Check if an acl is valid. Returns 0 if it is, or -E... otherwise.
+ *
+ * make sure ACL format is the following:
+ *
+ *   ACL_USER_OBJ ACL_USER*[1] ACL_GROUP_OBJ ACL_GROUP*[1] ACL_MASK[2] ACL_OTHER
+ *
+ *   [1] Where * is the regexp sense of "0 or more times"
+ *   [2] If ACL_USER or ACL_GROUP is present, then ACL_MASK must be present.
  */
 int
 posix_acl_valid(const struct posix_acl *acl)
diff --git a/fs/reiserfs/acl.h b/fs/reiserfs/acl.h
index f096b80..cb967a3 100644
--- a/fs/reiserfs/acl.h
+++ b/fs/reiserfs/acl.h
@@ -20,13 +20,13 @@  typedef struct {
 
 static inline size_t reiserfs_acl_size(int count)
 {
-	if (count <= 4) {
+	if (count <= ACL_MAX_SHORT_ENTRY) {
 		return sizeof(reiserfs_acl_header) +
 		    count * sizeof(reiserfs_acl_entry_short);
 	} else {
 		return sizeof(reiserfs_acl_header) +
-		    4 * sizeof(reiserfs_acl_entry_short) +
-		    (count - 4) * sizeof(reiserfs_acl_entry);
+		    ACL_MAX_SHORT_ENTRY * sizeof(reiserfs_acl_entry_short) +
+		    (count - ACL_MAX_SHORT_ENTRY) * sizeof(reiserfs_acl_entry);
 	}
 }
 
@@ -34,7 +34,7 @@  static inline int reiserfs_acl_count(size_t size)
 {
 	ssize_t s;
 	size -= sizeof(reiserfs_acl_header);
-	s = size - 4 * sizeof(reiserfs_acl_entry_short);
+	s = size - ACL_MAX_SHORT_ENTRY * sizeof(reiserfs_acl_entry_short);
 	if (s < 0) {
 		if (size % sizeof(reiserfs_acl_entry_short))
 			return -1;
@@ -42,7 +42,7 @@  static inline int reiserfs_acl_count(size_t size)
 	} else {
 		if (s % sizeof(reiserfs_acl_entry))
 			return -1;
-		return s / sizeof(reiserfs_acl_entry) + 4;
+		return s / sizeof(reiserfs_acl_entry) + ACL_MAX_SHORT_ENTRY;
 	}
 }
 
diff --git a/include/linux/posix_acl.h b/include/linux/posix_acl.h
index 7931efe..2c5609c 100644
--- a/include/linux/posix_acl.h
+++ b/include/linux/posix_acl.h
@@ -26,6 +26,14 @@ 
 #define ACL_MASK		(0x10)
 #define ACL_OTHER		(0x20)
 
+/*
+ * posix_acl_valid() makes sure that if there are <= 4 ACL entries, then
+ * all of them are short. Otherwise exactly 4 entries are short ones and
+ * other have full length. See comment before that function for exact ACL
+ * format.
+ */
+#define ACL_MAX_SHORT_ENTRY	4
+
 /* permissions in the e_perm field */
 #define ACL_READ		(0x04)
 #define ACL_WRITE		(0x02)