From mboxrd@z Thu Jan 1 00:00:00 1970 From: NeilBrown Subject: Re: [PATCH 0/9] Support follow_link in RCU-walk. Date: Mon, 9 Mar 2015 13:21:44 +1100 Message-ID: <20150309132144.7babc0a6@notabene.brown> References: <20150305051530.23906.65097.stgit@notabene.brown> <20150305060520.GY29656@ZenIV.linux.org.uk> Mime-Version: 1.0 Content-Type: multipart/signed; micalg=pgp-sha1; boundary="Sig_/1+7N8LKBlS2ykHwf+opgSta"; protocol="application/pgp-signature" Cc: linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org To: Al Viro Return-path: In-Reply-To: <20150305060520.GY29656@ZenIV.linux.org.uk> Sender: linux-kernel-owner@vger.kernel.org List-Id: linux-fsdevel.vger.kernel.org --Sig_/1+7N8LKBlS2ykHwf+opgSta Content-Type: text/plain; charset=US-ASCII Content-Transfer-Encoding: quoted-printable On Thu, 5 Mar 2015 06:05:20 +0000 Al Viro wrote: > On Thu, Mar 05, 2015 at 04:21:21PM +1100, NeilBrown wrote: > > Hi Al (and others), > >=20 > > I wonder if you could look over this patchset. > > It allows RCU-walk to follow symlinks in many common cases, > > thus removing a surprising performance hit caused by using symlinks. > >=20 > > The last could of patches make changes to XFS and NFS to support > > this but I haven't forwarded to the relevant lists yet. > > If/when the early code meets with approval I'll do that. > >=20 > > The first patch almost certainly needs to be changed. I originally > > wrote this code when filesystems could see inside nameidata. > > It is now opaque so the simplest solution was to provide an > > accessor function. > > Maybe I should as a 'flags' arg to ->follow_link?? Or have > > ->follow_link and ->follow_link_rcu ?? > > What do you suggest? >=20 > Umm... Some observations: > * now ->follow_link() can be called in RCU mode, which means > that it can race with fs shutdown; not a problem, except that now it > joins ->lookup() et.al. in "if some data structure is needed in RCU > case of that, make sure it's not destroyed without an RCU delay somewhere > between the entry into ->kill_sb() and destruction. So inodes and dentries and associated private data should already be safe. And s_fs_info can be used if it is freed by e.g. kfree_rcu (like autofs) but not if just kfree (like ext3). xfs_fs_put_super() directly frees the 'xfs_mount', which xfs_readlink accesses. I guess that needs to be fixed. > * highmem pages in symlinks: that BS shouldn't be allowed at > all. Just make sure that at least for those filesystems symlink inodes > get mapping_set_gfp_mask(&inode->i_data, GFP_KERNEL) and be done with tha= t. page_getlink() already uses kmap(), implying that highmem pages are supported. All I'm doing is making sure that my page_getlink_rcu() doesn't fail horribly if the page is a highmem page. If a filesystem needs improved follow_link performance on a highmem machine, then setting the gfp_mask as you suggest is probably a good idea, but I don= 't really want to impose that on filesystems if I don't need to. And at prese= nt I don't. So I'd rather leave it to the filesystem maintainer, or someone who discove= rs a need. > * are you sure that security_inode_follow_link() is OK to call in > RCU mode? No. avc_has_perm() doesn't look RCU safe, even without auditing enabled. At the very least we'll need to pass a "lookup_rcu" flag in there. > * what warranties are you giving for the lifetime of strings > passed to nd_set_link()? Right now it's "should not be freed until the > matching ->put_link()"; what happens for RCU mode? The same.... For XFS, we kmalloc a buffer GFP_ATOMIC and copy into that. Then put_link() kfrees it. For filesystems with the symlink in the page cache, we get a reference to the page (which is a bit heavy-handed for RCU-walk, but much less so than t= he current code) and drop the reference in ->put_link. For filesystems with a short symlink in the inode, we just provide a pointer to that... How long can we expect that to be around? I cannot see any provision for keeping those inodes in memory while we follow the symlink... What am I missing? In any case, if there is a reference held on the inode for ref-walk, then presumably complete_walk() will take a reference on that same inode when dropping out of rcu-walk.... I hope. So I think the rules here are unchanged. > * really nasty one: creat(2) on a dangling symlink. What's to > preserve the last component if you get into that symlink in RCU mode? As above - we will have a counted reference to whatever holds the text of t= he symlink. >=20 > TBH, I'm less than fond of passing nameidata to ->follow_link() at all, > flags or no flags. We could kill current->link_count and > current->total_link_count, replacing them with one void * current->nameid= ata > and taking counters into struct nameidata itself. Have places like e.g. > kern_path_locked() do > struct nameidata nd, *saved =3D set_nameidata(&nd); > ... > set_nameidata(saved); > with set_nameidata(p) doing this: > old =3D current->nameidata; > current->nameidata =3D p; > if (p) { > if (!old) { > p->link_count =3D 0; > p->total_link_count =3D 0; > } else { > p->link_count =3D old->link_count; > p->total_link_count =3D old->total_link_count; > } > } > return old; >=20 > Then nd_set_link() et.al. would use current->nameidata instead of an > explicitly passed pointer and ->follow_link() instances wouldn't need > that opaque pointer passed to them at all. Sounds interesting - I might try it. Would ->follow_link() than get a 'flags' argument, or would "nd_is_rcu()" reference current->nameidata->flags ?? Thanks, NeilBrown --Sig_/1+7N8LKBlS2ykHwf+opgSta Content-Type: application/pgp-signature Content-Description: OpenPGP digital signature -----BEGIN PGP SIGNATURE----- Version: GnuPG v2 iQIVAwUBVP0DuDnsnt1WYoG5AQIUEg//YF2et6gyfOJ6dPVDWXE2e7Nq8QlwpAHU ZpPegZvSQtYVMqr1wTBJVTyr6dH5N1K/R/IlU/yPMj1t2lFozRqpIgIf3nCZJjBJ UvStJJPyx10urbhKMEythu+Wgc52Ig4DOVHCu8ygAZBbbFYylHq8qN6wpZGagTEu ZOu+6iQ5dWl9CzNtA7FDCp6i9M3w8//vQZjnVYrGIP3dBuOK26VLxbXYuWc2Be8q KIiz/N0ueNLbd0e6kkeeBOi+Ms2w7k7spj6B9a5lK5ttUOIkxjuJw0N2p2pPdmVn tgabV3URyNLvp+wZ35BbviHJvY467Ipv914WPPmVnRclRlSdCEg3+rVZQqp65HN8 alAyqcDXUrM8oik0ZLThABtmy1WtNwGgGM437Tx95e8mgpbm4rRWXvPuREMyUmee W2QrmiJH+cdLeCCwgmu+1LIfZ1nWjJU1iA9Z3ytSd2WE53zkwdpRLw4gpi+mOSjI gdLozHr/dDghXDEWKJxvymPTrUngujh6Mk8zUuJy3un2LHY+jnmElvbbnsCvW4DH Y+wD4/wvPhJXqRsBd/dZSaUEq7kdqNomX207kixnbK2iia7X28ZYF9mQz30UPjfh Z18gPBTftKNA1/bkgkxIqF3hCx6NTA0wndYsP1SAlBdHLYWnZKyWJnx4s7OG7M5H XibA2w7RLvU= =DjdS -----END PGP SIGNATURE----- --Sig_/1+7N8LKBlS2ykHwf+opgSta--