Merge branch 'devel' into for-linus (cc859061) · Commits · e / devices / android_kernel_samsung_smdk4412

fs/lockd/clntlock.c

+1 −50

Original line number	Original line	Diff line number	Diff line
	@@ -139,55 +139,6 @@ int nlmclnt_block(struct nlm_wait block, struct nlm_rqst req, long timeout)
	return 0;		return 0;
	}		}

	#if defined(CONFIG_IPV6) \|\| defined(CONFIG_IPV6_MODULE)
	static const struct in6_addr nlmclnt_map_v4addr(const struct sockaddr sap,
	struct in6_addr *addr_mapped)
	{
	const struct sockaddr_in sin = (const struct sockaddr_in )sap;

	switch (sap->sa_family) {
	case AF_INET6:
	return &((const struct sockaddr_in6 *)sap)->sin6_addr;
	case AF_INET:
	ipv6_addr_set_v4mapped(sin->sin_addr.s_addr, addr_mapped);
	return addr_mapped;
	}

	return NULL;
	}

	/*
	* If lockd is using a PF_INET6 listener, all incoming requests appear
	* to come from AF_INET6 remotes. The address of AF_INET remotes are
	* mapped to AF_INET6 automatically by the network layer. In case the
	* user passed an AF_INET server address at mount time, ensure both
	* addresses are AF_INET6 before comparing them.
	*/
	static int nlmclnt_cmp_addr(const struct nlm_host *host,
	const struct sockaddr *sap)
	{
	const struct in6_addr *addr1;
	const struct in6_addr *addr2;
	struct in6_addr addr1_mapped;
	struct in6_addr addr2_mapped;

	addr1 = nlmclnt_map_v4addr(nlm_addr(host), &addr1_mapped);
	if (likely(addr1 != NULL)) {
	addr2 = nlmclnt_map_v4addr(sap, &addr2_mapped);
	if (likely(addr2 != NULL))
	return ipv6_addr_equal(addr1, addr2);
	}

	return 0;
	}
	#else /* !(CONFIG_IPV6 \|\| CONFIG_IPV6_MODULE) */
	static int nlmclnt_cmp_addr(const struct nlm_host *host,
	const struct sockaddr *sap)
	{
	return nlm_cmp_addr(nlm_addr(host), sap);
	}
	#endif /* !(CONFIG_IPV6 \|\| CONFIG_IPV6_MODULE) */

	/*		/*
	* The server lockd has called us back to tell us the lock was granted		* The server lockd has called us back to tell us the lock was granted
	*/		*/
	@@ -215,7 +166,7 @@ __be32 nlmclnt_grant(const struct sockaddr addr, const struct nlm_lock lock)
	*/		*/
	if (fl_blocked->fl_u.nfs_fl.owner->pid != lock->svid)		if (fl_blocked->fl_u.nfs_fl.owner->pid != lock->svid)
	continue;		continue;
	if (!nlmclnt_cmp_addr(block->b_host, addr))		if (!nlm_cmp_addr(nlm_addr(block->b_host), addr))
	continue;		continue;
	if (nfs_compare_fh(NFS_FH(fl_blocked->fl_file->f_path.dentry->d_inode) ,fh) != 0)		if (nfs_compare_fh(NFS_FH(fl_blocked->fl_file->f_path.dentry->d_inode) ,fh) != 0)
	continue;		continue;

fs/lockd/mon.c

+6 −2

Original line number	Original line	Diff line number	Diff line
	@@ -16,6 +16,8 @@
	#include <linux/sunrpc/svc.h>		#include <linux/sunrpc/svc.h>
	#include <linux/lockd/lockd.h>		#include <linux/lockd/lockd.h>

			#include <asm/unaligned.h>

	#define NLMDBG_FACILITY NLMDBG_MONITOR		#define NLMDBG_FACILITY NLMDBG_MONITOR
	#define NSM_PROGRAM 100024		#define NSM_PROGRAM 100024
	#define NSM_VERSION 1		#define NSM_VERSION 1
	@@ -274,10 +276,12 @@ static void nsm_init_private(struct nsm_handle *nsm)
	{		{
	u64 p = (u64 )&nsm->sm_priv.data;		u64 p = (u64 )&nsm->sm_priv.data;
	struct timespec ts;		struct timespec ts;
			s64 ns;

	ktime_get_ts(&ts);		ktime_get_ts(&ts);
	*p++ = timespec_to_ns(&ts);		ns = timespec_to_ns(&ts);
	*p = (unsigned long)nsm;		put_unaligned(ns, p);
			put_unaligned((unsigned long)nsm, p + 1);
	}		}

	static struct nsm_handle nsm_create_handle(const struct sockaddr sap,		static struct nsm_handle nsm_create_handle(const struct sockaddr sap,

fs/lockd/svc.c

+22 −20

Original line number	Original line	Diff line number	Diff line
	@@ -52,17 +52,6 @@ static struct task_struct *nlmsvc_task;
	static struct svc_rqst *nlmsvc_rqst;		static struct svc_rqst *nlmsvc_rqst;
	unsigned long nlmsvc_timeout;		unsigned long nlmsvc_timeout;

	/*
	* If the kernel has IPv6 support available, always listen for
	* both AF_INET and AF_INET6 requests.
	*/
	#if (defined(CONFIG_IPV6) \|\| defined(CONFIG_IPV6_MODULE)) && \
	defined(CONFIG_SUNRPC_REGISTER_V4)
	static const sa_family_t nlmsvc_family = AF_INET6;
	#else /* (CONFIG_IPV6 \|\| CONFIG_IPV6_MODULE) && CONFIG_SUNRPC_REGISTER_V4 */
	static const sa_family_t nlmsvc_family = AF_INET;
	#endif /* (CONFIG_IPV6 \|\| CONFIG_IPV6_MODULE) && CONFIG_SUNRPC_REGISTER_V4 */

	/*		/*
	* These can be set at insmod time (useful for NFS as root filesystem),		* These can be set at insmod time (useful for NFS as root filesystem),
	* and also changed through the sysctl interface. -- Jamie Lokier, Aug 2003		* and also changed through the sysctl interface. -- Jamie Lokier, Aug 2003
	@@ -204,19 +193,30 @@ lockd(void *vrqstp)
	return 0;		return 0;
	}		}

	static int create_lockd_listener(struct svc_serv serv, char name,		static int create_lockd_listener(struct svc_serv serv, const char name,
	unsigned short port)		const int family, const unsigned short port)
	{		{
	struct svc_xprt *xprt;		struct svc_xprt *xprt;

	xprt = svc_find_xprt(serv, name, 0, 0);		xprt = svc_find_xprt(serv, name, family, 0);
	if (xprt == NULL)		if (xprt == NULL)
	return svc_create_xprt(serv, name, port, SVC_SOCK_DEFAULTS);		return svc_create_xprt(serv, name, family, port,
			SVC_SOCK_DEFAULTS);
	svc_xprt_put(xprt);		svc_xprt_put(xprt);
	return 0;		return 0;
	}		}

			static int create_lockd_family(struct svc_serv *serv, const int family)
			{
			int err;

			err = create_lockd_listener(serv, "udp", family, nlm_udpport);
			if (err < 0)
			return err;

			return create_lockd_listener(serv, "tcp", family, nlm_tcpport);
			}

	/*		/*
	* Ensure there are active UDP and TCP listeners for lockd.		* Ensure there are active UDP and TCP listeners for lockd.
	*		*
	@@ -232,13 +232,15 @@ static int make_socks(struct svc_serv *serv)
	static int warned;		static int warned;
	int err;		int err;

	err = create_lockd_listener(serv, "udp", nlm_udpport);		err = create_lockd_family(serv, PF_INET);
	if (err < 0)		if (err < 0)
	goto out_err;		goto out_err;

	err = create_lockd_listener(serv, "tcp", nlm_tcpport);		#if defined(CONFIG_IPV6) \|\| defined(CONFIG_IPV6_MODULE)
	if (err < 0)		err = create_lockd_family(serv, PF_INET6);
			if (err < 0 && err != -EAFNOSUPPORT)
	goto out_err;		goto out_err;
			#endif /* CONFIG_IPV6 \|\| CONFIG_IPV6_MODULE */

	warned = 0;		warned = 0;
	return 0;		return 0;
	@@ -274,7 +276,7 @@ int lockd_up(void)
	"lockd_up: no pid, %d users??\n", nlmsvc_users);		"lockd_up: no pid, %d users??\n", nlmsvc_users);

	error = -ENOMEM;		error = -ENOMEM;
	serv = svc_create(&nlmsvc_program, LOCKD_BUFSIZE, nlmsvc_family, NULL);		serv = svc_create(&nlmsvc_program, LOCKD_BUFSIZE, NULL);
	if (!serv) {		if (!serv) {
	printk(KERN_WARNING "lockd_up: create service failed\n");		printk(KERN_WARNING "lockd_up: create service failed\n");
	goto out;		goto out;

fs/nfs/callback.c

+16 −15

Original line number	Original line	Diff line number	Diff line
	@@ -38,19 +38,10 @@ static struct svc_program nfs4_callback_program;

	unsigned int nfs_callback_set_tcpport;		unsigned int nfs_callback_set_tcpport;
	unsigned short nfs_callback_tcpport;		unsigned short nfs_callback_tcpport;
			unsigned short nfs_callback_tcpport6;
	static const int nfs_set_port_min = 0;		static const int nfs_set_port_min = 0;
	static const int nfs_set_port_max = 65535;		static const int nfs_set_port_max = 65535;

	/*
	* If the kernel has IPv6 support available, always listen for
	* both AF_INET and AF_INET6 requests.
	*/
	#if defined(CONFIG_IPV6) \|\| defined(CONFIG_IPV6_MODULE)
	static const sa_family_t nfs_callback_family = AF_INET6;
	#else
	static const sa_family_t nfs_callback_family = AF_INET;
	#endif

	static int param_set_port(const char val, struct kernel_param kp)		static int param_set_port(const char val, struct kernel_param kp)
	{		{
	char *endp;		char *endp;
	@@ -116,19 +107,29 @@ int nfs_callback_up(void)
	mutex_lock(&nfs_callback_mutex);		mutex_lock(&nfs_callback_mutex);
	if (nfs_callback_info.users++ \|\| nfs_callback_info.task != NULL)		if (nfs_callback_info.users++ \|\| nfs_callback_info.task != NULL)
	goto out;		goto out;
	serv = svc_create(&nfs4_callback_program, NFS4_CALLBACK_BUFSIZE,		serv = svc_create(&nfs4_callback_program, NFS4_CALLBACK_BUFSIZE, NULL);
	nfs_callback_family, NULL);
	ret = -ENOMEM;		ret = -ENOMEM;
	if (!serv)		if (!serv)
	goto out_err;		goto out_err;

	ret = svc_create_xprt(serv, "tcp", nfs_callback_set_tcpport,		ret = svc_create_xprt(serv, "tcp", PF_INET,
	SVC_SOCK_ANONYMOUS);		nfs_callback_set_tcpport, SVC_SOCK_ANONYMOUS);
	if (ret <= 0)		if (ret <= 0)
	goto out_err;		goto out_err;
	nfs_callback_tcpport = ret;		nfs_callback_tcpport = ret;
	dprintk("NFS: Callback listener port = %u (af %u)\n",		dprintk("NFS: Callback listener port = %u (af %u)\n",
	nfs_callback_tcpport, nfs_callback_family);		nfs_callback_tcpport, PF_INET);

			#if defined(CONFIG_IPV6) \|\| defined(CONFIG_IPV6_MODULE)
			ret = svc_create_xprt(serv, "tcp", PF_INET6,
			nfs_callback_set_tcpport, SVC_SOCK_ANONYMOUS);
			if (ret > 0) {
			nfs_callback_tcpport6 = ret;
			dprintk("NFS: Callback listener port = %u (af %u)\n",
			nfs_callback_tcpport6, PF_INET6);
			} else if (ret != -EAFNOSUPPORT)
			goto out_err;
			#endif /* defined(CONFIG_IPV6) \|\| defined(CONFIG_IPV6_MODULE) */

	nfs_callback_info.rqst = svc_prepare_thread(serv, &serv->sv_pools[0]);		nfs_callback_info.rqst = svc_prepare_thread(serv, &serv->sv_pools[0]);
	if (IS_ERR(nfs_callback_info.rqst)) {		if (IS_ERR(nfs_callback_info.rqst)) {

fs/nfs/callback.h

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -72,5 +72,6 @@ extern void nfs_callback_down(void);

	extern unsigned int nfs_callback_set_tcpport;		extern unsigned int nfs_callback_set_tcpport;
	extern unsigned short nfs_callback_tcpport;		extern unsigned short nfs_callback_tcpport;
			extern unsigned short nfs_callback_tcpport6;

	#endif /* __LINUX_FS_NFS_CALLBACK_H */		#endif /* __LINUX_FS_NFS_CALLBACK_H */