From mboxrd@z Thu Jan 1 00:00:00 1970 From: "J. Bruce Fields" Subject: Re: [PATCH v23 17/22] richacl: Automatic Inheritance Date: Tue, 12 Jul 2016 15:11:42 -0400 Message-ID: <20160712191142.GE449@fieldses.org> References: <1467294433-3222-1-git-send-email-agruenba@redhat.com> <1467294433-3222-18-git-send-email-agruenba@redhat.com> <1468324560.7798.14.camel@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: QUOTED-PRINTABLE Cc: Andreas Gruenbacher , Alexander Viro , Christoph Hellwig , Theodore Ts'o , Andreas Dilger , Trond Myklebust , Anna Schumaker , Dave Chinner , linux-ext4-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, xfs-VZNHf3L845pBDgjK7y7TUQ@public.gmane.org, linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, linux-fsdevel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, linux-nfs-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, linux-cifs-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, linux-api-u79uwXL29TY76Z2rM5mHXA@public.gmane.org To: Jeff Layton Return-path: Content-Disposition: inline In-Reply-To: <1468324560.7798.14.camel-H+wXaHxf7aLQT0dZR+AlfA@public.gmane.org> Sender: linux-api-owner-u79uwXL29TY76Z2rM5mHXA@public.gmane.org List-Id: linux-cifs.vger.kernel.org On Tue, Jul 12, 2016 at 07:56:00AM -0400, Jeff Layton wrote: > On Thu, 2016-06-30 at 15:47 +0200, Andreas Gruenbacher wrote: > > Automatic Inheritance (AI) allows changes to the acl of a directory= to > > propagate down to children. > >=20 > > This is mostly implemented in user space: when a process changes th= e > > permissions of a directory and Automatic Inheritance is enabled for= that > > directory, the process must propagate those changes to all children= , > > recursively. > >=20 > > The kernel enables this by keeping track of which permissions have = been > > inherited at create time.=C2=A0=C2=A0In addition, it makes sure tha= t permission > > propagation is turned off when the permissions are set explicitly (= for > > example, upon create or chmod). > >=20 > > Automatic Inheritance works as follows: > >=20 > > =C2=A0- When the RICHACL_AUTO_INHERIT flag in the acl of a file or = directory > > =C2=A0=C2=A0=C2=A0is not set, the file or directory is not affected= by AI. > >=20 > > =C2=A0- When the RICHACL_AUTO_INHERIT flag in the acl of a director= y is set > > =C2=A0=C2=A0=C2=A0and a file or subdirectory is created in that dir= ectory, the > > =C2=A0=C2=A0=C2=A0inherited acl will have the RICHACL_AUTO_INHERIT = flag set, and all > > =C2=A0=C2=A0=C2=A0inherited aces will have the RICHACE_INHERITED_AC= E flag set.=C2=A0=C2=A0This > > =C2=A0=C2=A0=C2=A0allows user space to distinguish between aces whi= ch have been > > =C2=A0=C2=A0=C2=A0inherited and aces which have been explicitly add= ed. > >=20 > > =C2=A0- When the RICHACL_PROTECTED acl flag in the acl of a file or= directory > > =C2=A0=C2=A0=C2=A0is set, AI will not modify the acl.=C2=A0=C2=A0Th= is does not affect propagation > > =C2=A0=C2=A0=C2=A0of permissions from the file to its children (if = the file is a > > =C2=A0=C2=A0=C2=A0directory). > >=20 > > Linux does not have a way of creating files or directories without = setting the > > file permission bits, so all files created inside a directory with > > RICHACL_AUTO_INHERIT set will have the RICHACL_PROTECTED flag set.=C2= =A0=C2=A0This > > effectively disables Automatic Inheritance. > >=20 > > Protocols which support creating files without specifying permissio= ns can > > explicitly clear the RICHACL_PROTECTED flag after creating a file a= nd reset the > > file masks to "undo" applying the create mode; see richacl_compute_= max_masks(). > > They should set the RICHACL_DEFAULTED flag.=C2=A0=C2=A0(A mechanism= that would allow to > > indicate to the kernel to ignore the create mode in the first place= when there > > are inherited permissions would be nice to have.) > >=20 > > Signed-off-by: Andreas Gruenbacher > > --- > > =C2=A0fs/richacl.c=C2=A0=C2=A0=C2=A0=C2=A0=C2=A0=C2=A0=C2=A0=C2=A0=C2= =A0=C2=A0=C2=A0=C2=A0=C2=A0=C2=A0=C2=A0=C2=A0=C2=A0| 20 +++++++++++++++= ++++- > > =C2=A0include/linux/richacl.h=C2=A0=C2=A0=C2=A0=C2=A0=C2=A0=C2=A0| = 12 ++++++++++++ > > =C2=A0include/uapi/linux/richacl.h | 11 ++++++++++- > > =C2=A03 files changed, 41 insertions(+), 2 deletions(-) > >=20 > > diff --git a/fs/richacl.c b/fs/richacl.c > > index 29eaf89..40e4af9 100644 > > --- a/fs/richacl.c > > +++ b/fs/richacl.c > > @@ -573,7 +573,8 @@ __richacl_chmod(struct richacl *acl, umode_t mo= de) > > =C2=A0 =C2=A0=C2=A0=C2=A0=C2=A0acl->a_group_mask =3D=3D group_mask = && > > =C2=A0 =C2=A0=C2=A0=C2=A0=C2=A0acl->a_other_mask =3D=3D other_mask = && > > =C2=A0 =C2=A0=C2=A0=C2=A0=C2=A0(acl->a_flags & RICHACL_MASKED) && > > - =C2=A0=C2=A0=C2=A0=C2=A0(acl->a_flags & RICHACL_WRITE_THROUGH)) > > + =C2=A0=C2=A0=C2=A0=C2=A0(acl->a_flags & RICHACL_WRITE_THROUGH) && > > + =C2=A0=C2=A0=C2=A0=C2=A0(!richacl_is_auto_inherit(acl) || richacl= _is_protected(acl))) > > =C2=A0 return acl; > > =C2=A0 > > =C2=A0 clone =3D richacl_clone(acl, GFP_KERNEL); > > @@ -585,6 +586,8 @@ __richacl_chmod(struct richacl *acl, umode_t mo= de) > > =C2=A0 clone->a_owner_mask =3D owner_mask; > > =C2=A0 clone->a_group_mask =3D group_mask; > > =C2=A0 clone->a_other_mask =3D other_mask; > > + if (richacl_is_auto_inherit(clone)) > > + clone->a_flags |=3D RICHACL_PROTECTED; > > =C2=A0 > > =C2=A0 return clone; > > =C2=A0} > > @@ -800,6 +803,14 @@ richacl_inherit(const struct richacl *dir_acl,= int isdir) > > =C2=A0 ace++; > > =C2=A0 } > > =C2=A0 } > > + if (richacl_is_auto_inherit(dir_acl)) { > > + acl->a_flags =3D RICHACL_AUTO_INHERIT; > > + richacl_for_each_entry(ace, acl) > > + ace->e_flags |=3D RICHACE_INHERITED_ACE; > > + } else { > > + richacl_for_each_entry(ace, acl) > > + ace->e_flags &=3D ~RICHACE_INHERITED_ACE; > > + } > > =C2=A0 > > =C2=A0 return acl; > > =C2=A0} > > @@ -828,6 +839,13 @@ richacl_inherit_inode(const struct richacl *di= r_acl, umode_t *mode_p) > > =C2=A0 richacl_put(acl); > > =C2=A0 acl =3D NULL; > > =C2=A0 } else { > > + /* > > + =C2=A0* We need to set RICHACL_PROTECTED because we are > > + =C2=A0* doing an implicit chmod > > + =C2=A0*/ > > + if (richacl_is_auto_inherit(acl)) > > + acl->a_flags |=3D RICHACL_PROTECTED; > > + > > =C2=A0 richacl_compute_max_masks(acl); > > =C2=A0 /* > > =C2=A0 =C2=A0* Ensure that the acl will not grant any permissions > > diff --git a/include/linux/richacl.h b/include/linux/richacl.h > > index 7aca1a3..a442372 100644 > > --- a/include/linux/richacl.h > > +++ b/include/linux/richacl.h > > @@ -81,6 +81,18 @@ extern void set_cached_richacl(struct inode *, s= truct richacl *); > > =C2=A0extern void forget_cached_richacl(struct inode *); > > =C2=A0extern struct richacl *get_richacl(struct inode *); > > =C2=A0 > > +static inline int > > +richacl_is_auto_inherit(const struct richacl *acl) > > +{ > > + return acl->a_flags & RICHACL_AUTO_INHERIT; > > +} > > + > > +static inline int > > +richacl_is_protected(const struct richacl *acl) > > +{ > > + return acl->a_flags & RICHACL_PROTECTED; > > +} > > + > > =C2=A0/** > > =C2=A0 * richace_is_owner=C2=A0=C2=A0-=C2=A0=C2=A0check if @ace is = an OWNER@ entry > > =C2=A0 */ > > diff --git a/include/uapi/linux/richacl.h b/include/uapi/linux/rich= acl.h > > index 1ed48ac..8849a53 100644 > > --- a/include/uapi/linux/richacl.h > > +++ b/include/uapi/linux/richacl.h > > @@ -18,6 +18,9 @@ > > =C2=A0#define __UAPI_RICHACL_H > > =C2=A0 > > =C2=A0/* a_flags values */ > > +#define RICHACL_AUTO_INHERIT 0x01 > > +#define RICHACL_PROTECTED 0x02 > > +#define RICHACL_DEFAULTED 0x04 > > =C2=A0#define RICHACL_WRITE_THROUGH 0x40 > > =C2=A0#define RICHACL_MASKED 0x80 > > =C2=A0 > > @@ -31,6 +34,7 @@ > > =C2=A0#define RICHACE_NO_PROPAGATE_INHERIT_ACE 0x0004 > > =C2=A0#define RICHACE_INHERIT_ONLY_ACE 0x0008 > > =C2=A0#define RICHACE_IDENTIFIER_GROUP 0x0040 > > +#define RICHACE_INHERITED_ACE 0x0080 > > =C2=A0#define RICHACE_SPECIAL_WHO 0x4000 > > =C2=A0 > > =C2=A0/* e_mask bitflags */ > > @@ -60,6 +64,9 @@ > > =C2=A0#define RICHACE_EVERYONE_SPECIAL_ID 2 > > =C2=A0 > > =C2=A0#define RICHACL_VALID_FLAGS ( \ > > + RICHACL_AUTO_INHERIT | \ > > + RICHACL_PROTECTED | \ > > + RICHACL_DEFAULTED | \ > > =C2=A0 RICHACL_WRITE_THROUGH | \ > > =C2=A0 RICHACL_MASKED ) > > =C2=A0 > > @@ -69,13 +76,15 @@ > > =C2=A0 RICHACE_NO_PROPAGATE_INHERIT_ACE | \ > > =C2=A0 RICHACE_INHERIT_ONLY_ACE | \ > > =C2=A0 RICHACE_IDENTIFIER_GROUP | \ > > + RICHACE_INHERITED_ACE | \ > > =C2=A0 RICHACE_SPECIAL_WHO ) > > =C2=A0 > > =C2=A0#define RICHACE_INHERITANCE_FLAGS ( \ > > =C2=A0 RICHACE_FILE_INHERIT_ACE | \ > > =C2=A0 RICHACE_DIRECTORY_INHERIT_ACE | \ > > =C2=A0 RICHACE_NO_PROPAGATE_INHERIT_ACE | \ > > - RICHACE_INHERIT_ONLY_ACE ) > > + RICHACE_INHERIT_ONLY_ACE | \ > > + RICHACE_INHERITED_ACE ) > > =C2=A0 > > =C2=A0/* Valid RICHACE_* flags for directories and non-directories = */ > > =C2=A0#define RICHACE_VALID_MASK ( =09 > > \ >=20 > Barf. AI seems like a trainwreck waiting to happen. What are the > chances that userland is going to get this right? This is just taken from Windows, so presumably Samba should do the righ= t thing (with one workaround required--see the discussion of PROTECTED in the changelog). > Still, I do applaud the fact that you're just doing the bare minimum = in > kernel to support userland apps that want this. Thanks for not trying > to push the propagation of the changed ACEs into the kernel. Agreed. But, again, this is just what Windows does. (I wonder whether there's an OS that's actually tried do any sort of atomic propagation.) --b. From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751397AbcGLTLr (ORCPT ); Tue, 12 Jul 2016 15:11:47 -0400 Received: from fieldses.org ([173.255.197.46]:36640 "EHLO fieldses.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751163AbcGLTLo (ORCPT ); Tue, 12 Jul 2016 15:11:44 -0400 Date: Tue, 12 Jul 2016 15:11:42 -0400 From: "J. Bruce Fields" To: Jeff Layton Cc: Andreas Gruenbacher , Alexander Viro , Christoph Hellwig , "Theodore Ts'o" , Andreas Dilger , Trond Myklebust , Anna Schumaker , Dave Chinner , linux-ext4@vger.kernel.org, xfs@oss.sgi.com, linux-kernel@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-nfs@vger.kernel.org, linux-cifs@vger.kernel.org, linux-api@vger.kernel.org Subject: Re: [PATCH v23 17/22] richacl: Automatic Inheritance Message-ID: <20160712191142.GE449@fieldses.org> References: <1467294433-3222-1-git-send-email-agruenba@redhat.com> <1467294433-3222-18-git-send-email-agruenba@redhat.com> <1468324560.7798.14.camel@redhat.com> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <1468324560.7798.14.camel@redhat.com> User-Agent: Mutt/1.5.21 (2010-09-15) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Tue, Jul 12, 2016 at 07:56:00AM -0400, Jeff Layton wrote: > On Thu, 2016-06-30 at 15:47 +0200, Andreas Gruenbacher wrote: > > Automatic Inheritance (AI) allows changes to the acl of a directory to > > propagate down to children. > > > > This is mostly implemented in user space: when a process changes the > > permissions of a directory and Automatic Inheritance is enabled for that > > directory, the process must propagate those changes to all children, > > recursively. > > > > The kernel enables this by keeping track of which permissions have been > > inherited at create time.  In addition, it makes sure that permission > > propagation is turned off when the permissions are set explicitly (for > > example, upon create or chmod). > > > > Automatic Inheritance works as follows: > > > >  - When the RICHACL_AUTO_INHERIT flag in the acl of a file or directory > >    is not set, the file or directory is not affected by AI. > > > >  - When the RICHACL_AUTO_INHERIT flag in the acl of a directory is set > >    and a file or subdirectory is created in that directory, the > >    inherited acl will have the RICHACL_AUTO_INHERIT flag set, and all > >    inherited aces will have the RICHACE_INHERITED_ACE flag set.  This > >    allows user space to distinguish between aces which have been > >    inherited and aces which have been explicitly added. > > > >  - When the RICHACL_PROTECTED acl flag in the acl of a file or directory > >    is set, AI will not modify the acl.  This does not affect propagation > >    of permissions from the file to its children (if the file is a > >    directory). > > > > Linux does not have a way of creating files or directories without setting the > > file permission bits, so all files created inside a directory with > > RICHACL_AUTO_INHERIT set will have the RICHACL_PROTECTED flag set.  This > > effectively disables Automatic Inheritance. > > > > Protocols which support creating files without specifying permissions can > > explicitly clear the RICHACL_PROTECTED flag after creating a file and reset the > > file masks to "undo" applying the create mode; see richacl_compute_max_masks(). > > They should set the RICHACL_DEFAULTED flag.  (A mechanism that would allow to > > indicate to the kernel to ignore the create mode in the first place when there > > are inherited permissions would be nice to have.) > > > > Signed-off-by: Andreas Gruenbacher > > --- > >  fs/richacl.c                 | 20 +++++++++++++++++++- > >  include/linux/richacl.h      | 12 ++++++++++++ > >  include/uapi/linux/richacl.h | 11 ++++++++++- > >  3 files changed, 41 insertions(+), 2 deletions(-) > > > > diff --git a/fs/richacl.c b/fs/richacl.c > > index 29eaf89..40e4af9 100644 > > --- a/fs/richacl.c > > +++ b/fs/richacl.c > > @@ -573,7 +573,8 @@ __richacl_chmod(struct richacl *acl, umode_t mode) > >       acl->a_group_mask == group_mask && > >       acl->a_other_mask == other_mask && > >       (acl->a_flags & RICHACL_MASKED) && > > -     (acl->a_flags & RICHACL_WRITE_THROUGH)) > > +     (acl->a_flags & RICHACL_WRITE_THROUGH) && > > +     (!richacl_is_auto_inherit(acl) || richacl_is_protected(acl))) > >   return acl; > >   > >   clone = richacl_clone(acl, GFP_KERNEL); > > @@ -585,6 +586,8 @@ __richacl_chmod(struct richacl *acl, umode_t mode) > >   clone->a_owner_mask = owner_mask; > >   clone->a_group_mask = group_mask; > >   clone->a_other_mask = other_mask; > > + if (richacl_is_auto_inherit(clone)) > > + clone->a_flags |= RICHACL_PROTECTED; > >   > >   return clone; > >  } > > @@ -800,6 +803,14 @@ richacl_inherit(const struct richacl *dir_acl, int isdir) > >   ace++; > >   } > >   } > > + if (richacl_is_auto_inherit(dir_acl)) { > > + acl->a_flags = RICHACL_AUTO_INHERIT; > > + richacl_for_each_entry(ace, acl) > > + ace->e_flags |= RICHACE_INHERITED_ACE; > > + } else { > > + richacl_for_each_entry(ace, acl) > > + ace->e_flags &= ~RICHACE_INHERITED_ACE; > > + } > >   > >   return acl; > >  } > > @@ -828,6 +839,13 @@ richacl_inherit_inode(const struct richacl *dir_acl, umode_t *mode_p) > >   richacl_put(acl); > >   acl = NULL; > >   } else { > > + /* > > +  * We need to set RICHACL_PROTECTED because we are > > +  * doing an implicit chmod > > +  */ > > + if (richacl_is_auto_inherit(acl)) > > + acl->a_flags |= RICHACL_PROTECTED; > > + > >   richacl_compute_max_masks(acl); > >   /* > >    * Ensure that the acl will not grant any permissions > > diff --git a/include/linux/richacl.h b/include/linux/richacl.h > > index 7aca1a3..a442372 100644 > > --- a/include/linux/richacl.h > > +++ b/include/linux/richacl.h > > @@ -81,6 +81,18 @@ extern void set_cached_richacl(struct inode *, struct richacl *); > >  extern void forget_cached_richacl(struct inode *); > >  extern struct richacl *get_richacl(struct inode *); > >   > > +static inline int > > +richacl_is_auto_inherit(const struct richacl *acl) > > +{ > > + return acl->a_flags & RICHACL_AUTO_INHERIT; > > +} > > + > > +static inline int > > +richacl_is_protected(const struct richacl *acl) > > +{ > > + return acl->a_flags & RICHACL_PROTECTED; > > +} > > + > >  /** > >   * richace_is_owner  -  check if @ace is an OWNER@ entry > >   */ > > diff --git a/include/uapi/linux/richacl.h b/include/uapi/linux/richacl.h > > index 1ed48ac..8849a53 100644 > > --- a/include/uapi/linux/richacl.h > > +++ b/include/uapi/linux/richacl.h > > @@ -18,6 +18,9 @@ > >  #define __UAPI_RICHACL_H > >   > >  /* a_flags values */ > > +#define RICHACL_AUTO_INHERIT 0x01 > > +#define RICHACL_PROTECTED 0x02 > > +#define RICHACL_DEFAULTED 0x04 > >  #define RICHACL_WRITE_THROUGH 0x40 > >  #define RICHACL_MASKED 0x80 > >   > > @@ -31,6 +34,7 @@ > >  #define RICHACE_NO_PROPAGATE_INHERIT_ACE 0x0004 > >  #define RICHACE_INHERIT_ONLY_ACE 0x0008 > >  #define RICHACE_IDENTIFIER_GROUP 0x0040 > > +#define RICHACE_INHERITED_ACE 0x0080 > >  #define RICHACE_SPECIAL_WHO 0x4000 > >   > >  /* e_mask bitflags */ > > @@ -60,6 +64,9 @@ > >  #define RICHACE_EVERYONE_SPECIAL_ID 2 > >   > >  #define RICHACL_VALID_FLAGS ( \ > > + RICHACL_AUTO_INHERIT | \ > > + RICHACL_PROTECTED | \ > > + RICHACL_DEFAULTED | \ > >   RICHACL_WRITE_THROUGH | \ > >   RICHACL_MASKED ) > >   > > @@ -69,13 +76,15 @@ > >   RICHACE_NO_PROPAGATE_INHERIT_ACE | \ > >   RICHACE_INHERIT_ONLY_ACE | \ > >   RICHACE_IDENTIFIER_GROUP | \ > > + RICHACE_INHERITED_ACE | \ > >   RICHACE_SPECIAL_WHO ) > >   > >  #define RICHACE_INHERITANCE_FLAGS ( \ > >   RICHACE_FILE_INHERIT_ACE | \ > >   RICHACE_DIRECTORY_INHERIT_ACE | \ > >   RICHACE_NO_PROPAGATE_INHERIT_ACE | \ > > - RICHACE_INHERIT_ONLY_ACE ) > > + RICHACE_INHERIT_ONLY_ACE | \ > > + RICHACE_INHERITED_ACE ) > >   > >  /* Valid RICHACE_* flags for directories and non-directories */ > >  #define RICHACE_VALID_MASK ( > > \ > > Barf. AI seems like a trainwreck waiting to happen. What are the > chances that userland is going to get this right? This is just taken from Windows, so presumably Samba should do the right thing (with one workaround required--see the discussion of PROTECTED in the changelog). > Still, I do applaud the fact that you're just doing the bare minimum in > kernel to support userland apps that want this. Thanks for not trying > to push the propagation of the changed ACEs into the kernel. Agreed. But, again, this is just what Windows does. (I wonder whether there's an OS that's actually tried do any sort of atomic propagation.) --b. From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from relay.sgi.com (relay3.corp.sgi.com [198.149.34.15]) by oss.sgi.com (Postfix) with ESMTP id A680D7CA1 for ; Tue, 12 Jul 2016 14:11:49 -0500 (CDT) Received: from cuda.sgi.com (cuda2.sgi.com [192.48.176.25]) by relay3.corp.sgi.com (Postfix) with ESMTP id 1EFD5AC002 for ; Tue, 12 Jul 2016 12:11:45 -0700 (PDT) Received: from fieldses.org (fieldses.org [173.255.197.46]) by cuda.sgi.com with ESMTP id GWtUBexaZulah1Br for ; Tue, 12 Jul 2016 12:11:43 -0700 (PDT) Date: Tue, 12 Jul 2016 15:11:42 -0400 From: "J. Bruce Fields" Subject: Re: [PATCH v23 17/22] richacl: Automatic Inheritance Message-ID: <20160712191142.GE449@fieldses.org> References: <1467294433-3222-1-git-send-email-agruenba@redhat.com> <1467294433-3222-18-git-send-email-agruenba@redhat.com> <1468324560.7798.14.camel@redhat.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <1468324560.7798.14.camel@redhat.com> List-Id: XFS Filesystem from SGI List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: xfs-bounces@oss.sgi.com Sender: xfs-bounces@oss.sgi.com To: Jeff Layton Cc: linux-cifs@vger.kernel.org, linux-nfs@vger.kernel.org, Theodore Ts'o , Andreas Gruenbacher , linux-api@vger.kernel.org, Trond Myklebust , linux-kernel@vger.kernel.org, xfs@oss.sgi.com, Christoph Hellwig , Andreas Dilger , Alexander Viro , linux-fsdevel@vger.kernel.org, linux-ext4@vger.kernel.org, Anna Schumaker T24gVHVlLCBKdWwgMTIsIDIwMTYgYXQgMDc6NTY6MDBBTSAtMDQwMCwgSmVmZiBMYXl0b24gd3Jv dGU6Cj4gT24gVGh1LCAyMDE2LTA2LTMwIGF0IDE1OjQ3ICswMjAwLCBBbmRyZWFzIEdydWVuYmFj aGVyIHdyb3RlOgo+ID4gQXV0b21hdGljIEluaGVyaXRhbmNlIChBSSkgYWxsb3dzIGNoYW5nZXMg dG8gdGhlIGFjbCBvZiBhIGRpcmVjdG9yeSB0bwo+ID4gcHJvcGFnYXRlIGRvd24gdG8gY2hpbGRy ZW4uCj4gPiAKPiA+IFRoaXMgaXMgbW9zdGx5IGltcGxlbWVudGVkIGluIHVzZXIgc3BhY2U6IHdo ZW4gYSBwcm9jZXNzIGNoYW5nZXMgdGhlCj4gPiBwZXJtaXNzaW9ucyBvZiBhIGRpcmVjdG9yeSBh bmQgQXV0b21hdGljIEluaGVyaXRhbmNlIGlzIGVuYWJsZWQgZm9yIHRoYXQKPiA+IGRpcmVjdG9y eSwgdGhlIHByb2Nlc3MgbXVzdCBwcm9wYWdhdGUgdGhvc2UgY2hhbmdlcyB0byBhbGwgY2hpbGRy ZW4sCj4gPiByZWN1cnNpdmVseS4KPiA+IAo+ID4gVGhlIGtlcm5lbCBlbmFibGVzIHRoaXMgYnkg a2VlcGluZyB0cmFjayBvZiB3aGljaCBwZXJtaXNzaW9ucyBoYXZlIGJlZW4KPiA+IGluaGVyaXRl ZCBhdCBjcmVhdGUgdGltZS7CoMKgSW4gYWRkaXRpb24sIGl0IG1ha2VzIHN1cmUgdGhhdCBwZXJt aXNzaW9uCj4gPiBwcm9wYWdhdGlvbiBpcyB0dXJuZWQgb2ZmIHdoZW4gdGhlIHBlcm1pc3Npb25z IGFyZSBzZXQgZXhwbGljaXRseSAoZm9yCj4gPiBleGFtcGxlLCB1cG9uIGNyZWF0ZSBvciBjaG1v ZCkuCj4gPiAKPiA+IEF1dG9tYXRpYyBJbmhlcml0YW5jZSB3b3JrcyBhcyBmb2xsb3dzOgo+ID4g Cj4gPiDCoC0gV2hlbiB0aGUgUklDSEFDTF9BVVRPX0lOSEVSSVQgZmxhZyBpbiB0aGUgYWNsIG9m IGEgZmlsZSBvciBkaXJlY3RvcnkKPiA+IMKgwqDCoGlzIG5vdCBzZXQsIHRoZSBmaWxlIG9yIGRp cmVjdG9yeSBpcyBub3QgYWZmZWN0ZWQgYnkgQUkuCj4gPiAKPiA+IMKgLSBXaGVuIHRoZSBSSUNI QUNMX0FVVE9fSU5IRVJJVCBmbGFnIGluIHRoZSBhY2wgb2YgYSBkaXJlY3RvcnkgaXMgc2V0Cj4g PiDCoMKgwqBhbmQgYSBmaWxlIG9yIHN1YmRpcmVjdG9yeSBpcyBjcmVhdGVkIGluIHRoYXQgZGly ZWN0b3J5LCB0aGUKPiA+IMKgwqDCoGluaGVyaXRlZCBhY2wgd2lsbCBoYXZlIHRoZSBSSUNIQUNM X0FVVE9fSU5IRVJJVCBmbGFnIHNldCwgYW5kIGFsbAo+ID4gwqDCoMKgaW5oZXJpdGVkIGFjZXMg d2lsbCBoYXZlIHRoZSBSSUNIQUNFX0lOSEVSSVRFRF9BQ0UgZmxhZyBzZXQuwqDCoFRoaXMKPiA+ IMKgwqDCoGFsbG93cyB1c2VyIHNwYWNlIHRvIGRpc3Rpbmd1aXNoIGJldHdlZW4gYWNlcyB3aGlj aCBoYXZlIGJlZW4KPiA+IMKgwqDCoGluaGVyaXRlZCBhbmQgYWNlcyB3aGljaCBoYXZlIGJlZW4g ZXhwbGljaXRseSBhZGRlZC4KPiA+IAo+ID4gwqAtIFdoZW4gdGhlIFJJQ0hBQ0xfUFJPVEVDVEVE IGFjbCBmbGFnIGluIHRoZSBhY2wgb2YgYSBmaWxlIG9yIGRpcmVjdG9yeQo+ID4gwqDCoMKgaXMg c2V0LCBBSSB3aWxsIG5vdCBtb2RpZnkgdGhlIGFjbC7CoMKgVGhpcyBkb2VzIG5vdCBhZmZlY3Qg cHJvcGFnYXRpb24KPiA+IMKgwqDCoG9mIHBlcm1pc3Npb25zIGZyb20gdGhlIGZpbGUgdG8gaXRz IGNoaWxkcmVuIChpZiB0aGUgZmlsZSBpcyBhCj4gPiDCoMKgwqBkaXJlY3RvcnkpLgo+ID4gCj4g PiBMaW51eCBkb2VzIG5vdCBoYXZlIGEgd2F5IG9mIGNyZWF0aW5nIGZpbGVzIG9yIGRpcmVjdG9y aWVzIHdpdGhvdXQgc2V0dGluZyB0aGUKPiA+IGZpbGUgcGVybWlzc2lvbiBiaXRzLCBzbyBhbGwg ZmlsZXMgY3JlYXRlZCBpbnNpZGUgYSBkaXJlY3Rvcnkgd2l0aAo+ID4gUklDSEFDTF9BVVRPX0lO SEVSSVQgc2V0IHdpbGwgaGF2ZSB0aGUgUklDSEFDTF9QUk9URUNURUQgZmxhZyBzZXQuwqDCoFRo aXMKPiA+IGVmZmVjdGl2ZWx5IGRpc2FibGVzIEF1dG9tYXRpYyBJbmhlcml0YW5jZS4KPiA+IAo+ ID4gUHJvdG9jb2xzIHdoaWNoIHN1cHBvcnQgY3JlYXRpbmcgZmlsZXMgd2l0aG91dCBzcGVjaWZ5 aW5nIHBlcm1pc3Npb25zIGNhbgo+ID4gZXhwbGljaXRseSBjbGVhciB0aGUgUklDSEFDTF9QUk9U RUNURUQgZmxhZyBhZnRlciBjcmVhdGluZyBhIGZpbGUgYW5kIHJlc2V0IHRoZQo+ID4gZmlsZSBt YXNrcyB0byAidW5kbyIgYXBwbHlpbmcgdGhlIGNyZWF0ZSBtb2RlOyBzZWUgcmljaGFjbF9jb21w dXRlX21heF9tYXNrcygpLgo+ID4gVGhleSBzaG91bGQgc2V0IHRoZSBSSUNIQUNMX0RFRkFVTFRF RCBmbGFnLsKgwqAoQSBtZWNoYW5pc20gdGhhdCB3b3VsZCBhbGxvdyB0bwo+ID4gaW5kaWNhdGUg dG8gdGhlIGtlcm5lbCB0byBpZ25vcmUgdGhlIGNyZWF0ZSBtb2RlIGluIHRoZSBmaXJzdCBwbGFj ZSB3aGVuIHRoZXJlCj4gPiBhcmUgaW5oZXJpdGVkIHBlcm1pc3Npb25zIHdvdWxkIGJlIG5pY2Ug dG8gaGF2ZS4pCj4gPiAKPiA+IFNpZ25lZC1vZmYtYnk6IEFuZHJlYXMgR3J1ZW5iYWNoZXIgPGFn cnVlbmJhQHJlZGhhdC5jb20+Cj4gPiAtLS0KPiA+IMKgZnMvcmljaGFjbC5jwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoHwgMjAgKysrKysrKysrKysrKysrKysrKy0KPiA+IMKgaW5j bHVkZS9saW51eC9yaWNoYWNsLmjCoMKgwqDCoMKgwqB8IDEyICsrKysrKysrKysrKwo+ID4gwqBp bmNsdWRlL3VhcGkvbGludXgvcmljaGFjbC5oIHwgMTEgKysrKysrKysrKy0KPiA+IMKgMyBmaWxl cyBjaGFuZ2VkLCA0MSBpbnNlcnRpb25zKCspLCAyIGRlbGV0aW9ucygtKQo+ID4gCj4gPiBkaWZm IC0tZ2l0IGEvZnMvcmljaGFjbC5jIGIvZnMvcmljaGFjbC5jCj4gPiBpbmRleCAyOWVhZjg5Li40 MGU0YWY5IDEwMDY0NAo+ID4gLS0tIGEvZnMvcmljaGFjbC5jCj4gPiArKysgYi9mcy9yaWNoYWNs LmMKPiA+IEBAIC01NzMsNyArNTczLDggQEAgX19yaWNoYWNsX2NobW9kKHN0cnVjdCByaWNoYWNs ICphY2wsIHVtb2RlX3QgbW9kZSkKPiA+IMKgCcKgwqDCoMKgYWNsLT5hX2dyb3VwX21hc2sgPT0g Z3JvdXBfbWFzayAmJgo+ID4gwqAJwqDCoMKgwqBhY2wtPmFfb3RoZXJfbWFzayA9PSBvdGhlcl9t YXNrICYmCj4gPiDCoAnCoMKgwqDCoChhY2wtPmFfZmxhZ3MgJiBSSUNIQUNMX01BU0tFRCkgJiYK PiA+IC0JwqDCoMKgwqAoYWNsLT5hX2ZsYWdzICYgUklDSEFDTF9XUklURV9USFJPVUdIKSkKPiA+ ICsJwqDCoMKgwqAoYWNsLT5hX2ZsYWdzICYgUklDSEFDTF9XUklURV9USFJPVUdIKSAmJgo+ID4g KwnCoMKgwqDCoCghcmljaGFjbF9pc19hdXRvX2luaGVyaXQoYWNsKSB8fCByaWNoYWNsX2lzX3By b3RlY3RlZChhY2wpKSkKPiA+IMKgCQlyZXR1cm4gYWNsOwo+ID4gwqAKPiA+IMKgCWNsb25lID0g cmljaGFjbF9jbG9uZShhY2wsIEdGUF9LRVJORUwpOwo+ID4gQEAgLTU4NSw2ICs1ODYsOCBAQCBf X3JpY2hhY2xfY2htb2Qoc3RydWN0IHJpY2hhY2wgKmFjbCwgdW1vZGVfdCBtb2RlKQo+ID4gwqAJ Y2xvbmUtPmFfb3duZXJfbWFzayA9IG93bmVyX21hc2s7Cj4gPiDCoAljbG9uZS0+YV9ncm91cF9t YXNrID0gZ3JvdXBfbWFzazsKPiA+IMKgCWNsb25lLT5hX290aGVyX21hc2sgPSBvdGhlcl9tYXNr Owo+ID4gKwlpZiAocmljaGFjbF9pc19hdXRvX2luaGVyaXQoY2xvbmUpKQo+ID4gKwkJY2xvbmUt PmFfZmxhZ3MgfD0gUklDSEFDTF9QUk9URUNURUQ7Cj4gPiDCoAo+ID4gwqAJcmV0dXJuIGNsb25l Owo+ID4gwqB9Cj4gPiBAQCAtODAwLDYgKzgwMywxNCBAQCByaWNoYWNsX2luaGVyaXQoY29uc3Qg c3RydWN0IHJpY2hhY2wgKmRpcl9hY2wsIGludCBpc2RpcikKPiA+IMKgCQkJYWNlKys7Cj4gPiDC oAkJfQo+ID4gwqAJfQo+ID4gKwlpZiAocmljaGFjbF9pc19hdXRvX2luaGVyaXQoZGlyX2FjbCkp IHsKPiA+ICsJCWFjbC0+YV9mbGFncyA9IFJJQ0hBQ0xfQVVUT19JTkhFUklUOwo+ID4gKwkJcmlj aGFjbF9mb3JfZWFjaF9lbnRyeShhY2UsIGFjbCkKPiA+ICsJCQlhY2UtPmVfZmxhZ3MgfD0gUklD SEFDRV9JTkhFUklURURfQUNFOwo+ID4gKwl9IGVsc2Ugewo+ID4gKwkJcmljaGFjbF9mb3JfZWFj aF9lbnRyeShhY2UsIGFjbCkKPiA+ICsJCQlhY2UtPmVfZmxhZ3MgJj0gflJJQ0hBQ0VfSU5IRVJJ VEVEX0FDRTsKPiA+ICsJfQo+ID4gwqAKPiA+IMKgCXJldHVybiBhY2w7Cj4gPiDCoH0KPiA+IEBA IC04MjgsNiArODM5LDEzIEBAIHJpY2hhY2xfaW5oZXJpdF9pbm9kZShjb25zdCBzdHJ1Y3Qgcmlj aGFjbCAqZGlyX2FjbCwgdW1vZGVfdCAqbW9kZV9wKQo+ID4gwqAJCQlyaWNoYWNsX3B1dChhY2wp Owo+ID4gwqAJCQlhY2wgPSBOVUxMOwo+ID4gwqAJCX0gZWxzZSB7Cj4gPiArCQkJLyoKPiA+ICsJ CQnCoCogV2UgbmVlZCB0byBzZXQgUklDSEFDTF9QUk9URUNURUQgYmVjYXVzZSB3ZSBhcmUKPiA+ ICsJCQnCoCogZG9pbmcgYW4gaW1wbGljaXQgY2htb2QKPiA+ICsJCQnCoCovCj4gPiArCQkJaWYg KHJpY2hhY2xfaXNfYXV0b19pbmhlcml0KGFjbCkpCj4gPiArCQkJCWFjbC0+YV9mbGFncyB8PSBS SUNIQUNMX1BST1RFQ1RFRDsKPiA+ICsKPiA+IMKgCQkJcmljaGFjbF9jb21wdXRlX21heF9tYXNr cyhhY2wpOwo+ID4gwqAJCQkvKgo+ID4gwqAJCQnCoCogRW5zdXJlIHRoYXQgdGhlIGFjbCB3aWxs IG5vdCBncmFudCBhbnkgcGVybWlzc2lvbnMKPiA+IGRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4 L3JpY2hhY2wuaCBiL2luY2x1ZGUvbGludXgvcmljaGFjbC5oCj4gPiBpbmRleCA3YWNhMWEzLi5h NDQyMzcyIDEwMDY0NAo+ID4gLS0tIGEvaW5jbHVkZS9saW51eC9yaWNoYWNsLmgKPiA+ICsrKyBi L2luY2x1ZGUvbGludXgvcmljaGFjbC5oCj4gPiBAQCAtODEsNiArODEsMTggQEAgZXh0ZXJuIHZv aWQgc2V0X2NhY2hlZF9yaWNoYWNsKHN0cnVjdCBpbm9kZSAqLCBzdHJ1Y3QgcmljaGFjbCAqKTsK PiA+IMKgZXh0ZXJuIHZvaWQgZm9yZ2V0X2NhY2hlZF9yaWNoYWNsKHN0cnVjdCBpbm9kZSAqKTsK PiA+IMKgZXh0ZXJuIHN0cnVjdCByaWNoYWNsICpnZXRfcmljaGFjbChzdHJ1Y3QgaW5vZGUgKik7 Cj4gPiDCoAo+ID4gK3N0YXRpYyBpbmxpbmUgaW50Cj4gPiArcmljaGFjbF9pc19hdXRvX2luaGVy aXQoY29uc3Qgc3RydWN0IHJpY2hhY2wgKmFjbCkKPiA+ICt7Cj4gPiArCXJldHVybiBhY2wtPmFf ZmxhZ3MgJiBSSUNIQUNMX0FVVE9fSU5IRVJJVDsKPiA+ICt9Cj4gPiArCj4gPiArc3RhdGljIGlu bGluZSBpbnQKPiA+ICtyaWNoYWNsX2lzX3Byb3RlY3RlZChjb25zdCBzdHJ1Y3QgcmljaGFjbCAq YWNsKQo+ID4gK3sKPiA+ICsJcmV0dXJuIGFjbC0+YV9mbGFncyAmIFJJQ0hBQ0xfUFJPVEVDVEVE Owo+ID4gK30KPiA+ICsKPiA+IMKgLyoqCj4gPiDCoCAqIHJpY2hhY2VfaXNfb3duZXLCoMKgLcKg wqBjaGVjayBpZiBAYWNlIGlzIGFuIE9XTkVSQCBlbnRyeQo+ID4gwqAgKi8KPiA+IGRpZmYgLS1n aXQgYS9pbmNsdWRlL3VhcGkvbGludXgvcmljaGFjbC5oIGIvaW5jbHVkZS91YXBpL2xpbnV4L3Jp Y2hhY2wuaAo+ID4gaW5kZXggMWVkNDhhYy4uODg0OWE1MyAxMDA2NDQKPiA+IC0tLSBhL2luY2x1 ZGUvdWFwaS9saW51eC9yaWNoYWNsLmgKPiA+ICsrKyBiL2luY2x1ZGUvdWFwaS9saW51eC9yaWNo YWNsLmgKPiA+IEBAIC0xOCw2ICsxOCw5IEBACj4gPiDCoCNkZWZpbmUgX19VQVBJX1JJQ0hBQ0xf SAo+ID4gwqAKPiA+IMKgLyogYV9mbGFncyB2YWx1ZXMgKi8KPiA+ICsjZGVmaW5lIFJJQ0hBQ0xf QVVUT19JTkhFUklUCQkJMHgwMQo+ID4gKyNkZWZpbmUgUklDSEFDTF9QUk9URUNURUQJCQkweDAy Cj4gPiArI2RlZmluZSBSSUNIQUNMX0RFRkFVTFRFRAkJCTB4MDQKPiA+IMKgI2RlZmluZSBSSUNI QUNMX1dSSVRFX1RIUk9VR0gJCQkweDQwCj4gPiDCoCNkZWZpbmUgUklDSEFDTF9NQVNLRUQJCQkJ MHg4MAo+ID4gwqAKPiA+IEBAIC0zMSw2ICszNCw3IEBACj4gPiDCoCNkZWZpbmUgUklDSEFDRV9O T19QUk9QQUdBVEVfSU5IRVJJVF9BQ0UJMHgwMDA0Cj4gPiDCoCNkZWZpbmUgUklDSEFDRV9JTkhF UklUX09OTFlfQUNFCQkweDAwMDgKPiA+IMKgI2RlZmluZSBSSUNIQUNFX0lERU5USUZJRVJfR1JP VVAJCTB4MDA0MAo+ID4gKyNkZWZpbmUgUklDSEFDRV9JTkhFUklURURfQUNFCQkJMHgwMDgwCj4g PiDCoCNkZWZpbmUgUklDSEFDRV9TUEVDSUFMX1dITwkJCTB4NDAwMAo+ID4gwqAKPiA+IMKgLyog ZV9tYXNrIGJpdGZsYWdzICovCj4gPiBAQCAtNjAsNiArNjQsOSBAQAo+ID4gwqAjZGVmaW5lIFJJ Q0hBQ0VfRVZFUllPTkVfU1BFQ0lBTF9JRAkJMgo+ID4gwqAKPiA+IMKgI2RlZmluZSBSSUNIQUNM X1ZBTElEX0ZMQUdTICgJCQkJCVwKPiA+ICsJUklDSEFDTF9BVVRPX0lOSEVSSVQgfAkJCQkJXAo+ ID4gKwlSSUNIQUNMX1BST1RFQ1RFRCB8CQkJCQlcCj4gPiArCVJJQ0hBQ0xfREVGQVVMVEVEIHwJ CQkJCVwKPiA+IMKgCVJJQ0hBQ0xfV1JJVEVfVEhST1VHSCB8CQkJCQlcCj4gPiDCoAlSSUNIQUNM X01BU0tFRCApCj4gPiDCoAo+ID4gQEAgLTY5LDEzICs3NiwxNSBAQAo+ID4gwqAJUklDSEFDRV9O T19QUk9QQUdBVEVfSU5IRVJJVF9BQ0UgfAkJCVwKPiA+IMKgCVJJQ0hBQ0VfSU5IRVJJVF9PTkxZ X0FDRSB8CQkJCVwKPiA+IMKgCVJJQ0hBQ0VfSURFTlRJRklFUl9HUk9VUCB8CQkJCVwKPiA+ICsJ UklDSEFDRV9JTkhFUklURURfQUNFIHwJCQkJCVwKPiA+IMKgCVJJQ0hBQ0VfU1BFQ0lBTF9XSE8g KQo+ID4gwqAKPiA+IMKgI2RlZmluZSBSSUNIQUNFX0lOSEVSSVRBTkNFX0ZMQUdTICgJCQkJXAo+ ID4gwqAJUklDSEFDRV9GSUxFX0lOSEVSSVRfQUNFIHwJCQkJXAo+ID4gwqAJUklDSEFDRV9ESVJF Q1RPUllfSU5IRVJJVF9BQ0UgfAkJCQlcCj4gPiDCoAlSSUNIQUNFX05PX1BST1BBR0FURV9JTkhF UklUX0FDRSB8CQkJXAo+ID4gLQlSSUNIQUNFX0lOSEVSSVRfT05MWV9BQ0UgKQo+ID4gKwlSSUNI QUNFX0lOSEVSSVRfT05MWV9BQ0UgfAkJCQlcCj4gPiArCVJJQ0hBQ0VfSU5IRVJJVEVEX0FDRSAp Cj4gPiDCoAo+ID4gwqAvKiBWYWxpZCBSSUNIQUNFXyogZmxhZ3MgZm9yIGRpcmVjdG9yaWVzIGFu ZCBub24tZGlyZWN0b3JpZXMgKi8KPiA+IMKgI2RlZmluZSBSSUNIQUNFX1ZBTElEX01BU0sgKAkJ CQkJCj4gPiBcCj4gCj4gQmFyZi4gQUkgc2VlbXMgbGlrZSBhIHRyYWlud3JlY2sgd2FpdGluZyB0 byBoYXBwZW4uIFdoYXQgYXJlIHRoZQo+IGNoYW5jZXMgdGhhdCB1c2VybGFuZCBpcyBnb2luZyB0 byBnZXQgdGhpcyByaWdodD8KClRoaXMgaXMganVzdCB0YWtlbiBmcm9tIFdpbmRvd3MsIHNvIHBy ZXN1bWFibHkgU2FtYmEgc2hvdWxkIGRvIHRoZSByaWdodAp0aGluZyAod2l0aCBvbmUgd29ya2Fy b3VuZCByZXF1aXJlZC0tc2VlIHRoZSBkaXNjdXNzaW9uIG9mIFBST1RFQ1RFRCBpbgp0aGUgY2hh bmdlbG9nKS4KCj4gU3RpbGwsIEkgZG8gYXBwbGF1ZCB0aGUgZmFjdCB0aGF0IHlvdSdyZSBqdXN0 IGRvaW5nIHRoZSBiYXJlIG1pbmltdW0gaW4KPiBrZXJuZWwgdG8gc3VwcG9ydCB1c2VybGFuZCBh cHBzIHRoYXQgd2FudCB0aGlzLiBUaGFua3MgZm9yIG5vdCB0cnlpbmcKPiB0byBwdXNoIHRoZSBw cm9wYWdhdGlvbiBvZiB0aGUgY2hhbmdlZCBBQ0VzIGludG8gdGhlIGtlcm5lbC4KCkFncmVlZC4g IEJ1dCwgYWdhaW4sIHRoaXMgaXMganVzdCB3aGF0IFdpbmRvd3MgZG9lcy4gIChJIHdvbmRlciB3 aGV0aGVyCnRoZXJlJ3MgYW4gT1MgdGhhdCdzIGFjdHVhbGx5IHRyaWVkIGRvIGFueSBzb3J0IG9m IGF0b21pYyBwcm9wYWdhdGlvbi4pCgotLWIuCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fXwp4ZnMgbWFpbGluZyBsaXN0Cnhmc0Bvc3Muc2dpLmNvbQpodHRw Oi8vb3NzLnNnaS5jb20vbWFpbG1hbi9saXN0aW5mby94ZnMK