From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jeff Layton Subject: Re: [PATCH v23 07/22] richacl: Permission mapping functions Date: Tue, 05 Jul 2016 09:39:46 -0400 Message-ID: <1467725986.3800.22.camel@redhat.com> References: <1467294433-3222-1-git-send-email-agruenba@redhat.com> <1467294433-3222-8-git-send-email-agruenba@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: QUOTED-PRINTABLE Return-path: In-Reply-To: <1467294433-3222-8-git-send-email-agruenba@redhat.com> Sender: linux-ext4-owner@vger.kernel.org To: Andreas Gruenbacher , Alexander Viro Cc: Christoph Hellwig , Theodore Ts'o , Andreas Dilger , "J. Bruce Fields" , 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 List-Id: linux-api@vger.kernel.org On Thu, 2016-06-30 at 15:46 +0200, Andreas Gruenbacher wrote: > We need to map from POSIX permissions to NFSv4 permissions when a > chmod() is done, from NFSv4 permissions to POSIX permissions when an = acl > is set (which implicitly sets the file permission bits), and from the > MAY_READ/MAY_WRITE/MAY_EXEC/MAY_APPEND flags to NFSv4 permissions whe= n > doing an access check in a richacl. >=20 > Signed-off-by: Andreas Gruenbacher > Reviewed-by: J. Bruce Fields > --- > =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| 118 ++++++++++++++= +++++++++++++++++++++++++++++ > =C2=A0include/linux/richacl.h=C2=A0=C2=A0=C2=A0=C2=A0=C2=A0=C2=A0|=C2= =A0=C2=A0=C2=A03 ++ > =C2=A0include/uapi/linux/richacl.h |=C2=A0=C2=A044 ++++++++++++++++ > =C2=A03 files changed, 165 insertions(+) >=20 > diff --git a/fs/richacl.c b/fs/richacl.c > index bcc6591..d0a4135 100644 > --- a/fs/richacl.c > +++ b/fs/richacl.c > @@ -63,3 +63,121 @@ richace_copy(struct richace *to, const struct ric= hace *from) > =C2=A0{ > =C2=A0 memcpy(to, from, sizeof(struct richace)); > =C2=A0} > + > +/* > + * richacl_mask_to_mode=C2=A0=C2=A0-=C2=A0=C2=A0compute the file per= mission bits from mask > + * @mask: %RICHACE_* permission mask > + * > + * Compute the file permission bits corresponding to a particular se= t of > + * richacl permissions. > + * > + * See richacl_masks_to_mode(). > + */ > +static int > +richacl_mask_to_mode(unsigned int mask) > +{ > + int mode =3D 0; > + > + if (mask & RICHACE_POSIX_MODE_READ) > + mode |=3D S_IROTH; > + if (mask & RICHACE_POSIX_MODE_WRITE) > + mode |=3D S_IWOTH; > + if (mask & RICHACE_POSIX_MODE_EXEC) > + mode |=3D S_IXOTH; > + > + return mode; > +} > + > +/** > + * richacl_masks_to_mode=C2=A0=C2=A0-=C2=A0=C2=A0compute file permis= sion bits from file masks > + * > + * When setting a richacl, we set the file permission bits to indica= te maximum > + * permissions: for example, we set the Write permission when a mask= contains > + * RICHACE_APPEND_DATA even if it does not also contain RICHACE_WRIT= E_DATA. > + * > + * Permissions which are not in RICHACE_POSIX_MODE_READ, > + * RICHACE_POSIX_MODE_WRITE, or RICHACE_POSIX_MODE_EXEC cannot be re= presented > + * in the file permission bits.=C2=A0=C2=A0Such permissions can stil= l be effective, but > + * not for new files or after a chmod(); they must be explicitly ena= bled in the > + * richacl. > + */ > +int > +richacl_masks_to_mode(const struct richacl *acl) > +{ > + return richacl_mask_to_mode(acl->a_owner_mask) << 6 | > + =C2=A0=C2=A0=C2=A0=C2=A0=C2=A0=C2=A0=C2=A0richacl_mask_to_mode(acl-= >a_group_mask) << 3 | > + =C2=A0=C2=A0=C2=A0=C2=A0=C2=A0=C2=A0=C2=A0richacl_mask_to_mode(acl-= >a_other_mask); > +} > +EXPORT_SYMBOL_GPL(richacl_masks_to_mode); > + > +/** > + * richacl_mode_to_mask=C2=A0=C2=A0- compute a file mask from the lo= west three mode bits > + * @mode: mode to convert to richacl permissions > + * > + * When the file permission bits of a file are set with chmod(), thi= s specifies > + * the maximum permissions that processes will get.=C2=A0=C2=A0All p= ermissions beyond > + * that will be removed from the file masks, and become ineffective. > + */ > +unsigned int > +richacl_mode_to_mask(umode_t mode) > +{ > + unsigned int mask =3D 0; > + > + if (mode & S_IROTH) > + mask |=3D RICHACE_POSIX_MODE_READ; > + if (mode & S_IWOTH) > + mask |=3D RICHACE_POSIX_MODE_WRITE; > + if (mode & S_IXOTH) > + mask |=3D RICHACE_POSIX_MODE_EXEC; > + > + return mask; > +} > + > +/** > + * richacl_want_to_mask=C2=A0=C2=A0- convert the iop->permission wan= t argument to a mask > + * @want: @want argument of the permission inode operation > + * > + * When checking for append, @want is (MAY_WRITE | MAY_APPEND). > + * > + * Richacls use the iop->may_create and iop->may_delete hooks which = are used > + * for checking if creating and deleting files is allowed.=C2=A0=C2=A0= These hooks do not > + * use richacl_want_to_mask(), so we do not have to deal with mappin= g MAY_WRITE > + * to RICHACE_ADD_FILE, RICHACE_ADD_SUBDIRECTORY, and RICHACE_DELETE= _CHILD > + * here. > + */ This comment is confusing as I don't see any may_create or may_delete iops in the final patchset. Do you mean may_create() and may_delete() here? > +unsigned int > +richacl_want_to_mask(unsigned int want) > +{ > + unsigned int mask =3D 0; > + > + if (want & MAY_READ) > + mask |=3D RICHACE_READ_DATA; > + if (want & MAY_DELETE_SELF) > + mask |=3D RICHACE_DELETE; > + if (want & MAY_TAKE_OWNERSHIP) > + mask |=3D RICHACE_WRITE_OWNER; > + if (want & MAY_CHMOD) > + mask |=3D RICHACE_WRITE_ACL; > + if (want & MAY_SET_TIMES) > + mask |=3D RICHACE_WRITE_ATTRIBUTES; > + if (want & MAY_EXEC) > + mask |=3D RICHACE_EXECUTE; > + /* > + =C2=A0* differentiate MAY_WRITE from these request > + =C2=A0*/ > + if (want & (MAY_APPEND | > + =C2=A0=C2=A0=C2=A0=C2=A0MAY_CREATE_FILE | MAY_CREATE_DIR | > + =C2=A0=C2=A0=C2=A0=C2=A0MAY_DELETE_CHILD)) { > + if (want & MAY_APPEND) > + mask |=3D RICHACE_APPEND_DATA; > + if (want & MAY_CREATE_FILE) > + mask |=3D RICHACE_ADD_FILE; > + if (want & MAY_CREATE_DIR) > + mask |=3D RICHACE_ADD_SUBDIRECTORY; > + if (want & MAY_DELETE_CHILD) > + mask |=3D RICHACE_DELETE_CHILD; > + } else if (want & MAY_WRITE) > + mask |=3D RICHACE_WRITE_DATA; > + return mask; > +} > +EXPORT_SYMBOL_GPL(richacl_want_to_mask); > diff --git a/include/linux/richacl.h b/include/linux/richacl.h > index edb8480..9102ef0 100644 > --- a/include/linux/richacl.h > +++ b/include/linux/richacl.h > @@ -175,5 +175,8 @@ richace_is_same_identifier(const struct richace *= a, const struct richace *b) > =C2=A0extern struct richacl *richacl_alloc(int, gfp_t); > =C2=A0extern struct richacl *richacl_clone(const struct richacl *, gf= p_t); > =C2=A0extern void richace_copy(struct richace *, const struct richace= *); > +extern int richacl_masks_to_mode(const struct richacl *); > +extern unsigned int richacl_mode_to_mask(umode_t); > +extern unsigned int richacl_want_to_mask(unsigned int); > =C2=A0 > =C2=A0#endif /* __RICHACL_H */ > diff --git a/include/uapi/linux/richacl.h b/include/uapi/linux/richac= l.h > index 08856f8..1ed48ac 100644 > --- a/include/uapi/linux/richacl.h > +++ b/include/uapi/linux/richacl.h > @@ -96,4 +96,48 @@ > =C2=A0 RICHACE_WRITE_OWNER | \ > =C2=A0 RICHACE_SYNCHRONIZE ) > =C2=A0 > +/* > + * The POSIX permissions are supersets of the following richacl perm= issions: > + * > + *=C2=A0=C2=A0- MAY_READ maps to READ_DATA or LIST_DIRECTORY, depend= ing on the type > + *=C2=A0=C2=A0=C2=A0=C2=A0of the file system object. > + * > + *=C2=A0=C2=A0- MAY_WRITE maps to WRITE_DATA or RICHACE_APPEND_DATA = for files, and to > + *=C2=A0=C2=A0=C2=A0=C2=A0ADD_FILE, RICHACE_ADD_SUBDIRECTORY, or RIC= HACE_DELETE_CHILD for directories. > + * > + *=C2=A0=C2=A0- MAY_EXECUTE maps to RICHACE_EXECUTE. > + * > + *=C2=A0=C2=A0(Some of these richacl permissions have the same bit v= alues.) > + */ > +#define RICHACE_POSIX_MODE_READ ( \ > + RICHACE_READ_DATA | \ > + RICHACE_LIST_DIRECTORY) > +#define RICHACE_POSIX_MODE_WRITE ( \ > + RICHACE_WRITE_DATA | \ > + RICHACE_ADD_FILE | \ > + RICHACE_APPEND_DATA | \ > + RICHACE_ADD_SUBDIRECTORY | \ > + RICHACE_DELETE_CHILD) > +#define RICHACE_POSIX_MODE_EXEC RICHACE_EXECUTE > +#define RICHACE_POSIX_MODE_ALL ( \ > + RICHACE_POSIX_MODE_READ | \ > + RICHACE_POSIX_MODE_WRITE | \ > + RICHACE_POSIX_MODE_EXEC) > + > +/* > + * These permissions are always allowed no matter what the acl says. > + */ > +#define RICHACE_POSIX_ALWAYS_ALLOWED ( \ > + RICHACE_SYNCHRONIZE | \ > + RICHACE_READ_ATTRIBUTES | \ > + RICHACE_READ_ACL) > + > +/* > + * The owner is implicitly granted these permissions under POSIX. > + */ > +#define RICHACE_POSIX_OWNER_ALLOWED ( \ > + RICHACE_WRITE_ATTRIBUTES | \ > + RICHACE_WRITE_OWNER | \ > + RICHACE_WRITE_ACL) > + > =C2=A0#endif /* __UAPI_RICHACL_H */ Other than the confusing comment, this looks ok. Reviewed-by: Jeff Layton -- To unsubscribe from this list: send the line "unsubscribe linux-ext4" i= n the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-qt0-f181.google.com ([209.85.216.181]:33226 "EHLO mail-qt0-f181.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754458AbcGENju (ORCPT ); Tue, 5 Jul 2016 09:39:50 -0400 Received: by mail-qt0-f181.google.com with SMTP id c34so100736023qte.0 for ; Tue, 05 Jul 2016 06:39:49 -0700 (PDT) Message-ID: <1467725986.3800.22.camel@redhat.com> Subject: Re: [PATCH v23 07/22] richacl: Permission mapping functions From: Jeff Layton To: Andreas Gruenbacher , Alexander Viro Cc: Christoph Hellwig , "Theodore Ts'o" , Andreas Dilger , "J. Bruce Fields" , 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 Date: Tue, 05 Jul 2016 09:39:46 -0400 In-Reply-To: <1467294433-3222-8-git-send-email-agruenba@redhat.com> References: <1467294433-3222-1-git-send-email-agruenba@redhat.com> <1467294433-3222-8-git-send-email-agruenba@redhat.com> Content-Type: text/plain; charset="UTF-8" Mime-Version: 1.0 Sender: linux-nfs-owner@vger.kernel.org List-ID: On Thu, 2016-06-30 at 15:46 +0200, Andreas Gruenbacher wrote: > We need to map from POSIX permissions to NFSv4 permissions when a > chmod() is done, from NFSv4 permissions to POSIX permissions when an acl > is set (which implicitly sets the file permission bits), and from the > MAY_READ/MAY_WRITE/MAY_EXEC/MAY_APPEND flags to NFSv4 permissions when > doing an access check in a richacl. > > Signed-off-by: Andreas Gruenbacher > Reviewed-by: J. Bruce Fields > --- >  fs/richacl.c                 | 118 +++++++++++++++++++++++++++++++++++++++++++ >  include/linux/richacl.h      |   3 ++ >  include/uapi/linux/richacl.h |  44 ++++++++++++++++ >  3 files changed, 165 insertions(+) > > diff --git a/fs/richacl.c b/fs/richacl.c > index bcc6591..d0a4135 100644 > --- a/fs/richacl.c > +++ b/fs/richacl.c > @@ -63,3 +63,121 @@ richace_copy(struct richace *to, const struct richace *from) >  { >   memcpy(to, from, sizeof(struct richace)); >  } > + > +/* > + * richacl_mask_to_mode  -  compute the file permission bits from mask > + * @mask: %RICHACE_* permission mask > + * > + * Compute the file permission bits corresponding to a particular set of > + * richacl permissions. > + * > + * See richacl_masks_to_mode(). > + */ > +static int > +richacl_mask_to_mode(unsigned int mask) > +{ > + int mode = 0; > + > + if (mask & RICHACE_POSIX_MODE_READ) > + mode |= S_IROTH; > + if (mask & RICHACE_POSIX_MODE_WRITE) > + mode |= S_IWOTH; > + if (mask & RICHACE_POSIX_MODE_EXEC) > + mode |= S_IXOTH; > + > + return mode; > +} > + > +/** > + * richacl_masks_to_mode  -  compute file permission bits from file masks > + * > + * When setting a richacl, we set the file permission bits to indicate maximum > + * permissions: for example, we set the Write permission when a mask contains > + * RICHACE_APPEND_DATA even if it does not also contain RICHACE_WRITE_DATA. > + * > + * Permissions which are not in RICHACE_POSIX_MODE_READ, > + * RICHACE_POSIX_MODE_WRITE, or RICHACE_POSIX_MODE_EXEC cannot be represented > + * in the file permission bits.  Such permissions can still be effective, but > + * not for new files or after a chmod(); they must be explicitly enabled in the > + * richacl. > + */ > +int > +richacl_masks_to_mode(const struct richacl *acl) > +{ > + return richacl_mask_to_mode(acl->a_owner_mask) << 6 | > +        richacl_mask_to_mode(acl->a_group_mask) << 3 | > +        richacl_mask_to_mode(acl->a_other_mask); > +} > +EXPORT_SYMBOL_GPL(richacl_masks_to_mode); > + > +/** > + * richacl_mode_to_mask  - compute a file mask from the lowest three mode bits > + * @mode: mode to convert to richacl permissions > + * > + * When the file permission bits of a file are set with chmod(), this specifies > + * the maximum permissions that processes will get.  All permissions beyond > + * that will be removed from the file masks, and become ineffective. > + */ > +unsigned int > +richacl_mode_to_mask(umode_t mode) > +{ > + unsigned int mask = 0; > + > + if (mode & S_IROTH) > + mask |= RICHACE_POSIX_MODE_READ; > + if (mode & S_IWOTH) > + mask |= RICHACE_POSIX_MODE_WRITE; > + if (mode & S_IXOTH) > + mask |= RICHACE_POSIX_MODE_EXEC; > + > + return mask; > +} > + > +/** > + * richacl_want_to_mask  - convert the iop->permission want argument to a mask > + * @want: @want argument of the permission inode operation > + * > + * When checking for append, @want is (MAY_WRITE | MAY_APPEND). > + * > + * Richacls use the iop->may_create and iop->may_delete hooks which are used > + * for checking if creating and deleting files is allowed.  These hooks do not > + * use richacl_want_to_mask(), so we do not have to deal with mapping MAY_WRITE > + * to RICHACE_ADD_FILE, RICHACE_ADD_SUBDIRECTORY, and RICHACE_DELETE_CHILD > + * here. > + */ This comment is confusing as I don't see any may_create or may_delete iops in the final patchset. Do you mean may_create() and may_delete() here? > +unsigned int > +richacl_want_to_mask(unsigned int want) > +{ > + unsigned int mask = 0; > + > + if (want & MAY_READ) > + mask |= RICHACE_READ_DATA; > + if (want & MAY_DELETE_SELF) > + mask |= RICHACE_DELETE; > + if (want & MAY_TAKE_OWNERSHIP) > + mask |= RICHACE_WRITE_OWNER; > + if (want & MAY_CHMOD) > + mask |= RICHACE_WRITE_ACL; > + if (want & MAY_SET_TIMES) > + mask |= RICHACE_WRITE_ATTRIBUTES; > + if (want & MAY_EXEC) > + mask |= RICHACE_EXECUTE; > + /* > +  * differentiate MAY_WRITE from these request > +  */ > + if (want & (MAY_APPEND | > +     MAY_CREATE_FILE | MAY_CREATE_DIR | > +     MAY_DELETE_CHILD)) { > + if (want & MAY_APPEND) > + mask |= RICHACE_APPEND_DATA; > + if (want & MAY_CREATE_FILE) > + mask |= RICHACE_ADD_FILE; > + if (want & MAY_CREATE_DIR) > + mask |= RICHACE_ADD_SUBDIRECTORY; > + if (want & MAY_DELETE_CHILD) > + mask |= RICHACE_DELETE_CHILD; > + } else if (want & MAY_WRITE) > + mask |= RICHACE_WRITE_DATA; > + return mask; > +} > +EXPORT_SYMBOL_GPL(richacl_want_to_mask); > diff --git a/include/linux/richacl.h b/include/linux/richacl.h > index edb8480..9102ef0 100644 > --- a/include/linux/richacl.h > +++ b/include/linux/richacl.h > @@ -175,5 +175,8 @@ richace_is_same_identifier(const struct richace *a, const struct richace *b) >  extern struct richacl *richacl_alloc(int, gfp_t); >  extern struct richacl *richacl_clone(const struct richacl *, gfp_t); >  extern void richace_copy(struct richace *, const struct richace *); > +extern int richacl_masks_to_mode(const struct richacl *); > +extern unsigned int richacl_mode_to_mask(umode_t); > +extern unsigned int richacl_want_to_mask(unsigned int); >   >  #endif /* __RICHACL_H */ > diff --git a/include/uapi/linux/richacl.h b/include/uapi/linux/richacl.h > index 08856f8..1ed48ac 100644 > --- a/include/uapi/linux/richacl.h > +++ b/include/uapi/linux/richacl.h > @@ -96,4 +96,48 @@ >   RICHACE_WRITE_OWNER | \ >   RICHACE_SYNCHRONIZE ) >   > +/* > + * The POSIX permissions are supersets of the following richacl permissions: > + * > + *  - MAY_READ maps to READ_DATA or LIST_DIRECTORY, depending on the type > + *    of the file system object. > + * > + *  - MAY_WRITE maps to WRITE_DATA or RICHACE_APPEND_DATA for files, and to > + *    ADD_FILE, RICHACE_ADD_SUBDIRECTORY, or RICHACE_DELETE_CHILD for directories. > + * > + *  - MAY_EXECUTE maps to RICHACE_EXECUTE. > + * > + *  (Some of these richacl permissions have the same bit values.) > + */ > +#define RICHACE_POSIX_MODE_READ ( \ > + RICHACE_READ_DATA | \ > + RICHACE_LIST_DIRECTORY) > +#define RICHACE_POSIX_MODE_WRITE ( \ > + RICHACE_WRITE_DATA | \ > + RICHACE_ADD_FILE | \ > + RICHACE_APPEND_DATA | \ > + RICHACE_ADD_SUBDIRECTORY | \ > + RICHACE_DELETE_CHILD) > +#define RICHACE_POSIX_MODE_EXEC RICHACE_EXECUTE > +#define RICHACE_POSIX_MODE_ALL ( \ > + RICHACE_POSIX_MODE_READ | \ > + RICHACE_POSIX_MODE_WRITE | \ > + RICHACE_POSIX_MODE_EXEC) > + > +/* > + * These permissions are always allowed no matter what the acl says. > + */ > +#define RICHACE_POSIX_ALWAYS_ALLOWED ( \ > + RICHACE_SYNCHRONIZE | \ > + RICHACE_READ_ATTRIBUTES | \ > + RICHACE_READ_ACL) > + > +/* > + * The owner is implicitly granted these permissions under POSIX. > + */ > +#define RICHACE_POSIX_OWNER_ALLOWED ( \ > + RICHACE_WRITE_ATTRIBUTES | \ > + RICHACE_WRITE_OWNER | \ > + RICHACE_WRITE_ACL) > + >  #endif /* __UAPI_RICHACL_H */ Other than the confusing comment, this looks ok. Reviewed-by: Jeff Layton From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from relay.sgi.com (relay2.corp.sgi.com [137.38.102.29]) by oss.sgi.com (Postfix) with ESMTP id 9D7097CD1 for ; Tue, 5 Jul 2016 08:39:52 -0500 (CDT) Received: from cuda.sgi.com (cuda2.sgi.com [192.48.176.25]) by relay2.corp.sgi.com (Postfix) with ESMTP id 6C981304062 for ; Tue, 5 Jul 2016 06:39:52 -0700 (PDT) Received: from mail-qt0-f180.google.com (mail-qt0-f180.google.com [209.85.216.180]) by cuda.sgi.com with ESMTP id idgDWutFB6r6YiKY (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128 verify=NO) for ; Tue, 05 Jul 2016 06:39:49 -0700 (PDT) Received: by mail-qt0-f180.google.com with SMTP id c34so100735979qte.0 for ; Tue, 05 Jul 2016 06:39:49 -0700 (PDT) Message-ID: <1467725986.3800.22.camel@redhat.com> Subject: Re: [PATCH v23 07/22] richacl: Permission mapping functions From: Jeff Layton Date: Tue, 05 Jul 2016 09:39:46 -0400 In-Reply-To: <1467294433-3222-8-git-send-email-agruenba@redhat.com> References: <1467294433-3222-1-git-send-email-agruenba@redhat.com> <1467294433-3222-8-git-send-email-agruenba@redhat.com> Mime-Version: 1.0 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: Andreas Gruenbacher , Alexander Viro Cc: "J. Bruce Fields" , linux-nfs@vger.kernel.org, Theodore Ts'o , linux-cifs@vger.kernel.org, linux-api@vger.kernel.org, Trond Myklebust , linux-kernel@vger.kernel.org, xfs@oss.sgi.com, Christoph Hellwig , Andreas Dilger , linux-fsdevel@vger.kernel.org, linux-ext4@vger.kernel.org, Anna Schumaker T24gVGh1LCAyMDE2LTA2LTMwIGF0IDE1OjQ2ICswMjAwLCBBbmRyZWFzIEdydWVuYmFjaGVyIHdy b3RlOgo+IFdlIG5lZWQgdG8gbWFwIGZyb20gUE9TSVggcGVybWlzc2lvbnMgdG8gTkZTdjQgcGVy bWlzc2lvbnMgd2hlbiBhCj4gY2htb2QoKSBpcyBkb25lLCBmcm9tIE5GU3Y0IHBlcm1pc3Npb25z IHRvIFBPU0lYIHBlcm1pc3Npb25zIHdoZW4gYW4gYWNsCj4gaXMgc2V0ICh3aGljaCBpbXBsaWNp dGx5IHNldHMgdGhlIGZpbGUgcGVybWlzc2lvbiBiaXRzKSwgYW5kIGZyb20gdGhlCj4gTUFZX1JF QUQvTUFZX1dSSVRFL01BWV9FWEVDL01BWV9BUFBFTkQgZmxhZ3MgdG8gTkZTdjQgcGVybWlzc2lv bnMgd2hlbgo+IGRvaW5nIGFuIGFjY2VzcyBjaGVjayBpbiBhIHJpY2hhY2wuCj4gCj4gU2lnbmVk LW9mZi1ieTogQW5kcmVhcyBHcnVlbmJhY2hlciA8YWdydWVuYmFAcmVkaGF0LmNvbT4KPiBSZXZp ZXdlZC1ieTogSi4gQnJ1Y2UgRmllbGRzIDxiZmllbGRzQHJlZGhhdC5jb20+Cj4gLS0tCj4gwqBm cy9yaWNoYWNsLmPCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgfCAxMTggKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwo+IMKgaW5jbHVkZS9saW51eC9y aWNoYWNsLmjCoMKgwqDCoMKgwqB8wqDCoMKgMyArKwo+IMKgaW5jbHVkZS91YXBpL2xpbnV4L3Jp Y2hhY2wuaCB8wqDCoDQ0ICsrKysrKysrKysrKysrKysKPiDCoDMgZmlsZXMgY2hhbmdlZCwgMTY1 IGluc2VydGlvbnMoKykKPiAKPiBkaWZmIC0tZ2l0IGEvZnMvcmljaGFjbC5jIGIvZnMvcmljaGFj bC5jCj4gaW5kZXggYmNjNjU5MS4uZDBhNDEzNSAxMDA2NDQKPiAtLS0gYS9mcy9yaWNoYWNsLmMK PiArKysgYi9mcy9yaWNoYWNsLmMKPiBAQCAtNjMsMyArNjMsMTIxIEBAIHJpY2hhY2VfY29weShz dHJ1Y3QgcmljaGFjZSAqdG8sIGNvbnN0IHN0cnVjdCByaWNoYWNlICpmcm9tKQo+IMKgewo+IMKg CW1lbWNweSh0bywgZnJvbSwgc2l6ZW9mKHN0cnVjdCByaWNoYWNlKSk7Cj4gwqB9Cj4gKwo+ICsv Kgo+ICsgKiByaWNoYWNsX21hc2tfdG9fbW9kZcKgwqAtwqDCoGNvbXB1dGUgdGhlIGZpbGUgcGVy bWlzc2lvbiBiaXRzIGZyb20gbWFzawo+ICsgKiBAbWFzazoJJVJJQ0hBQ0VfKiBwZXJtaXNzaW9u IG1hc2sKPiArICoKPiArICogQ29tcHV0ZSB0aGUgZmlsZSBwZXJtaXNzaW9uIGJpdHMgY29ycmVz cG9uZGluZyB0byBhIHBhcnRpY3VsYXIgc2V0IG9mCj4gKyAqIHJpY2hhY2wgcGVybWlzc2lvbnMu Cj4gKyAqCj4gKyAqIFNlZSByaWNoYWNsX21hc2tzX3RvX21vZGUoKS4KPiArICovCj4gK3N0YXRp YyBpbnQKPiArcmljaGFjbF9tYXNrX3RvX21vZGUodW5zaWduZWQgaW50IG1hc2spCj4gK3sKPiAr CWludCBtb2RlID0gMDsKPiArCj4gKwlpZiAobWFzayAmIFJJQ0hBQ0VfUE9TSVhfTU9ERV9SRUFE KQo+ICsJCW1vZGUgfD0gU19JUk9USDsKPiArCWlmIChtYXNrICYgUklDSEFDRV9QT1NJWF9NT0RF X1dSSVRFKQo+ICsJCW1vZGUgfD0gU19JV09USDsKPiArCWlmIChtYXNrICYgUklDSEFDRV9QT1NJ WF9NT0RFX0VYRUMpCj4gKwkJbW9kZSB8PSBTX0lYT1RIOwo+ICsKPiArCXJldHVybiBtb2RlOwo+ ICt9Cj4gKwo+ICsvKioKPiArICogcmljaGFjbF9tYXNrc190b19tb2RlwqDCoC3CoMKgY29tcHV0 ZSBmaWxlIHBlcm1pc3Npb24gYml0cyBmcm9tIGZpbGUgbWFza3MKPiArICoKPiArICogV2hlbiBz ZXR0aW5nIGEgcmljaGFjbCwgd2Ugc2V0IHRoZSBmaWxlIHBlcm1pc3Npb24gYml0cyB0byBpbmRp Y2F0ZSBtYXhpbXVtCj4gKyAqIHBlcm1pc3Npb25zOiBmb3IgZXhhbXBsZSwgd2Ugc2V0IHRoZSBX cml0ZSBwZXJtaXNzaW9uIHdoZW4gYSBtYXNrIGNvbnRhaW5zCj4gKyAqIFJJQ0hBQ0VfQVBQRU5E X0RBVEEgZXZlbiBpZiBpdCBkb2VzIG5vdCBhbHNvIGNvbnRhaW4gUklDSEFDRV9XUklURV9EQVRB Lgo+ICsgKgo+ICsgKiBQZXJtaXNzaW9ucyB3aGljaCBhcmUgbm90IGluIFJJQ0hBQ0VfUE9TSVhf TU9ERV9SRUFELAo+ICsgKiBSSUNIQUNFX1BPU0lYX01PREVfV1JJVEUsIG9yIFJJQ0hBQ0VfUE9T SVhfTU9ERV9FWEVDIGNhbm5vdCBiZSByZXByZXNlbnRlZAo+ICsgKiBpbiB0aGUgZmlsZSBwZXJt aXNzaW9uIGJpdHMuwqDCoFN1Y2ggcGVybWlzc2lvbnMgY2FuIHN0aWxsIGJlIGVmZmVjdGl2ZSwg YnV0Cj4gKyAqIG5vdCBmb3IgbmV3IGZpbGVzIG9yIGFmdGVyIGEgY2htb2QoKTsgdGhleSBtdXN0 IGJlIGV4cGxpY2l0bHkgZW5hYmxlZCBpbiB0aGUKPiArICogcmljaGFjbC4KPiArICovCj4gK2lu dAo+ICtyaWNoYWNsX21hc2tzX3RvX21vZGUoY29uc3Qgc3RydWN0IHJpY2hhY2wgKmFjbCkKPiAr ewo+ICsJcmV0dXJuIHJpY2hhY2xfbWFza190b19tb2RlKGFjbC0+YV9vd25lcl9tYXNrKSA8PCA2 IHwKPiArCcKgwqDCoMKgwqDCoMKgcmljaGFjbF9tYXNrX3RvX21vZGUoYWNsLT5hX2dyb3VwX21h c2spIDw8IDMgfAo+ICsJwqDCoMKgwqDCoMKgwqByaWNoYWNsX21hc2tfdG9fbW9kZShhY2wtPmFf b3RoZXJfbWFzayk7Cj4gK30KPiArRVhQT1JUX1NZTUJPTF9HUEwocmljaGFjbF9tYXNrc190b19t b2RlKTsKPiArCj4gKy8qKgo+ICsgKiByaWNoYWNsX21vZGVfdG9fbWFza8KgwqAtIGNvbXB1dGUg YSBmaWxlIG1hc2sgZnJvbSB0aGUgbG93ZXN0IHRocmVlIG1vZGUgYml0cwo+ICsgKiBAbW9kZToJ bW9kZSB0byBjb252ZXJ0IHRvIHJpY2hhY2wgcGVybWlzc2lvbnMKPiArICoKPiArICogV2hlbiB0 aGUgZmlsZSBwZXJtaXNzaW9uIGJpdHMgb2YgYSBmaWxlIGFyZSBzZXQgd2l0aCBjaG1vZCgpLCB0 aGlzIHNwZWNpZmllcwo+ICsgKiB0aGUgbWF4aW11bSBwZXJtaXNzaW9ucyB0aGF0IHByb2Nlc3Nl cyB3aWxsIGdldC7CoMKgQWxsIHBlcm1pc3Npb25zIGJleW9uZAo+ICsgKiB0aGF0IHdpbGwgYmUg cmVtb3ZlZCBmcm9tIHRoZSBmaWxlIG1hc2tzLCBhbmQgYmVjb21lIGluZWZmZWN0aXZlLgo+ICsg Ki8KPiArdW5zaWduZWQgaW50Cj4gK3JpY2hhY2xfbW9kZV90b19tYXNrKHVtb2RlX3QgbW9kZSkK PiArewo+ICsJdW5zaWduZWQgaW50IG1hc2sgPSAwOwo+ICsKPiArCWlmIChtb2RlICYgU19JUk9U SCkKPiArCQltYXNrIHw9IFJJQ0hBQ0VfUE9TSVhfTU9ERV9SRUFEOwo+ICsJaWYgKG1vZGUgJiBT X0lXT1RIKQo+ICsJCW1hc2sgfD0gUklDSEFDRV9QT1NJWF9NT0RFX1dSSVRFOwo+ICsJaWYgKG1v ZGUgJiBTX0lYT1RIKQo+ICsJCW1hc2sgfD0gUklDSEFDRV9QT1NJWF9NT0RFX0VYRUM7Cj4gKwo+ ICsJcmV0dXJuIG1hc2s7Cj4gK30KPiArCj4gKy8qKgo+ICsgKiByaWNoYWNsX3dhbnRfdG9fbWFz a8KgwqAtIGNvbnZlcnQgdGhlIGlvcC0+cGVybWlzc2lvbiB3YW50IGFyZ3VtZW50IHRvIGEgbWFz awo+ICsgKiBAd2FudDoJQHdhbnQgYXJndW1lbnQgb2YgdGhlIHBlcm1pc3Npb24gaW5vZGUgb3Bl cmF0aW9uCj4gKyAqCj4gKyAqIFdoZW4gY2hlY2tpbmcgZm9yIGFwcGVuZCwgQHdhbnQgaXMgKE1B WV9XUklURSB8IE1BWV9BUFBFTkQpLgo+ICsgKgo+ICsgKiBSaWNoYWNscyB1c2UgdGhlIGlvcC0+ bWF5X2NyZWF0ZSBhbmQgaW9wLT5tYXlfZGVsZXRlIGhvb2tzIHdoaWNoIGFyZSB1c2VkCj4gKyAq IGZvciBjaGVja2luZyBpZiBjcmVhdGluZyBhbmQgZGVsZXRpbmcgZmlsZXMgaXMgYWxsb3dlZC7C oMKgVGhlc2UgaG9va3MgZG8gbm90Cj4gKyAqIHVzZSByaWNoYWNsX3dhbnRfdG9fbWFzaygpLCBz byB3ZSBkbyBub3QgaGF2ZSB0byBkZWFsIHdpdGggbWFwcGluZyBNQVlfV1JJVEUKPiArICogdG8g UklDSEFDRV9BRERfRklMRSwgUklDSEFDRV9BRERfU1VCRElSRUNUT1JZLCBhbmQgUklDSEFDRV9E RUxFVEVfQ0hJTEQKPiArICogaGVyZS4KPiArICovCgpUaGlzIGNvbW1lbnQgaXMgY29uZnVzaW5n IGFzIEkgZG9uJ3Qgc2VlIGFueSBtYXlfY3JlYXRlIG9yIG1heV9kZWxldGUKaW9wcyBpbiB0aGUg ZmluYWwgcGF0Y2hzZXQuIERvIHlvdSBtZWFuIG1heV9jcmVhdGUoKSBhbmQgbWF5X2RlbGV0ZSgp CmhlcmU/Cgo+ICt1bnNpZ25lZCBpbnQKPiArcmljaGFjbF93YW50X3RvX21hc2sodW5zaWduZWQg aW50IHdhbnQpCj4gK3sKPiArCXVuc2lnbmVkIGludCBtYXNrID0gMDsKPiArCj4gKwlpZiAod2Fu dCAmIE1BWV9SRUFEKQo+ICsJCW1hc2sgfD0gUklDSEFDRV9SRUFEX0RBVEE7Cj4gKwlpZiAod2Fu dCAmIE1BWV9ERUxFVEVfU0VMRikKPiArCQltYXNrIHw9IFJJQ0hBQ0VfREVMRVRFOwo+ICsJaWYg KHdhbnQgJiBNQVlfVEFLRV9PV05FUlNISVApCj4gKwkJbWFzayB8PSBSSUNIQUNFX1dSSVRFX09X TkVSOwo+ICsJaWYgKHdhbnQgJiBNQVlfQ0hNT0QpCj4gKwkJbWFzayB8PSBSSUNIQUNFX1dSSVRF X0FDTDsKPiArCWlmICh3YW50ICYgTUFZX1NFVF9USU1FUykKPiArCQltYXNrIHw9IFJJQ0hBQ0Vf V1JJVEVfQVRUUklCVVRFUzsKPiArCWlmICh3YW50ICYgTUFZX0VYRUMpCj4gKwkJbWFzayB8PSBS SUNIQUNFX0VYRUNVVEU7Cj4gKwkvKgo+ICsJwqAqIGRpZmZlcmVudGlhdGUgTUFZX1dSSVRFIGZy b20gdGhlc2UgcmVxdWVzdAo+ICsJwqAqLwo+ICsJaWYgKHdhbnQgJiAoTUFZX0FQUEVORCB8Cj4g KwkJwqDCoMKgwqBNQVlfQ1JFQVRFX0ZJTEUgfCBNQVlfQ1JFQVRFX0RJUiB8Cj4gKwkJwqDCoMKg wqBNQVlfREVMRVRFX0NISUxEKSkgewo+ICsJCWlmICh3YW50ICYgTUFZX0FQUEVORCkKPiArCQkJ bWFzayB8PSBSSUNIQUNFX0FQUEVORF9EQVRBOwo+ICsJCWlmICh3YW50ICYgTUFZX0NSRUFURV9G SUxFKQo+ICsJCQltYXNrIHw9IFJJQ0hBQ0VfQUREX0ZJTEU7Cj4gKwkJaWYgKHdhbnQgJiBNQVlf Q1JFQVRFX0RJUikKPiArCQkJbWFzayB8PSBSSUNIQUNFX0FERF9TVUJESVJFQ1RPUlk7Cj4gKwkJ aWYgKHdhbnQgJiBNQVlfREVMRVRFX0NISUxEKQo+ICsJCQltYXNrIHw9IFJJQ0hBQ0VfREVMRVRF X0NISUxEOwo+ICsJfSBlbHNlIGlmICh3YW50ICYgTUFZX1dSSVRFKQo+ICsJCW1hc2sgfD0gUklD SEFDRV9XUklURV9EQVRBOwo+ICsJcmV0dXJuIG1hc2s7Cj4gK30KPiArRVhQT1JUX1NZTUJPTF9H UEwocmljaGFjbF93YW50X3RvX21hc2spOwo+IGRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3Jp Y2hhY2wuaCBiL2luY2x1ZGUvbGludXgvcmljaGFjbC5oCj4gaW5kZXggZWRiODQ4MC4uOTEwMmVm MCAxMDA2NDQKPiAtLS0gYS9pbmNsdWRlL2xpbnV4L3JpY2hhY2wuaAo+ICsrKyBiL2luY2x1ZGUv bGludXgvcmljaGFjbC5oCj4gQEAgLTE3NSw1ICsxNzUsOCBAQCByaWNoYWNlX2lzX3NhbWVfaWRl bnRpZmllcihjb25zdCBzdHJ1Y3QgcmljaGFjZSAqYSwgY29uc3Qgc3RydWN0IHJpY2hhY2UgKmIp Cj4gwqBleHRlcm4gc3RydWN0IHJpY2hhY2wgKnJpY2hhY2xfYWxsb2MoaW50LCBnZnBfdCk7Cj4g wqBleHRlcm4gc3RydWN0IHJpY2hhY2wgKnJpY2hhY2xfY2xvbmUoY29uc3Qgc3RydWN0IHJpY2hh Y2wgKiwgZ2ZwX3QpOwo+IMKgZXh0ZXJuIHZvaWQgcmljaGFjZV9jb3B5KHN0cnVjdCByaWNoYWNl ICosIGNvbnN0IHN0cnVjdCByaWNoYWNlICopOwo+ICtleHRlcm4gaW50IHJpY2hhY2xfbWFza3Nf dG9fbW9kZShjb25zdCBzdHJ1Y3QgcmljaGFjbCAqKTsKPiArZXh0ZXJuIHVuc2lnbmVkIGludCBy aWNoYWNsX21vZGVfdG9fbWFzayh1bW9kZV90KTsKPiArZXh0ZXJuIHVuc2lnbmVkIGludCByaWNo YWNsX3dhbnRfdG9fbWFzayh1bnNpZ25lZCBpbnQpOwo+IMKgCj4gwqAjZW5kaWYgLyogX19SSUNI QUNMX0ggKi8KPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS91YXBpL2xpbnV4L3JpY2hhY2wuaCBiL2lu Y2x1ZGUvdWFwaS9saW51eC9yaWNoYWNsLmgKPiBpbmRleCAwODg1NmY4Li4xZWQ0OGFjIDEwMDY0 NAo+IC0tLSBhL2luY2x1ZGUvdWFwaS9saW51eC9yaWNoYWNsLmgKPiArKysgYi9pbmNsdWRlL3Vh cGkvbGludXgvcmljaGFjbC5oCj4gQEAgLTk2LDQgKzk2LDQ4IEBACj4gwqAJUklDSEFDRV9XUklU RV9PV05FUiB8CQkJCQlcCj4gwqAJUklDSEFDRV9TWU5DSFJPTklaRSApCj4gwqAKPiArLyoKPiAr ICogVGhlIFBPU0lYIHBlcm1pc3Npb25zIGFyZSBzdXBlcnNldHMgb2YgdGhlIGZvbGxvd2luZyBy aWNoYWNsIHBlcm1pc3Npb25zOgo+ICsgKgo+ICsgKsKgwqAtIE1BWV9SRUFEIG1hcHMgdG8gUkVB RF9EQVRBIG9yIExJU1RfRElSRUNUT1JZLCBkZXBlbmRpbmcgb24gdGhlIHR5cGUKPiArICrCoMKg wqDCoG9mIHRoZSBmaWxlIHN5c3RlbSBvYmplY3QuCj4gKyAqCj4gKyAqwqDCoC0gTUFZX1dSSVRF IG1hcHMgdG8gV1JJVEVfREFUQSBvciBSSUNIQUNFX0FQUEVORF9EQVRBIGZvciBmaWxlcywgYW5k IHRvCj4gKyAqwqDCoMKgwqBBRERfRklMRSwgUklDSEFDRV9BRERfU1VCRElSRUNUT1JZLCBvciBS SUNIQUNFX0RFTEVURV9DSElMRCBmb3IgZGlyZWN0b3JpZXMuCj4gKyAqCj4gKyAqwqDCoC0gTUFZ X0VYRUNVVEUgbWFwcyB0byBSSUNIQUNFX0VYRUNVVEUuCj4gKyAqCj4gKyAqwqDCoChTb21lIG9m IHRoZXNlIHJpY2hhY2wgcGVybWlzc2lvbnMgaGF2ZSB0aGUgc2FtZSBiaXQgdmFsdWVzLikKPiAr ICovCj4gKyNkZWZpbmUgUklDSEFDRV9QT1NJWF9NT0RFX1JFQUQgKAkJCVwKPiArCQlSSUNIQUNF X1JFQURfREFUQSB8CQkJXAo+ICsJCVJJQ0hBQ0VfTElTVF9ESVJFQ1RPUlkpCj4gKyNkZWZpbmUg UklDSEFDRV9QT1NJWF9NT0RFX1dSSVRFICgJCQlcCj4gKwkJUklDSEFDRV9XUklURV9EQVRBIHwJ CQlcCj4gKwkJUklDSEFDRV9BRERfRklMRSB8CQkJXAo+ICsJCVJJQ0hBQ0VfQVBQRU5EX0RBVEEg fAkJCVwKPiArCQlSSUNIQUNFX0FERF9TVUJESVJFQ1RPUlkgfAkJXAo+ICsJCVJJQ0hBQ0VfREVM RVRFX0NISUxEKQo+ICsjZGVmaW5lIFJJQ0hBQ0VfUE9TSVhfTU9ERV9FWEVDIFJJQ0hBQ0VfRVhF Q1VURQo+ICsjZGVmaW5lIFJJQ0hBQ0VfUE9TSVhfTU9ERV9BTEwgKAkJCVwKPiArCQlSSUNIQUNF X1BPU0lYX01PREVfUkVBRCB8CQlcCj4gKwkJUklDSEFDRV9QT1NJWF9NT0RFX1dSSVRFIHwJCVwK PiArCQlSSUNIQUNFX1BPU0lYX01PREVfRVhFQykKPiArCj4gKy8qCj4gKyAqIFRoZXNlIHBlcm1p c3Npb25zIGFyZSBhbHdheXMgYWxsb3dlZCBubyBtYXR0ZXIgd2hhdCB0aGUgYWNsIHNheXMuCj4g KyAqLwo+ICsjZGVmaW5lIFJJQ0hBQ0VfUE9TSVhfQUxXQVlTX0FMTE9XRUQgKAkJCVwKPiArCQlS SUNIQUNFX1NZTkNIUk9OSVpFIHwJCQlcCj4gKwkJUklDSEFDRV9SRUFEX0FUVFJJQlVURVMgfAkJ XAo+ICsJCVJJQ0hBQ0VfUkVBRF9BQ0wpCj4gKwo+ICsvKgo+ICsgKiBUaGUgb3duZXIgaXMgaW1w bGljaXRseSBncmFudGVkIHRoZXNlIHBlcm1pc3Npb25zIHVuZGVyIFBPU0lYLgo+ICsgKi8KPiAr I2RlZmluZSBSSUNIQUNFX1BPU0lYX09XTkVSX0FMTE9XRUQgKAkJCVwKPiArCQlSSUNIQUNFX1dS SVRFX0FUVFJJQlVURVMgfAkJXAo+ICsJCVJJQ0hBQ0VfV1JJVEVfT1dORVIgfAkJCVwKPiArCQlS SUNIQUNFX1dSSVRFX0FDTCkKPiArCj4gwqAjZW5kaWYgLyogX19VQVBJX1JJQ0hBQ0xfSCAqLwoK T3RoZXIgdGhhbiB0aGUgY29uZnVzaW5nIGNvbW1lbnQsIHRoaXMgbG9va3Mgb2suCgpSZXZpZXdl ZC1ieTogSmVmZiBMYXl0b24gPGpsYXl0b25AcmVkaGF0LmNvbT4KCl9fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCnhmcyBtYWlsaW5nIGxpc3QKeGZzQG9zcy5z Z2kuY29tCmh0dHA6Ly9vc3Muc2dpLmNvbS9tYWlsbWFuL2xpc3RpbmZvL3hmcwo=