[PATCH 17/20] VFS/namei: handle LOOKUP_RCU in page_follow_link_light.

NeilBrown
2015-03-23T02:39:47Z

If the symlink has already be been read-in, then
page_follow_link_light can succeed in RCU-walk mode.
page_getlink_rcu() is added to support this.

With this, many filesystems can follow links in RCU-walk
mode when everything is cached. This includes ext?fs and
others.

If the page is a HighMem page we do *not* try to kmap_atomic,
but simply give up - only page_address() is used.
This is because we need to be able to sleep while holding
the address of the page, particularly over calls to do_last()
which can be quite slow and in particular takes a mutex.

If this were a problem, then copying into a GFP_ATOMIC allocation
might be a workable solution.

This selective calling of kmap requires us to know, in page_put_link,
whether or not kunmap() needs to be called. Pass this information in
the lsb of the cookie.

The new page_getlink_rcu() needs to be passed the inode rather than
the dentry (as dentry->d_inode is not stable), so change
page_getlink() to behave the same way: it only needed the dentry
to get the inode.

Signed-off-by: NeilBrown <neilb@suse.de>
---
fs/namei.c | 45 ++++++++++++++++++++++++++++++++++++---------
1 file changed, 36 insertions(+), 9 deletions(-)

diff --git a/fs/namei.c b/fs/namei.c
index 0f5b627bd78e..d13b4315447f 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -4497,24 +4497,48 @@ int generic_readlink(struct dentry *dentry, char __user *buffer, int buflen)
EXPORT_SYMBOL(generic_readlink);

/* get the link contents into pagecache */
-static char *page_getlink(struct dentry * dentry, struct page **ppage)
+static char *page_getlink(struct inode *inode, struct page **ppage)
{
char *kaddr;
struct page *page;
- struct address_space *mapping = dentry->d_inode->i_mapping;
+ struct address_space *mapping = inode->i_mapping;
page = read_mapping_page(mapping, 0, NULL);
if (IS_ERR(page))
return (char*)page;
*ppage = page;
kaddr = kmap(page);
- nd_terminate_link(kaddr, dentry->d_inode->i_size, PAGE_SIZE - 1);
+ nd_terminate_link(kaddr, inode->i_size, PAGE_SIZE - 1);
+ return kaddr;
+}
+
+/* get the link contents from pagecache under RCU */
+static char *page_getlink_rcu(struct inode *inode, struct page **ppage)
+{
+ char *kaddr;
+ struct page *page;
+ struct address_space *mapping = inode->i_mapping;
+
+ page = find_get_page(mapping, 0);
+ if (page &&
+ (!PageUptodate(page) || PageHighMem(page))) {
+ put_page(page);
+ page = NULL;
+ }
+ if (!page) {
+ *ppage = ERR_PTR(-ECHILD);
+ return NULL;
+ }
+ *ppage = page;
+ kaddr = page_address(page);
+ nd_terminate_link(kaddr, inode->i_size, PAGE_SIZE - 1);
return kaddr;
}

int page_readlink(struct dentry *dentry, char __user *buffer, int buflen)
{
struct page *page = NULL;
- int res = readlink_copy(buffer, buflen, page_getlink(dentry, &page));
+ int res = readlink_copy(buffer, buflen,
+ page_getlink(dentry->d_inode, &page));
if (page) {
kunmap(page);
page_cache_release(page);
@@ -4527,19 +4551,22 @@ void *page_follow_link_light(struct dentry *dentry, struct inode *inode,
int flags)
{
struct page *page = NULL;
- if (flags & LOOKUP_RCU)
- return ERR_PTR(-ECHILD);
- nd_set_link(page_getlink(dentry, &page));
+ if (flags & LOOKUP_RCU) {
+ nd_set_link(page_getlink_rcu(inode, &page));
+ page = (void *)((unsigned long)page | 1);
+ } else
+ nd_set_link(page_getlink(inode, &page));
return page;
}
EXPORT_SYMBOL(page_follow_link_light);

void page_put_link(struct dentry *dentry, char *link, void *cookie)
{
- struct page *page = cookie;
+ struct page *page = (void *)((unsigned long)cookie & ~1UL);

if (page) {
- kunmap(page);
+ if (page == cookie)
+ kunmap(page);
page_cache_release(page);
}
}