Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit e571cbf1 authored by Trond Myklebust's avatar Trond Myklebust
Browse files

NFS: Add a dns resolver for use with NFSv4 referrals and migration 



The NFSv4 and NFSv4.1 protocols both allow for the redirection of a client
from one server to another in order to support filesystem migration and
replication. For full protocol support, we need to add the ability to
convert a DNS host name into an IP address that we can feed to the RPC
client.

We'll reuse the sunrpc cache, now that it has been converted to work with
rpc_pipefs.

Signed-off-by: default avatarTrond Myklebust <Trond.Myklebust@netapp.com>
parent 96c61cbd

Documentation/filesystems/nfs.txt

0 → 100644
+98 −0
Original line number Diff line number Diff line 


The NFS client

==============



The NFS version 2 protocol was first documented in RFC1094 (March 1989).

Since then two more major releases of NFS have been published, with NFSv3

being documented in RFC1813 (June 1995), and NFSv4 in RFC3530 (April

2003).



The Linux NFS client currently supports all the above published versions,

and work is in progress on adding support for minor version 1 of the NFSv4

protocol.



The purpose of this document is to provide information on some of the

upcall interfaces that are used in order to provide the NFS client with

some of the information that it requires in order to fully comply with

the NFS spec.



The DNS resolver

================



NFSv4 allows for one server to refer the NFS client to data that has been

migrated onto another server by means of the special "fs_locations"

attribute. See

	http://tools.ietf.org/html/rfc3530#section-6

and

	http://tools.ietf.org/html/draft-ietf-nfsv4-referrals-00



The fs_locations information can take the form of either an ip address and

a path, or a DNS hostname and a path. The latter requires the NFS client to

do a DNS lookup in order to mount the new volume, and hence the need for an

upcall to allow userland to provide this service.



Assuming that the user has the 'rpc_pipefs' filesystem mounted in the usual

/var/lib/nfs/rpc_pipefs, the upcall consists of the following steps:



   (1) The process checks the dns_resolve cache to see if it contains a

       valid entry. If so, it returns that entry and exits.



   (2) If no valid entry exists, the helper script '/sbin/nfs_cache_getent'

       (may be changed using the 'nfs.cache_getent' kernel boot parameter)

       is run, with two arguments:

		- the cache name, "dns_resolve"

		- the hostname to resolve



   (3) After looking up the corresponding ip address, the helper script

       writes the result into the rpc_pipefs pseudo-file

       '/var/lib/nfs/rpc_pipefs/cache/dns_resolve/channel'

       in the following (text) format:



		"<ip address> <hostname> <ttl>\n"



       Where <ip address> is in the usual IPv4 (123.456.78.90) or IPv6

       (ffee:ddcc:bbaa:9988:7766:5544:3322:1100, ffee::1100, ...) format.

       <hostname> is identical to the second argument of the helper

       script, and <ttl> is the 'time to live' of this cache entry (in

       units of seconds).



       Note: If <ip address> is invalid, say the string "0", then a negative

       entry is created, which will cause the kernel to treat the hostname

       as having no valid DNS translation.









A basic sample /sbin/nfs_cache_getent

=====================================



#!/bin/bash

#

ttl=600

#

cut=/usr/bin/cut

getent=/usr/bin/getent

rpc_pipefs=/var/lib/nfs/rpc_pipefs

#

die()

{

	echo "Usage: $0 cache_name entry_name"

	exit 1

}



[ $# -lt 2 ] && die

cachename="$1"

cache_path=${rpc_pipefs}/cache/${cachename}/channel



case "${cachename}" in

	dns_resolve)

		name="$2"

		result="$(${getent} hosts ${name} | ${cut} -f1 -d\ )"

		[ -z "${result}" ] && result="0"

		;;

	*)

		die

		;;

esac

echo "${result} ${name} ${ttl}" >${cache_path}

Documentation/kernel-parameters.txt

+8 −0
Original line number Diff line number Diff line
@@ -1503,6 +1503,14 @@ and is between 256 and 4096 characters. It is defined in the file 
			[NFS] set the TCP port on which the NFSv4 callback

			channel should listen.



	nfs.cache_getent=

			[NFS] sets the pathname to the program which is used

			to update the NFS client cache entries.



	nfs.cache_getent_timeout=

			[NFS] sets the timeout after which an attempt to

			update a cache entry is deemed to have failed.



	nfs.idmap_cache_timeout=

			[NFS] set the maximum lifetime for idmapper cache

			entries.

fs/nfs/Makefile

+2 −1
Original line number Diff line number Diff line
@@ -6,7 +6,8 @@ obj-$(CONFIG_NFS_FS) += nfs.o 


nfs-y 			:= client.o dir.o file.o getroot.o inode.o super.o nfs2xdr.o \

			   direct.o pagelist.o proc.o read.o symlink.o unlink.o \

			   write.o namespace.o mount_clnt.o

			   write.o namespace.o mount_clnt.o \

			   dns_resolve.o cache_lib.o

nfs-$(CONFIG_ROOT_NFS)	+= nfsroot.o

nfs-$(CONFIG_NFS_V3)	+= nfs3proc.o nfs3xdr.o

nfs-$(CONFIG_NFS_V3_ACL)	+= nfs3acl.o

fs/nfs/cache_lib.c

0 → 100644
+140 −0
Original line number Diff line number Diff line 
/*

 * linux/fs/nfs/cache_lib.c

 *

 * Helper routines for the NFS client caches

 *

 * Copyright (c) 2009 Trond Myklebust <Trond.Myklebust@netapp.com>

 */

#include <linux/kmod.h>

#include <linux/module.h>

#include <linux/moduleparam.h>

#include <linux/mount.h>

#include <linux/namei.h>

#include <linux/sunrpc/cache.h>

#include <linux/sunrpc/rpc_pipe_fs.h>



#include "cache_lib.h"



#define NFS_CACHE_UPCALL_PATHLEN 256

#define NFS_CACHE_UPCALL_TIMEOUT 15



static char nfs_cache_getent_prog[NFS_CACHE_UPCALL_PATHLEN] =

				"/sbin/nfs_cache_getent";

static unsigned long nfs_cache_getent_timeout = NFS_CACHE_UPCALL_TIMEOUT;



module_param_string(cache_getent, nfs_cache_getent_prog,

		sizeof(nfs_cache_getent_prog), 0600);

MODULE_PARM_DESC(cache_getent, "Path to the client cache upcall program");

module_param_named(cache_getent_timeout, nfs_cache_getent_timeout, ulong, 0600);

MODULE_PARM_DESC(cache_getent_timeout, "Timeout (in seconds) after which "

		"the cache upcall is assumed to have failed");



int nfs_cache_upcall(struct cache_detail *cd, char *entry_name)

{

	static char *envp[] = { "HOME=/",

		"TERM=linux",

		"PATH=/sbin:/usr/sbin:/bin:/usr/bin",

		NULL

	};

	char *argv[] = {

		nfs_cache_getent_prog,

		cd->name,

		entry_name,

		NULL

	};

	int ret = -EACCES;



	if (nfs_cache_getent_prog[0] == '\0')

		goto out;

	ret = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_EXEC);

	/*

	 * Disable the upcall mechanism if we're getting an ENOENT or

	 * EACCES error. The admin can re-enable it on the fly by using

	 * sysfs to set the 'cache_getent' parameter once the problem

	 * has been fixed.

	 */

	if (ret == -ENOENT || ret == -EACCES)

		nfs_cache_getent_prog[0] = '\0';

out:

	return ret > 0 ? 0 : ret;

}



/*

 * Deferred request handling

 */

void nfs_cache_defer_req_put(struct nfs_cache_defer_req *dreq)

{

	if (atomic_dec_and_test(&dreq->count))

		kfree(dreq);

}



static void nfs_dns_cache_revisit(struct cache_deferred_req *d, int toomany)

{

	struct nfs_cache_defer_req *dreq;



	dreq = container_of(d, struct nfs_cache_defer_req, deferred_req);



	complete_all(&dreq->completion);

	nfs_cache_defer_req_put(dreq);

}



static struct cache_deferred_req *nfs_dns_cache_defer(struct cache_req *req)

{

	struct nfs_cache_defer_req *dreq;



	dreq = container_of(req, struct nfs_cache_defer_req, req);

	dreq->deferred_req.revisit = nfs_dns_cache_revisit;

	atomic_inc(&dreq->count);



	return &dreq->deferred_req;

}



struct nfs_cache_defer_req *nfs_cache_defer_req_alloc(void)

{

	struct nfs_cache_defer_req *dreq;



	dreq = kzalloc(sizeof(*dreq), GFP_KERNEL);

	if (dreq) {

		init_completion(&dreq->completion);

		atomic_set(&dreq->count, 1);

		dreq->req.defer = nfs_dns_cache_defer;

	}

	return dreq;

}



int nfs_cache_wait_for_upcall(struct nfs_cache_defer_req *dreq)

{

	if (wait_for_completion_timeout(&dreq->completion,

			nfs_cache_getent_timeout * HZ) == 0)

		return -ETIMEDOUT;

	return 0;

}



int nfs_cache_register(struct cache_detail *cd)

{

	struct nameidata nd;

	struct vfsmount *mnt;

	int ret;



	mnt = rpc_get_mount();

	if (IS_ERR(mnt))

		return PTR_ERR(mnt);

	ret = vfs_path_lookup(mnt->mnt_root, mnt, "/cache", 0, &nd);

	if (ret)

		goto err;

	ret = sunrpc_cache_register_pipefs(nd.path.dentry,

			cd->name, 0600, cd);

	path_put(&nd.path);

	if (!ret)

		return ret;

err:

	rpc_put_mount();

	return ret;

}



void nfs_cache_unregister(struct cache_detail *cd)

{

	sunrpc_cache_unregister_pipefs(cd);

	rpc_put_mount();

}

fs/nfs/cache_lib.h

0 → 100644
+27 −0
Original line number Diff line number Diff line 
/*

 * Helper routines for the NFS client caches

 *

 * Copyright (c) 2009 Trond Myklebust <Trond.Myklebust@netapp.com>

 */



#include <linux/completion.h>

#include <linux/sunrpc/cache.h>

#include <asm/atomic.h>



/*

 * Deferred request handling

 */

struct nfs_cache_defer_req {

	struct cache_req req;

	struct cache_deferred_req deferred_req;

	struct completion completion;

	atomic_t count;

};



extern int nfs_cache_upcall(struct cache_detail *cd, char *entry_name);

extern struct nfs_cache_defer_req *nfs_cache_defer_req_alloc(void);

extern void nfs_cache_defer_req_put(struct nfs_cache_defer_req *dreq);

extern int nfs_cache_wait_for_upcall(struct nfs_cache_defer_req *dreq);



extern int nfs_cache_register(struct cache_detail *cd);

extern void nfs_cache_unregister(struct cache_detail *cd);