Received: by 2002:a05:6358:d09b:b0:dc:cd0c:909e with SMTP id jc27csp4734265rwb; Mon, 21 Nov 2022 11:09:03 -0800 (PST) X-Google-Smtp-Source: AA0mqf6ErHNMTzkzf+B+pkGEf8+p5wAZdI2mJpy6oDXMqptYBl/bElzmBwiIGQBqwbKoonZ7Epf1 X-Received: by 2002:a17:903:2112:b0:186:67b0:afab with SMTP id o18-20020a170903211200b0018667b0afabmr224401ple.17.1669057742907; Mon, 21 Nov 2022 11:09:02 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1669057742; cv=none; d=google.com; s=arc-20160816; b=PHECP52SOsg9xpo1VRAJV/G9O6waUU703gGB9xFLcqVrPu7XUIhC2e44/4szfZX4Am tJGjadhIe2AGgrZfJAZjMi0tw92/3RNhF2OmQfR2TtbhrdqpwFodwgSaMux4YbcWfSSU Cq4SUdiUI8n1OF/M7wvqjKATNqak0hL5AuiZQES4vNUryVrcha7P+yhWEEBjpKM9VHYP jag7byq04nPkD4sYd6uAPnHqTf32IaVXnzRC7H7JyFsrSWJSYoCOkAmzue48M0NjNsgv vqeP61nUTTzjug0BjnluUtMWyj811fECF1No7MqjAlkYXR/D4d09fFayEVIGIEIyLqsf uWcA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:mime-version:user-agent :content-transfer-encoding:references:in-reply-to:date:cc:to:from :subject:message-id:dkim-signature; bh=i+GDkpSgkbya4SW1YV+4Jh6/x2P5EUKtV5IoGDlYKNg=; b=u9amxbQ6K9yzGezgf054N7yhbbzcsM9d2dR2PgBVuP6dVvY7M24/Zsxxka/oBR8llY r93ddyKgxY8jCjSgtXngQZxqC8OCc4ErcQt3gvMH8aUFpI52RD7g1x/yAgpalz62MmQL Wxu8C3bZqBfunIBIqmX9PD7B4UjqyolkwhWHgbW+R0NYQmsrrVLjjo+jF6jy3dAAOm42 voZHTiRCZ1+Lbs66KxANNfSyKfUZQI+V67/Goy4x31QZHTiLQDQkz79w4EfKX9DfSgqh VMG4ngRurFSTsz9apCSH+bQS1g6gl+/Iaur7/KMwGQgnEjDUdKyKON6Ixgb0wN36QFj1 qZhw== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@kernel.org header.s=k20201202 header.b=GeWgfmbi; spf=pass (google.com: domain of linux-nfs-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-nfs-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=kernel.org Return-Path: Received: from out1.vger.email (out1.vger.email. [2620:137:e000::1:20]) by mx.google.com with ESMTP id e3-20020a63aa03000000b004704b8534c9si12160197pgf.809.2022.11.21.11.08.41; Mon, 21 Nov 2022 11:09:02 -0800 (PST) Received-SPF: pass (google.com: domain of linux-nfs-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20; Authentication-Results: mx.google.com; dkim=pass header.i=@kernel.org header.s=k20201202 header.b=GeWgfmbi; spf=pass (google.com: domain of linux-nfs-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-nfs-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=kernel.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230481AbiKUTGo (ORCPT + 99 others); Mon, 21 Nov 2022 14:06:44 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:39264 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229985AbiKUTGn (ORCPT ); Mon, 21 Nov 2022 14:06:43 -0500 Received: from dfw.source.kernel.org (dfw.source.kernel.org [IPv6:2604:1380:4641:c500::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 12672450B5; Mon, 21 Nov 2022 11:06:40 -0800 (PST) Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id 7B2DD6144C; Mon, 21 Nov 2022 19:06:39 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id F22D0C433C1; Mon, 21 Nov 2022 19:06:34 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1669057598; bh=Tz/0BsvqWv+DMFavLzefmj3B4VjnIFnpysdMUlKb+JE=; h=Subject:From:To:Cc:Date:In-Reply-To:References:From; b=GeWgfmbihr69buRHpQ7B3LiyTalvRcB70VjJPv3AHqnMbtgL8kkgt5ddMSgpp82rt fTJm9yzTOUzjUDLYylT5noFxiIWaXF5FD2S7EDUuusMLZO4j+UFBelb1+wkQdxoo4i qE+cttUr6ctvsCOtWMpR0g6MSTKDEJ2oGBd3mg7r44lM33KclwCpDN41+aPU89O/5E n5MGG4ZI71HWzwHw6FxCt+4cAZJtFVLojZD/CY8zpTWwZvgAjyYN+pjjdv7lQOu1f6 b174tnlgJ+sEnf5p9aZMNuhnB8yyHTseEy7Y72tirthKVYd/D1KCUug2S0PxcDb45Q V73mSY6dDjfGQ== Message-ID: Subject: Re: [PATCH] filelock: move file locking definitions to separate header file From: Jeff Layton To: "Darrick J. Wong" Cc: Eric Van Hensbergen , Latchesar Ionkov , Dominique Martinet , Christian Schoenebeck , David Howells , Marc Dionne , Alexander Viro , Xiubo Li , Ilya Dryomov , Steve French , Paulo Alcantara , Ronnie Sahlberg , Shyam Prasad N , Tom Talpey , Christine Caulfield , David Teigland , Chuck Lever , Miklos Szeredi , Bob Peterson , Andreas Gruenbacher , Namjae Jeon , Sergey Senozhatsky , Trond Myklebust , Anna Schumaker , Mark Fasheh , Joel Becker , Joseph Qi , Mike Marshall , Martin Brandenburg , hch@lst.de, linux-kernel@vger.kernel.org, v9fs-developer@lists.sourceforge.net, linux-afs@lists.infradead.org, linux-fsdevel@vger.kernel.org, ceph-devel@vger.kernel.org, linux-cifs@vger.kernel.org, samba-technical@lists.samba.org, cluster-devel@redhat.com, linux-nfs@vger.kernel.org, ocfs2-devel@oss.oracle.com, devel@lists.orangefs.org, linux-xfs@vger.kernel.org Date: Mon, 21 Nov 2022 14:06:33 -0500 In-Reply-To: References: <20221120210004.381842-1-jlayton@kernel.org> <0db4c0f324fda683f6d5694c4e8e9dfab7ca893b.camel@kernel.org> Content-Type: text/plain; charset="ISO-8859-15" Content-Transfer-Encoding: quoted-printable User-Agent: Evolution 3.46.1 (3.46.1-1.fc37) MIME-Version: 1.0 X-Spam-Status: No, score=-7.1 required=5.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_HI, SPF_HELO_NONE,SPF_PASS autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-nfs@vger.kernel.org On Mon, 2022-11-21 at 09:27 -0800, Darrick J. Wong wrote: > On Mon, Nov 21, 2022 at 12:16:16PM -0500, Jeff Layton wrote: > > On Mon, 2022-11-21 at 08:53 -0800, Darrick J. Wong wrote: > > > On Sun, Nov 20, 2022 at 03:59:57PM -0500, Jeff Layton wrote: > > > > The file locking definitions have lived in fs.h since the dawn of t= ime, > > > > but they are only used by a small subset of the source files that > > > > include it. > > > >=20 > > > > Move the file locking definitions to a new header file, and add the > > > > appropriate #include directives to the source files that need them.= By > > > > doing this we trim down fs.h a bit and limit the amount of rebuildi= ng > > > > that has to be done when we make changes to the file locking APIs. > > > >=20 > > > > Signed-off-by: Jeff Layton > > > > --- > > > > fs/9p/vfs_file.c | 1 + > > > > fs/afs/internal.h | 1 + > > > > fs/attr.c | 1 + > > > > fs/ceph/locks.c | 1 + > > > > fs/cifs/cifsfs.c | 1 + > > > > fs/cifs/cifsglob.h | 1 + > > > > fs/cifs/cifssmb.c | 1 + > > > > fs/cifs/file.c | 1 + > > > > fs/cifs/smb2file.c | 1 + > > > > fs/dlm/plock.c | 1 + > > > > fs/fcntl.c | 1 + > > > > fs/file_table.c | 1 + > > > > fs/fuse/file.c | 1 + > > > > fs/gfs2/file.c | 1 + > > > > fs/inode.c | 1 + > > > > fs/ksmbd/smb2pdu.c | 1 + > > > > fs/ksmbd/vfs.c | 1 + > > > > fs/ksmbd/vfs_cache.c | 1 + > > > > fs/lockd/clntproc.c | 1 + > > > > fs/lockd/netns.h | 1 + > > > > fs/locks.c | 1 + > > > > fs/namei.c | 1 + > > > > fs/nfs/nfs4_fs.h | 1 + > > > > fs/nfs_common/grace.c | 1 + > > > > fs/nfsd/netns.h | 1 + > > > > fs/ocfs2/locks.c | 1 + > > > > fs/ocfs2/stack_user.c | 1 + > > > > fs/open.c | 1 + > > > > fs/orangefs/file.c | 1 + > > > > fs/proc/fd.c | 1 + > > > > fs/utimes.c | 1 + > > > > fs/xattr.c | 1 + > > > > fs/xfs/xfs_buf.h | 1 + > > >=20 > > > What part of the xfs buffer cache requires the file locking APIs? > > >=20 > > XFS mostly needs the layout recall APIs. Several xfs files seem to pull > > in fs.h currently by including xfs_buf.h. I started adding filelock.h t= o > > several *.c files, but quite a few needed it. > >=20 > > I can go back and add them to the xfs *.c files if you prefer. >=20 > Hmm, was it was a mechanical change? I was wondering why you didn't > pick xfs_linux.h, since that's where we usually dump header #includes > for the rest of the kernel... >=20 > $ git grep \/fs.h fs/xfs/ > fs/xfs/xfs_buf.h:13:#include >=20 > $ git grep xfs_buf.h fs/xfs/xfs_linux.h > fs/xfs/xfs_linux.h:80:#include "xfs_buf.h" >=20 > Would you mind #include'ing fs.h and filelock.h in xfs_linux.h instead? > I think/hope you'll find that the changes to xfs_file.c and xfs_inode.c > become unnecessary after that. Will do. I'll send a v2 after more people have had a chance to review this one. Thanks for taking a look! -- Jeff >=20 > > >=20 > > > > fs/xfs/xfs_file.c | 1 + > > > > fs/xfs/xfs_inode.c | 1 + > > > > include/linux/filelock.h | 428 ++++++++++++++++++++++++++++++++++= ++++ > > > > include/linux/fs.h | 421 ----------------------------------= --- > > > > include/linux/lockd/xdr.h | 1 + > > > > 38 files changed, 464 insertions(+), 421 deletions(-) > > > > create mode 100644 include/linux/filelock.h > > > >=20 > > > > Unless anyone has objections, I'll plan to merge this in via the fi= le > > > > locking tree for v6.3. I'd appreciate Acked-bys or Reviewed-bys fro= m > > > > maintainers, however. > > > >=20 > > > > diff --git a/fs/9p/vfs_file.c b/fs/9p/vfs_file.c > > > > index aec43ba83799..5e3c4b5198a6 100644 > > > > --- a/fs/9p/vfs_file.c > > > > +++ b/fs/9p/vfs_file.c > > > > @@ -9,6 +9,7 @@ > > > > #include > > > > #include > > > > #include > > > > +#include > > > > #include > > > > #include > > > > #include > > > > diff --git a/fs/afs/internal.h b/fs/afs/internal.h > > > > index 723d162078a3..c41a82a08f8b 100644 > > > > --- a/fs/afs/internal.h > > > > +++ b/fs/afs/internal.h > > > > @@ -9,6 +9,7 @@ > > > > #include > > > > #include > > > > #include > > > > +#include > > > > #include > > > > #include > > > > #include > > > > diff --git a/fs/attr.c b/fs/attr.c > > > > index 1552a5f23d6b..e643f17a5465 100644 > > > > --- a/fs/attr.c > > > > +++ b/fs/attr.c > > > > @@ -14,6 +14,7 @@ > > > > #include > > > > #include > > > > #include > > > > +#include > > > > #include > > > > #include > > > > #include > > > > diff --git a/fs/ceph/locks.c b/fs/ceph/locks.c > > > > index f3b461c708a8..476f25bba263 100644 > > > > --- a/fs/ceph/locks.c > > > > +++ b/fs/ceph/locks.c > > > > @@ -7,6 +7,7 @@ > > > > =20 > > > > #include "super.h" > > > > #include "mds_client.h" > > > > +#include > > > > #include > > > > =20 > > > > static u64 lock_secret; > > > > diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c > > > > index fe220686bba4..8d255916b6bf 100644 > > > > --- a/fs/cifs/cifsfs.c > > > > +++ b/fs/cifs/cifsfs.c > > > > @@ -12,6 +12,7 @@ > > > > =20 > > > > #include > > > > #include > > > > +#include > > > > #include > > > > #include > > > > #include > > > > diff --git a/fs/cifs/cifsglob.h b/fs/cifs/cifsglob.h > > > > index 1420acf987f0..1b9fee67a25e 100644 > > > > --- a/fs/cifs/cifsglob.h > > > > +++ b/fs/cifs/cifsglob.h > > > > @@ -25,6 +25,7 @@ > > > > #include > > > > #include "../smbfs_common/smb2pdu.h" > > > > #include "smb2pdu.h" > > > > +#include > > > > =20 > > > > #define SMB_PATH_MAX 260 > > > > #define CIFS_PORT 445 > > > > diff --git a/fs/cifs/cifssmb.c b/fs/cifs/cifssmb.c > > > > index 1724066c1536..0410658c00bd 100644 > > > > --- a/fs/cifs/cifssmb.c > > > > +++ b/fs/cifs/cifssmb.c > > > > @@ -15,6 +15,7 @@ > > > > /* want to reuse a stale file handle and only the caller knows th= e file info */ > > > > =20 > > > > #include > > > > +#include > > > > #include > > > > #include > > > > #include > > > > diff --git a/fs/cifs/file.c b/fs/cifs/file.c > > > > index 6c1431979495..c230e86f1e09 100644 > > > > --- a/fs/cifs/file.c > > > > +++ b/fs/cifs/file.c > > > > @@ -9,6 +9,7 @@ > > > > * > > > > */ > > > > #include > > > > +#include > > > > #include > > > > #include > > > > #include > > > > diff --git a/fs/cifs/smb2file.c b/fs/cifs/smb2file.c > > > > index ffbd9a99fc12..1f421bfbe797 100644 > > > > --- a/fs/cifs/smb2file.c > > > > +++ b/fs/cifs/smb2file.c > > > > @@ -7,6 +7,7 @@ > > > > * > > > > */ > > > > #include > > > > +#include > > > > #include > > > > #include > > > > #include > > > > diff --git a/fs/dlm/plock.c b/fs/dlm/plock.c > > > > index 737f185aad8d..ed4357e62f35 100644 > > > > --- a/fs/dlm/plock.c > > > > +++ b/fs/dlm/plock.c > > > > @@ -4,6 +4,7 @@ > > > > */ > > > > =20 > > > > #include > > > > +#include > > > > #include > > > > #include > > > > #include > > > > diff --git a/fs/fcntl.c b/fs/fcntl.c > > > > index 146c9ab0cd4b..7852e946fdf4 100644 > > > > --- a/fs/fcntl.c > > > > +++ b/fs/fcntl.c > > > > @@ -10,6 +10,7 @@ > > > > #include > > > > #include > > > > #include > > > > +#include > > > > #include > > > > #include > > > > #include > > > > diff --git a/fs/file_table.c b/fs/file_table.c > > > > index dd88701e54a9..372653b92617 100644 > > > > --- a/fs/file_table.c > > > > +++ b/fs/file_table.c > > > > @@ -13,6 +13,7 @@ > > > > #include > > > > #include > > > > #include > > > > +#include > > > > #include > > > > #include > > > > #include > > > > diff --git a/fs/fuse/file.c b/fs/fuse/file.c > > > > index 71bfb663aac5..0e6b3b8e2f27 100644 > > > > --- a/fs/fuse/file.c > > > > +++ b/fs/fuse/file.c > > > > @@ -18,6 +18,7 @@ > > > > #include > > > > #include > > > > #include > > > > +#include > > > > =20 > > > > static int fuse_send_open(struct fuse_mount *fm, u64 nodeid, > > > > unsigned int open_flags, int opcode, > > > > diff --git a/fs/gfs2/file.c b/fs/gfs2/file.c > > > > index 60c6fb91fb58..2a48c8df6d56 100644 > > > > --- a/fs/gfs2/file.c > > > > +++ b/fs/gfs2/file.c > > > > @@ -15,6 +15,7 @@ > > > > #include > > > > #include > > > > #include > > > > +#include > > > > #include > > > > #include > > > > #include > > > > diff --git a/fs/inode.c b/fs/inode.c > > > > index b608528efd3a..f32aa2ec148d 100644 > > > > --- a/fs/inode.c > > > > +++ b/fs/inode.c > > > > @@ -5,6 +5,7 @@ > > > > */ > > > > #include > > > > #include > > > > +#include > > > > #include > > > > #include > > > > #include > > > > diff --git a/fs/ksmbd/smb2pdu.c b/fs/ksmbd/smb2pdu.c > > > > index f2bcd2a5fb7f..d4d6f24790d6 100644 > > > > --- a/fs/ksmbd/smb2pdu.c > > > > +++ b/fs/ksmbd/smb2pdu.c > > > > @@ -12,6 +12,7 @@ > > > > #include > > > > #include > > > > #include > > > > +#include > > > > =20 > > > > #include "glob.h" > > > > #include "smbfsctl.h" > > > > diff --git a/fs/ksmbd/vfs.c b/fs/ksmbd/vfs.c > > > > index f9e85d6a160e..f73c4e119ffd 100644 > > > > --- a/fs/ksmbd/vfs.c > > > > +++ b/fs/ksmbd/vfs.c > > > > @@ -6,6 +6,7 @@ > > > > =20 > > > > #include > > > > #include > > > > +#include > > > > #include > > > > #include > > > > #include > > > > diff --git a/fs/ksmbd/vfs_cache.c b/fs/ksmbd/vfs_cache.c > > > > index da9163b00350..552c3882a8f4 100644 > > > > --- a/fs/ksmbd/vfs_cache.c > > > > +++ b/fs/ksmbd/vfs_cache.c > > > > @@ -5,6 +5,7 @@ > > > > */ > > > > =20 > > > > #include > > > > +#include > > > > #include > > > > #include > > > > =20 > > > > diff --git a/fs/lockd/clntproc.c b/fs/lockd/clntproc.c > > > > index 99fffc9cb958..e875a3571c41 100644 > > > > --- a/fs/lockd/clntproc.c > > > > +++ b/fs/lockd/clntproc.c > > > > @@ -12,6 +12,7 @@ > > > > #include > > > > #include > > > > #include > > > > +#include > > > > #include > > > > #include > > > > #include > > > > diff --git a/fs/lockd/netns.h b/fs/lockd/netns.h > > > > index 5bec78c8e431..17432c445fe6 100644 > > > > --- a/fs/lockd/netns.h > > > > +++ b/fs/lockd/netns.h > > > > @@ -3,6 +3,7 @@ > > > > #define __LOCKD_NETNS_H__ > > > > =20 > > > > #include > > > > +#include > > > > #include > > > > =20 > > > > struct lockd_net { > > > > diff --git a/fs/locks.c b/fs/locks.c > > > > index 8f01bee17715..a5cc90c958c9 100644 > > > > --- a/fs/locks.c > > > > +++ b/fs/locks.c > > > > @@ -52,6 +52,7 @@ > > > > #include > > > > #include > > > > #include > > > > +#include > > > > #include > > > > #include > > > > #include > > > > diff --git a/fs/namei.c b/fs/namei.c > > > > index 578c2110df02..d5121f51f900 100644 > > > > --- a/fs/namei.c > > > > +++ b/fs/namei.c > > > > @@ -20,6 +20,7 @@ > > > > #include > > > > #include > > > > #include > > > > +#include > > > > #include > > > > #include > > > > #include > > > > diff --git a/fs/nfs/nfs4_fs.h b/fs/nfs/nfs4_fs.h > > > > index cfef738d765e..9822ad1aabef 100644 > > > > --- a/fs/nfs/nfs4_fs.h > > > > +++ b/fs/nfs/nfs4_fs.h > > > > @@ -23,6 +23,7 @@ > > > > #define NFS4_MAX_LOOP_ON_RECOVER (10) > > > > =20 > > > > #include > > > > +#include > > > > =20 > > > > struct idmap; > > > > =20 > > > > diff --git a/fs/nfs_common/grace.c b/fs/nfs_common/grace.c > > > > index 0a9b72685f98..1479583fbb62 100644 > > > > --- a/fs/nfs_common/grace.c > > > > +++ b/fs/nfs_common/grace.c > > > > @@ -9,6 +9,7 @@ > > > > #include > > > > #include > > > > #include > > > > +#include > > > > =20 > > > > static unsigned int grace_net_id; > > > > static DEFINE_SPINLOCK(grace_lock); > > > > diff --git a/fs/nfsd/netns.h b/fs/nfsd/netns.h > > > > index 8c854ba3285b..bc139401927d 100644 > > > > --- a/fs/nfsd/netns.h > > > > +++ b/fs/nfsd/netns.h > > > > @@ -10,6 +10,7 @@ > > > > =20 > > > > #include > > > > #include > > > > +#include > > > > #include > > > > #include > > > > =20 > > > > diff --git a/fs/ocfs2/locks.c b/fs/ocfs2/locks.c > > > > index 73a3854b2afb..f37174e79fad 100644 > > > > --- a/fs/ocfs2/locks.c > > > > +++ b/fs/ocfs2/locks.c > > > > @@ -8,6 +8,7 @@ > > > > */ > > > > =20 > > > > #include > > > > +#include > > > > #include > > > > =20 > > > > #include > > > > diff --git a/fs/ocfs2/stack_user.c b/fs/ocfs2/stack_user.c > > > > index 64e6ddcfe329..05d4414d0c33 100644 > > > > --- a/fs/ocfs2/stack_user.c > > > > +++ b/fs/ocfs2/stack_user.c > > > > @@ -9,6 +9,7 @@ > > > > =20 > > > > #include > > > > #include > > > > +#include > > > > #include > > > > #include > > > > #include > > > > diff --git a/fs/open.c b/fs/open.c > > > > index a81319b6177f..11a3202ea60c 100644 > > > > --- a/fs/open.c > > > > +++ b/fs/open.c > > > > @@ -33,6 +33,7 @@ > > > > #include > > > > #include > > > > #include > > > > +#include > > > > =20 > > > > #include "internal.h" > > > > =20 > > > > diff --git a/fs/orangefs/file.c b/fs/orangefs/file.c > > > > index 732661aa2680..12ec31a9113b 100644 > > > > --- a/fs/orangefs/file.c > > > > +++ b/fs/orangefs/file.c > > > > @@ -14,6 +14,7 @@ > > > > #include "orangefs-kernel.h" > > > > #include "orangefs-bufmap.h" > > > > #include > > > > +#include > > > > #include > > > > =20 > > > > static int flush_racache(struct inode *inode) > > > > diff --git a/fs/proc/fd.c b/fs/proc/fd.c > > > > index 913bef0d2a36..2a1e7725dbcb 100644 > > > > --- a/fs/proc/fd.c > > > > +++ b/fs/proc/fd.c > > > > @@ -11,6 +11,7 @@ > > > > #include > > > > #include > > > > #include > > > > +#include > > > > =20 > > > > #include > > > > =20 > > > > diff --git a/fs/utimes.c b/fs/utimes.c > > > > index 39f356017635..00499e4ba955 100644 > > > > --- a/fs/utimes.c > > > > +++ b/fs/utimes.c > > > > @@ -7,6 +7,7 @@ > > > > #include > > > > #include > > > > #include > > > > +#include > > > > =20 > > > > static bool nsec_valid(long nsec) > > > > { > > > > diff --git a/fs/xattr.c b/fs/xattr.c > > > > index 61107b6bbed2..b81fd7d8520e 100644 > > > > --- a/fs/xattr.c > > > > +++ b/fs/xattr.c > > > > @@ -9,6 +9,7 @@ > > > > Copyright (c) 2004 Red Hat, Inc., James Morris > > > > */ > > > > #include > > > > +#include > > > > #include > > > > #include > > > > #include > > > > diff --git a/fs/xfs/xfs_buf.h b/fs/xfs/xfs_buf.h > > > > index 549c60942208..c1f283cc22f6 100644 > > > > --- a/fs/xfs/xfs_buf.h > > > > +++ b/fs/xfs/xfs_buf.h > > > > @@ -11,6 +11,7 @@ > > > > #include > > > > #include > > > > #include > > > > +#include > > > > #include > > > > #include > > > > #include > > > > diff --git a/fs/xfs/xfs_file.c b/fs/xfs/xfs_file.c > > > > index e462d39c840e..591c696651f0 100644 > > > > --- a/fs/xfs/xfs_file.c > > > > +++ b/fs/xfs/xfs_file.c > > > > @@ -31,6 +31,7 @@ > > > > #include > > > > #include > > > > #include > > > > +#include > > > > =20 > > > > static const struct vm_operations_struct xfs_file_vm_ops; > > > > =20 > > > > diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c > > > > index aa303be11576..257e279df469 100644 > > > > --- a/fs/xfs/xfs_inode.c > > > > +++ b/fs/xfs/xfs_inode.c > > > > @@ -4,6 +4,7 @@ > > > > * All Rights Reserved. > > > > */ > > > > #include > > > > +#include > > > > =20 > > > > #include "xfs.h" > > > > #include "xfs_fs.h" > > > > diff --git a/include/linux/filelock.h b/include/linux/filelock.h > > > > new file mode 100644 > > > > index 000000000000..b686e7e74787 > > > > --- /dev/null > > > > +++ b/include/linux/filelock.h > > > > @@ -0,0 +1,428 @@ > > > > +/* SPDX-License-Identifier: GPL-2.0 */ > > > > +#ifndef _LINUX_FILELOCK_H > > > > +#define _LINUX_FILELOCK_H > > > > + > > > > +#include > > > > +#include > > > > + > > > > +#define FL_POSIX 1 > > > > +#define FL_FLOCK 2 > > > > +#define FL_DELEG 4 /* NFSv4 delegation */ > > > > +#define FL_ACCESS 8 /* not trying to lock, just looking */ > > > > +#define FL_EXISTS 16 /* when unlocking, test for existence */ > > > > +#define FL_LEASE 32 /* lease held on this file */ > > > > +#define FL_CLOSE 64 /* unlock on close */ > > > > +#define FL_SLEEP 128 /* A blocking lock */ > > > > +#define FL_DOWNGRADE_PENDING 256 /* Lease is being downgraded */ > > > > +#define FL_UNLOCK_PENDING 512 /* Lease is being broken */ > > > > +#define FL_OFDLCK 1024 /* lock is "owned" by struct file */ > > > > +#define FL_LAYOUT 2048 /* outstanding pNFS layout */ > > > > +#define FL_RECLAIM 4096 /* reclaiming from a reboot server */ > > > > + > > > > +#define FL_CLOSE_POSIX (FL_POSIX | FL_CLOSE) > > > > + > > > > +/* > > > > + * Special return value from posix_lock_file() and vfs_lock_file()= for > > > > + * asynchronous locking. > > > > + */ > > > > +#define FILE_LOCK_DEFERRED 1 > > > > + > > > > +struct file_lock; > > > > + > > > > +struct file_lock_operations { > > > > + void (*fl_copy_lock)(struct file_lock *, struct file_lock *); > > > > + void (*fl_release_private)(struct file_lock *); > > > > +}; > > > > + > > > > +struct lock_manager_operations { > > > > + void *lm_mod_owner; > > > > + fl_owner_t (*lm_get_owner)(fl_owner_t); > > > > + void (*lm_put_owner)(fl_owner_t); > > > > + void (*lm_notify)(struct file_lock *); /* unblock callback */ > > > > + int (*lm_grant)(struct file_lock *, int); > > > > + bool (*lm_break)(struct file_lock *); > > > > + int (*lm_change)(struct file_lock *, int, struct list_head *); > > > > + void (*lm_setup)(struct file_lock *, void **); > > > > + bool (*lm_breaker_owns_lease)(struct file_lock *); > > > > + bool (*lm_lock_expirable)(struct file_lock *cfl); > > > > + void (*lm_expire_lock)(void); > > > > +}; > > > > + > > > > +struct lock_manager { > > > > + struct list_head list; > > > > + /* > > > > + * NFSv4 and up also want opens blocked during the grace period; > > > > + * NLM doesn't care: > > > > + */ > > > > + bool block_opens; > > > > +}; > > > > + > > > > +struct net; > > > > +void locks_start_grace(struct net *, struct lock_manager *); > > > > +void locks_end_grace(struct lock_manager *); > > > > +bool locks_in_grace(struct net *); > > > > +bool opens_in_grace(struct net *); > > > > + > > > > + > > > > +/* > > > > + * struct file_lock represents a generic "file lock". It's used to= represent > > > > + * POSIX byte range locks, BSD (flock) locks, and leases. It's imp= ortant to > > > > + * note that the same struct is used to represent both a request f= or a lock and > > > > + * the lock itself, but the same object is never used for both. > > > > + * > > > > + * FIXME: should we create a separate "struct lock_request" to hel= p distinguish > > > > + * these two uses? > > > > + * > > > > + * The varous i_flctx lists are ordered by: > > > > + * > > > > + * 1) lock owner > > > > + * 2) lock range start > > > > + * 3) lock range end > > > > + * > > > > + * Obviously, the last two criteria only matter for POSIX locks. > > > > + */ > > > > +struct file_lock { > > > > + struct file_lock *fl_blocker; /* The lock, that is blocking us */ > > > > + struct list_head fl_list; /* link into file_lock_context */ > > > > + struct hlist_node fl_link; /* node in global lists */ > > > > + struct list_head fl_blocked_requests; /* list of requests with > > > > + * ->fl_blocker pointing here > > > > + */ > > > > + struct list_head fl_blocked_member; /* node in > > > > + * ->fl_blocker->fl_blocked_requests > > > > + */ > > > > + fl_owner_t fl_owner; > > > > + unsigned int fl_flags; > > > > + unsigned char fl_type; > > > > + unsigned int fl_pid; > > > > + int fl_link_cpu; /* what cpu's list is this on? */ > > > > + wait_queue_head_t fl_wait; > > > > + struct file *fl_file; > > > > + loff_t fl_start; > > > > + loff_t fl_end; > > > > + > > > > + struct fasync_struct * fl_fasync; /* for lease break notification= s */ > > > > + /* for lease breaks: */ > > > > + unsigned long fl_break_time; > > > > + unsigned long fl_downgrade_time; > > > > + > > > > + const struct file_lock_operations *fl_ops; /* Callbacks for files= ystems */ > > > > + const struct lock_manager_operations *fl_lmops; /* Callbacks for = lockmanagers */ > > > > + union { > > > > + struct nfs_lock_info nfs_fl; > > > > + struct nfs4_lock_info nfs4_fl; > > > > + struct { > > > > + struct list_head link; /* link in AFS vnode's pending_locks lis= t */ > > > > + int state; /* state of grant or error if -ve */ > > > > + unsigned int debug_id; > > > > + } afs; > > > > + } fl_u; > > > > +} __randomize_layout; > > > > + > > > > +struct file_lock_context { > > > > + spinlock_t flc_lock; > > > > + struct list_head flc_flock; > > > > + struct list_head flc_posix; > > > > + struct list_head flc_lease; > > > > +}; > > > > + > > > > +#define locks_inode(f) file_inode(f) > > > > + > > > > +#ifdef CONFIG_FILE_LOCKING > > > > +extern int fcntl_getlk(struct file *, unsigned int, struct flock *= ); > > > > +extern int fcntl_setlk(unsigned int, struct file *, unsigned int, > > > > + struct flock *); > > > > + > > > > +#if BITS_PER_LONG =3D=3D 32 > > > > +extern int fcntl_getlk64(struct file *, unsigned int, struct flock= 64 *); > > > > +extern int fcntl_setlk64(unsigned int, struct file *, unsigned int= , > > > > + struct flock64 *); > > > > +#endif > > > > + > > > > +extern int fcntl_setlease(unsigned int fd, struct file *filp, long= arg); > > > > +extern int fcntl_getlease(struct file *filp); > > > > + > > > > +/* fs/locks.c */ > > > > +void locks_free_lock_context(struct inode *inode); > > > > +void locks_free_lock(struct file_lock *fl); > > > > +extern void locks_init_lock(struct file_lock *); > > > > +extern struct file_lock * locks_alloc_lock(void); > > > > +extern void locks_copy_lock(struct file_lock *, struct file_lock *= ); > > > > +extern void locks_copy_conflock(struct file_lock *, struct file_lo= ck *); > > > > +extern void locks_remove_posix(struct file *, fl_owner_t); > > > > +extern void locks_remove_file(struct file *); > > > > +extern void locks_release_private(struct file_lock *); > > > > +extern void posix_test_lock(struct file *, struct file_lock *); > > > > +extern int posix_lock_file(struct file *, struct file_lock *, stru= ct file_lock *); > > > > +extern int locks_delete_block(struct file_lock *); > > > > +extern int vfs_test_lock(struct file *, struct file_lock *); > > > > +extern int vfs_lock_file(struct file *, unsigned int, struct file_= lock *, struct file_lock *); > > > > +extern int vfs_cancel_lock(struct file *filp, struct file_lock *fl= ); > > > > +bool vfs_inode_has_locks(struct inode *inode); > > > > +extern int locks_lock_inode_wait(struct inode *inode, struct file_= lock *fl); > > > > +extern int __break_lease(struct inode *inode, unsigned int flags, = unsigned int type); > > > > +extern void lease_get_mtime(struct inode *, struct timespec64 *tim= e); > > > > +extern int generic_setlease(struct file *, long, struct file_lock = **, void **priv); > > > > +extern int vfs_setlease(struct file *, long, struct file_lock **, = void **); > > > > +extern int lease_modify(struct file_lock *, int, struct list_head = *); > > > > + > > > > +struct notifier_block; > > > > +extern int lease_register_notifier(struct notifier_block *); > > > > +extern void lease_unregister_notifier(struct notifier_block *); > > > > + > > > > +struct files_struct; > > > > +extern void show_fd_locks(struct seq_file *f, > > > > + struct file *filp, struct files_struct *files); > > > > +extern bool locks_owner_has_blockers(struct file_lock_context *flc= tx, > > > > + fl_owner_t owner); > > > > + > > > > +static inline struct file_lock_context * > > > > +locks_inode_context(const struct inode *inode) > > > > +{ > > > > + return smp_load_acquire(&inode->i_flctx); > > > > +} > > > > + > > > > +#else /* !CONFIG_FILE_LOCKING */ > > > > +static inline int fcntl_getlk(struct file *file, unsigned int cmd, > > > > + struct flock __user *user) > > > > +{ > > > > + return -EINVAL; > > > > +} > > > > + > > > > +static inline int fcntl_setlk(unsigned int fd, struct file *file, > > > > + unsigned int cmd, struct flock __user *user) > > > > +{ > > > > + return -EACCES; > > > > +} > > > > + > > > > +#if BITS_PER_LONG =3D=3D 32 > > > > +static inline int fcntl_getlk64(struct file *file, unsigned int cm= d, > > > > + struct flock64 *user) > > > > +{ > > > > + return -EINVAL; > > > > +} > > > > + > > > > +static inline int fcntl_setlk64(unsigned int fd, struct file *file= , > > > > + unsigned int cmd, struct flock64 *user) > > > > +{ > > > > + return -EACCES; > > > > +} > > > > +#endif > > > > +static inline int fcntl_setlease(unsigned int fd, struct file *fil= p, long arg) > > > > +{ > > > > + return -EINVAL; > > > > +} > > > > + > > > > +static inline int fcntl_getlease(struct file *filp) > > > > +{ > > > > + return F_UNLCK; > > > > +} > > > > + > > > > +static inline void > > > > +locks_free_lock_context(struct inode *inode) > > > > +{ > > > > +} > > > > + > > > > +static inline void locks_init_lock(struct file_lock *fl) > > > > +{ > > > > + return; > > > > +} > > > > + > > > > +static inline void locks_copy_conflock(struct file_lock *new, stru= ct file_lock *fl) > > > > +{ > > > > + return; > > > > +} > > > > + > > > > +static inline void locks_copy_lock(struct file_lock *new, struct f= ile_lock *fl) > > > > +{ > > > > + return; > > > > +} > > > > + > > > > +static inline void locks_remove_posix(struct file *filp, fl_owner_= t owner) > > > > +{ > > > > + return; > > > > +} > > > > + > > > > +static inline void locks_remove_file(struct file *filp) > > > > +{ > > > > + return; > > > > +} > > > > + > > > > +static inline void posix_test_lock(struct file *filp, struct file_= lock *fl) > > > > +{ > > > > + return; > > > > +} > > > > + > > > > +static inline int posix_lock_file(struct file *filp, struct file_l= ock *fl, > > > > + struct file_lock *conflock) > > > > +{ > > > > + return -ENOLCK; > > > > +} > > > > + > > > > +static inline int locks_delete_block(struct file_lock *waiter) > > > > +{ > > > > + return -ENOENT; > > > > +} > > > > + > > > > +static inline int vfs_test_lock(struct file *filp, struct file_loc= k *fl) > > > > +{ > > > > + return 0; > > > > +} > > > > + > > > > +static inline int vfs_lock_file(struct file *filp, unsigned int cm= d, > > > > + struct file_lock *fl, struct file_lock *conf) > > > > +{ > > > > + return -ENOLCK; > > > > +} > > > > + > > > > +static inline int vfs_cancel_lock(struct file *filp, struct file_l= ock *fl) > > > > +{ > > > > + return 0; > > > > +} > > > > + > > > > +static inline int locks_lock_inode_wait(struct inode *inode, struc= t file_lock *fl) > > > > +{ > > > > + return -ENOLCK; > > > > +} > > > > + > > > > +static inline int __break_lease(struct inode *inode, unsigned int = mode, unsigned int type) > > > > +{ > > > > + return 0; > > > > +} > > > > + > > > > +static inline void lease_get_mtime(struct inode *inode, > > > > + struct timespec64 *time) > > > > +{ > > > > + return; > > > > +} > > > > + > > > > +static inline int generic_setlease(struct file *filp, long arg, > > > > + struct file_lock **flp, void **priv) > > > > +{ > > > > + return -EINVAL; > > > > +} > > > > + > > > > +static inline int vfs_setlease(struct file *filp, long arg, > > > > + struct file_lock **lease, void **priv) > > > > +{ > > > > + return -EINVAL; > > > > +} > > > > + > > > > +static inline int lease_modify(struct file_lock *fl, int arg, > > > > + struct list_head *dispose) > > > > +{ > > > > + return -EINVAL; > > > > +} > > > > + > > > > +struct files_struct; > > > > +static inline void show_fd_locks(struct seq_file *f, > > > > + struct file *filp, struct files_struct *files) {} > > > > +static inline bool locks_owner_has_blockers(struct file_lock_conte= xt *flctx, > > > > + fl_owner_t owner) > > > > +{ > > > > + return false; > > > > +} > > > > + > > > > +static inline struct file_lock_context * > > > > +locks_inode_context(const struct inode *inode) > > > > +{ > > > > + return NULL; > > > > +} > > > > +#endif /* !CONFIG_FILE_LOCKING */ > > > > + > > > > +static inline int locks_lock_file_wait(struct file *filp, struct f= ile_lock *fl) > > > > +{ > > > > + return locks_lock_inode_wait(locks_inode(filp), fl); > > > > +} > > > > + > > > > +#ifdef CONFIG_FILE_LOCKING > > > > +static inline int break_lease(struct inode *inode, unsigned int mo= de) > > > > +{ > > > > + /* > > > > + * Since this check is lockless, we must ensure that any refcount= s > > > > + * taken are done before checking i_flctx->flc_lease. Otherwise, = we > > > > + * could end up racing with tasks trying to set a new lease on th= is > > > > + * file. > > > > + */ > > > > + smp_mb(); > > > > + if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_le= ase)) > > > > + return __break_lease(inode, mode, FL_LEASE); > > > > + return 0; > > > > +} > > > > + > > > > +static inline int break_deleg(struct inode *inode, unsigned int mo= de) > > > > +{ > > > > + /* > > > > + * Since this check is lockless, we must ensure that any refcount= s > > > > + * taken are done before checking i_flctx->flc_lease. Otherwise, = we > > > > + * could end up racing with tasks trying to set a new lease on th= is > > > > + * file. > > > > + */ > > > > + smp_mb(); > > > > + if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_le= ase)) > > > > + return __break_lease(inode, mode, FL_DELEG); > > > > + return 0; > > > > +} > > > > + > > > > +static inline int try_break_deleg(struct inode *inode, struct inod= e **delegated_inode) > > > > +{ > > > > + int ret; > > > > + > > > > + ret =3D break_deleg(inode, O_WRONLY|O_NONBLOCK); > > > > + if (ret =3D=3D -EWOULDBLOCK && delegated_inode) { > > > > + *delegated_inode =3D inode; > > > > + ihold(inode); > > > > + } > > > > + return ret; > > > > +} > > > > + > > > > +static inline int break_deleg_wait(struct inode **delegated_inode) > > > > +{ > > > > + int ret; > > > > + > > > > + ret =3D break_deleg(*delegated_inode, O_WRONLY); > > > > + iput(*delegated_inode); > > > > + *delegated_inode =3D NULL; > > > > + return ret; > > > > +} > > > > + > > > > +static inline int break_layout(struct inode *inode, bool wait) > > > > +{ > > > > + smp_mb(); > > > > + if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_le= ase)) > > > > + return __break_lease(inode, > > > > + wait ? O_WRONLY : O_WRONLY | O_NONBLOCK, > > > > + FL_LAYOUT); > > > > + return 0; > > > > +} > > > > + > > > > +#else /* !CONFIG_FILE_LOCKING */ > > > > +static inline int break_lease(struct inode *inode, unsigned int mo= de) > > > > +{ > > > > + return 0; > > > > +} > > > > + > > > > +static inline int break_deleg(struct inode *inode, unsigned int mo= de) > > > > +{ > > > > + return 0; > > > > +} > > > > + > > > > +static inline int try_break_deleg(struct inode *inode, struct inod= e **delegated_inode) > > > > +{ > > > > + return 0; > > > > +} > > > > + > > > > +static inline int break_deleg_wait(struct inode **delegated_inode) > > > > +{ > > > > + BUG(); > > > > + return 0; > > > > +} > > > > + > > > > +static inline int break_layout(struct inode *inode, bool wait) > > > > +{ > > > > + return 0; > > > > +} > > > > + > > > > +#endif /* CONFIG_FILE_LOCKING */ > > > > + > > > > +#endif /* _LINUX_FILELOCK_H */ > > > > diff --git a/include/linux/fs.h b/include/linux/fs.h > > > > index 092673178e13..63f355058ab5 100644 > > > > --- a/include/linux/fs.h > > > > +++ b/include/linux/fs.h > > > > @@ -1003,132 +1003,11 @@ static inline struct file *get_file(struct= file *f) > > > > #define MAX_LFS_FILESIZE ((loff_t)LLONG_MAX) > > > > #endif > > > > =20 > > > > -#define FL_POSIX 1 > > > > -#define FL_FLOCK 2 > > > > -#define FL_DELEG 4 /* NFSv4 delegation */ > > > > -#define FL_ACCESS 8 /* not trying to lock, just looking */ > > > > -#define FL_EXISTS 16 /* when unlocking, test for existence */ > > > > -#define FL_LEASE 32 /* lease held on this file */ > > > > -#define FL_CLOSE 64 /* unlock on close */ > > > > -#define FL_SLEEP 128 /* A blocking lock */ > > > > -#define FL_DOWNGRADE_PENDING 256 /* Lease is being downgraded */ > > > > -#define FL_UNLOCK_PENDING 512 /* Lease is being broken */ > > > > -#define FL_OFDLCK 1024 /* lock is "owned" by struct file */ > > > > -#define FL_LAYOUT 2048 /* outstanding pNFS layout */ > > > > -#define FL_RECLAIM 4096 /* reclaiming from a reboot server */ > > > > - > > > > -#define FL_CLOSE_POSIX (FL_POSIX | FL_CLOSE) > > > > - > > > > -/* > > > > - * Special return value from posix_lock_file() and vfs_lock_file()= for > > > > - * asynchronous locking. > > > > - */ > > > > -#define FILE_LOCK_DEFERRED 1 > > > > - > > > > /* legacy typedef, should eventually be removed */ > > > > typedef void *fl_owner_t; > > > > =20 > > > > struct file_lock; > > > > =20 > > > > -struct file_lock_operations { > > > > - void (*fl_copy_lock)(struct file_lock *, struct file_lock *); > > > > - void (*fl_release_private)(struct file_lock *); > > > > -}; > > > > - > > > > -struct lock_manager_operations { > > > > - void *lm_mod_owner; > > > > - fl_owner_t (*lm_get_owner)(fl_owner_t); > > > > - void (*lm_put_owner)(fl_owner_t); > > > > - void (*lm_notify)(struct file_lock *); /* unblock callback */ > > > > - int (*lm_grant)(struct file_lock *, int); > > > > - bool (*lm_break)(struct file_lock *); > > > > - int (*lm_change)(struct file_lock *, int, struct list_head *); > > > > - void (*lm_setup)(struct file_lock *, void **); > > > > - bool (*lm_breaker_owns_lease)(struct file_lock *); > > > > - bool (*lm_lock_expirable)(struct file_lock *cfl); > > > > - void (*lm_expire_lock)(void); > > > > -}; > > > > - > > > > -struct lock_manager { > > > > - struct list_head list; > > > > - /* > > > > - * NFSv4 and up also want opens blocked during the grace period; > > > > - * NLM doesn't care: > > > > - */ > > > > - bool block_opens; > > > > -}; > > > > - > > > > -struct net; > > > > -void locks_start_grace(struct net *, struct lock_manager *); > > > > -void locks_end_grace(struct lock_manager *); > > > > -bool locks_in_grace(struct net *); > > > > -bool opens_in_grace(struct net *); > > > > - > > > > -/* that will die - we need it for nfs_lock_info */ > > > > -#include > > > > - > > > > -/* > > > > - * struct file_lock represents a generic "file lock". It's used to= represent > > > > - * POSIX byte range locks, BSD (flock) locks, and leases. It's imp= ortant to > > > > - * note that the same struct is used to represent both a request f= or a lock and > > > > - * the lock itself, but the same object is never used for both. > > > > - * > > > > - * FIXME: should we create a separate "struct lock_request" to hel= p distinguish > > > > - * these two uses? > > > > - * > > > > - * The varous i_flctx lists are ordered by: > > > > - * > > > > - * 1) lock owner > > > > - * 2) lock range start > > > > - * 3) lock range end > > > > - * > > > > - * Obviously, the last two criteria only matter for POSIX locks. > > > > - */ > > > > -struct file_lock { > > > > - struct file_lock *fl_blocker; /* The lock, that is blocking us */ > > > > - struct list_head fl_list; /* link into file_lock_context */ > > > > - struct hlist_node fl_link; /* node in global lists */ > > > > - struct list_head fl_blocked_requests; /* list of requests with > > > > - * ->fl_blocker pointing here > > > > - */ > > > > - struct list_head fl_blocked_member; /* node in > > > > - * ->fl_blocker->fl_blocked_requests > > > > - */ > > > > - fl_owner_t fl_owner; > > > > - unsigned int fl_flags; > > > > - unsigned char fl_type; > > > > - unsigned int fl_pid; > > > > - int fl_link_cpu; /* what cpu's list is this on? */ > > > > - wait_queue_head_t fl_wait; > > > > - struct file *fl_file; > > > > - loff_t fl_start; > > > > - loff_t fl_end; > > > > - > > > > - struct fasync_struct * fl_fasync; /* for lease break notification= s */ > > > > - /* for lease breaks: */ > > > > - unsigned long fl_break_time; > > > > - unsigned long fl_downgrade_time; > > > > - > > > > - const struct file_lock_operations *fl_ops; /* Callbacks for files= ystems */ > > > > - const struct lock_manager_operations *fl_lmops; /* Callbacks for = lockmanagers */ > > > > - union { > > > > - struct nfs_lock_info nfs_fl; > > > > - struct nfs4_lock_info nfs4_fl; > > > > - struct { > > > > - struct list_head link; /* link in AFS vnode's pending_locks lis= t */ > > > > - int state; /* state of grant or error if -ve */ > > > > - unsigned int debug_id; > > > > - } afs; > > > > - } fl_u; > > > > -} __randomize_layout; > > > > - > > > > -struct file_lock_context { > > > > - spinlock_t flc_lock; > > > > - struct list_head flc_flock; > > > > - struct list_head flc_posix; > > > > - struct list_head flc_lease; > > > > -}; > > > > - > > > > /* The following constant reflects the upper bound of the file/loc= king space */ > > > > #ifndef OFFSET_MAX > > > > #define INT_LIMIT(x) (~((x)1 << (sizeof(x)*8 - 1))) > > > > @@ -1138,211 +1017,6 @@ struct file_lock_context { > > > > =20 > > > > extern void send_sigio(struct fown_struct *fown, int fd, int band)= ; > > > > =20 > > > > -#define locks_inode(f) file_inode(f) > > > > - > > > > -#ifdef CONFIG_FILE_LOCKING > > > > -extern int fcntl_getlk(struct file *, unsigned int, struct flock *= ); > > > > -extern int fcntl_setlk(unsigned int, struct file *, unsigned int, > > > > - struct flock *); > > > > - > > > > -#if BITS_PER_LONG =3D=3D 32 > > > > -extern int fcntl_getlk64(struct file *, unsigned int, struct flock= 64 *); > > > > -extern int fcntl_setlk64(unsigned int, struct file *, unsigned int= , > > > > - struct flock64 *); > > > > -#endif > > > > - > > > > -extern int fcntl_setlease(unsigned int fd, struct file *filp, long= arg); > > > > -extern int fcntl_getlease(struct file *filp); > > > > - > > > > -/* fs/locks.c */ > > > > -void locks_free_lock_context(struct inode *inode); > > > > -void locks_free_lock(struct file_lock *fl); > > > > -extern void locks_init_lock(struct file_lock *); > > > > -extern struct file_lock * locks_alloc_lock(void); > > > > -extern void locks_copy_lock(struct file_lock *, struct file_lock *= ); > > > > -extern void locks_copy_conflock(struct file_lock *, struct file_lo= ck *); > > > > -extern void locks_remove_posix(struct file *, fl_owner_t); > > > > -extern void locks_remove_file(struct file *); > > > > -extern void locks_release_private(struct file_lock *); > > > > -extern void posix_test_lock(struct file *, struct file_lock *); > > > > -extern int posix_lock_file(struct file *, struct file_lock *, stru= ct file_lock *); > > > > -extern int locks_delete_block(struct file_lock *); > > > > -extern int vfs_test_lock(struct file *, struct file_lock *); > > > > -extern int vfs_lock_file(struct file *, unsigned int, struct file_= lock *, struct file_lock *); > > > > -extern int vfs_cancel_lock(struct file *filp, struct file_lock *fl= ); > > > > -bool vfs_inode_has_locks(struct inode *inode); > > > > -extern int locks_lock_inode_wait(struct inode *inode, struct file_= lock *fl); > > > > -extern int __break_lease(struct inode *inode, unsigned int flags, = unsigned int type); > > > > -extern void lease_get_mtime(struct inode *, struct timespec64 *tim= e); > > > > -extern int generic_setlease(struct file *, long, struct file_lock = **, void **priv); > > > > -extern int vfs_setlease(struct file *, long, struct file_lock **, = void **); > > > > -extern int lease_modify(struct file_lock *, int, struct list_head = *); > > > > - > > > > -struct notifier_block; > > > > -extern int lease_register_notifier(struct notifier_block *); > > > > -extern void lease_unregister_notifier(struct notifier_block *); > > > > - > > > > -struct files_struct; > > > > -extern void show_fd_locks(struct seq_file *f, > > > > - struct file *filp, struct files_struct *files); > > > > -extern bool locks_owner_has_blockers(struct file_lock_context *flc= tx, > > > > - fl_owner_t owner); > > > > - > > > > -static inline struct file_lock_context * > > > > -locks_inode_context(const struct inode *inode) > > > > -{ > > > > - return smp_load_acquire(&inode->i_flctx); > > > > -} > > > > - > > > > -#else /* !CONFIG_FILE_LOCKING */ > > > > -static inline int fcntl_getlk(struct file *file, unsigned int cmd, > > > > - struct flock __user *user) > > > > -{ > > > > - return -EINVAL; > > > > -} > > > > - > > > > -static inline int fcntl_setlk(unsigned int fd, struct file *file, > > > > - unsigned int cmd, struct flock __user *user) > > > > -{ > > > > - return -EACCES; > > > > -} > > > > - > > > > -#if BITS_PER_LONG =3D=3D 32 > > > > -static inline int fcntl_getlk64(struct file *file, unsigned int cm= d, > > > > - struct flock64 *user) > > > > -{ > > > > - return -EINVAL; > > > > -} > > > > - > > > > -static inline int fcntl_setlk64(unsigned int fd, struct file *file= , > > > > - unsigned int cmd, struct flock64 *user) > > > > -{ > > > > - return -EACCES; > > > > -} > > > > -#endif > > > > -static inline int fcntl_setlease(unsigned int fd, struct file *fil= p, long arg) > > > > -{ > > > > - return -EINVAL; > > > > -} > > > > - > > > > -static inline int fcntl_getlease(struct file *filp) > > > > -{ > > > > - return F_UNLCK; > > > > -} > > > > - > > > > -static inline void > > > > -locks_free_lock_context(struct inode *inode) > > > > -{ > > > > -} > > > > - > > > > -static inline void locks_init_lock(struct file_lock *fl) > > > > -{ > > > > - return; > > > > -} > > > > - > > > > -static inline void locks_copy_conflock(struct file_lock *new, stru= ct file_lock *fl) > > > > -{ > > > > - return; > > > > -} > > > > - > > > > -static inline void locks_copy_lock(struct file_lock *new, struct f= ile_lock *fl) > > > > -{ > > > > - return; > > > > -} > > > > - > > > > -static inline void locks_remove_posix(struct file *filp, fl_owner_= t owner) > > > > -{ > > > > - return; > > > > -} > > > > - > > > > -static inline void locks_remove_file(struct file *filp) > > > > -{ > > > > - return; > > > > -} > > > > - > > > > -static inline void posix_test_lock(struct file *filp, struct file_= lock *fl) > > > > -{ > > > > - return; > > > > -} > > > > - > > > > -static inline int posix_lock_file(struct file *filp, struct file_l= ock *fl, > > > > - struct file_lock *conflock) > > > > -{ > > > > - return -ENOLCK; > > > > -} > > > > - > > > > -static inline int locks_delete_block(struct file_lock *waiter) > > > > -{ > > > > - return -ENOENT; > > > > -} > > > > - > > > > -static inline int vfs_test_lock(struct file *filp, struct file_loc= k *fl) > > > > -{ > > > > - return 0; > > > > -} > > > > - > > > > -static inline int vfs_lock_file(struct file *filp, unsigned int cm= d, > > > > - struct file_lock *fl, struct file_lock *conf) > > > > -{ > > > > - return -ENOLCK; > > > > -} > > > > - > > > > -static inline int vfs_cancel_lock(struct file *filp, struct file_l= ock *fl) > > > > -{ > > > > - return 0; > > > > -} > > > > - > > > > -static inline int locks_lock_inode_wait(struct inode *inode, struc= t file_lock *fl) > > > > -{ > > > > - return -ENOLCK; > > > > -} > > > > - > > > > -static inline int __break_lease(struct inode *inode, unsigned int = mode, unsigned int type) > > > > -{ > > > > - return 0; > > > > -} > > > > - > > > > -static inline void lease_get_mtime(struct inode *inode, > > > > - struct timespec64 *time) > > > > -{ > > > > - return; > > > > -} > > > > - > > > > -static inline int generic_setlease(struct file *filp, long arg, > > > > - struct file_lock **flp, void **priv) > > > > -{ > > > > - return -EINVAL; > > > > -} > > > > - > > > > -static inline int vfs_setlease(struct file *filp, long arg, > > > > - struct file_lock **lease, void **priv) > > > > -{ > > > > - return -EINVAL; > > > > -} > > > > - > > > > -static inline int lease_modify(struct file_lock *fl, int arg, > > > > - struct list_head *dispose) > > > > -{ > > > > - return -EINVAL; > > > > -} > > > > - > > > > -struct files_struct; > > > > -static inline void show_fd_locks(struct seq_file *f, > > > > - struct file *filp, struct files_struct *files) {} > > > > -static inline bool locks_owner_has_blockers(struct file_lock_conte= xt *flctx, > > > > - fl_owner_t owner) > > > > -{ > > > > - return false; > > > > -} > > > > - > > > > -static inline struct file_lock_context * > > > > -locks_inode_context(const struct inode *inode) > > > > -{ > > > > - return NULL; > > > > -} > > > > - > > > > -#endif /* !CONFIG_FILE_LOCKING */ > > > > - > > > > static inline struct inode *file_inode(const struct file *f) > > > > { > > > > return f->f_inode; > > > > @@ -1353,11 +1027,6 @@ static inline struct dentry *file_dentry(con= st struct file *file) > > > > return d_real(file->f_path.dentry, file_inode(file)); > > > > } > > > > =20 > > > > -static inline int locks_lock_file_wait(struct file *filp, struct f= ile_lock *fl) > > > > -{ > > > > - return locks_lock_inode_wait(locks_inode(filp), fl); > > > > -} > > > > - > > > > struct fasync_struct { > > > > rwlock_t fa_lock; > > > > int magic; > > > > @@ -2641,96 +2310,6 @@ extern struct kobject *fs_kobj; > > > > =20 > > > > #define MAX_RW_COUNT (INT_MAX & PAGE_MASK) > > > > =20 > > > > -#ifdef CONFIG_FILE_LOCKING > > > > -static inline int break_lease(struct inode *inode, unsigned int mo= de) > > > > -{ > > > > - /* > > > > - * Since this check is lockless, we must ensure that any refcount= s > > > > - * taken are done before checking i_flctx->flc_lease. Otherwise, = we > > > > - * could end up racing with tasks trying to set a new lease on th= is > > > > - * file. > > > > - */ > > > > - smp_mb(); > > > > - if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_le= ase)) > > > > - return __break_lease(inode, mode, FL_LEASE); > > > > - return 0; > > > > -} > > > > - > > > > -static inline int break_deleg(struct inode *inode, unsigned int mo= de) > > > > -{ > > > > - /* > > > > - * Since this check is lockless, we must ensure that any refcount= s > > > > - * taken are done before checking i_flctx->flc_lease. Otherwise, = we > > > > - * could end up racing with tasks trying to set a new lease on th= is > > > > - * file. > > > > - */ > > > > - smp_mb(); > > > > - if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_le= ase)) > > > > - return __break_lease(inode, mode, FL_DELEG); > > > > - return 0; > > > > -} > > > > - > > > > -static inline int try_break_deleg(struct inode *inode, struct inod= e **delegated_inode) > > > > -{ > > > > - int ret; > > > > - > > > > - ret =3D break_deleg(inode, O_WRONLY|O_NONBLOCK); > > > > - if (ret =3D=3D -EWOULDBLOCK && delegated_inode) { > > > > - *delegated_inode =3D inode; > > > > - ihold(inode); > > > > - } > > > > - return ret; > > > > -} > > > > - > > > > -static inline int break_deleg_wait(struct inode **delegated_inode) > > > > -{ > > > > - int ret; > > > > - > > > > - ret =3D break_deleg(*delegated_inode, O_WRONLY); > > > > - iput(*delegated_inode); > > > > - *delegated_inode =3D NULL; > > > > - return ret; > > > > -} > > > > - > > > > -static inline int break_layout(struct inode *inode, bool wait) > > > > -{ > > > > - smp_mb(); > > > > - if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_le= ase)) > > > > - return __break_lease(inode, > > > > - wait ? O_WRONLY : O_WRONLY | O_NONBLOCK, > > > > - FL_LAYOUT); > > > > - return 0; > > > > -} > > > > - > > > > -#else /* !CONFIG_FILE_LOCKING */ > > > > -static inline int break_lease(struct inode *inode, unsigned int mo= de) > > > > -{ > > > > - return 0; > > > > -} > > > > - > > > > -static inline int break_deleg(struct inode *inode, unsigned int mo= de) > > > > -{ > > > > - return 0; > > > > -} > > > > - > > > > -static inline int try_break_deleg(struct inode *inode, struct inod= e **delegated_inode) > > > > -{ > > > > - return 0; > > > > -} > > > > - > > > > -static inline int break_deleg_wait(struct inode **delegated_inode) > > > > -{ > > > > - BUG(); > > > > - return 0; > > > > -} > > > > - > > > > -static inline int break_layout(struct inode *inode, bool wait) > > > > -{ > > > > - return 0; > > > > -} > > > > - > > > > -#endif /* CONFIG_FILE_LOCKING */ > > > > - > > > > /* fs/open.c */ > > > > struct audit_names; > > > > struct filename { > > > > diff --git a/include/linux/lockd/xdr.h b/include/linux/lockd/xdr.h > > > > index 67e4a2c5500b..b60fbcd8cdfa 100644 > > > > --- a/include/linux/lockd/xdr.h > > > > +++ b/include/linux/lockd/xdr.h > > > > @@ -11,6 +11,7 @@ > > > > #define LOCKD_XDR_H > > > > =20 > > > > #include > > > > +#include > > > > #include > > > > #include > > > > =20 > > > > --=20 > > > > 2.38.1 > > > >=20 > >=20 > > --=20 > > Jeff Layton --=20 Jeff Layton