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

Commit b9d919a4 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'nfs-for-2.6.38' of git://git.linux-nfs.org/projects/trondmy/nfs-2.6 

* 'nfs-for-2.6.38' of git://git.linux-nfs.org/projects/trondmy/nfs-2.6: (89 commits)
  NFS fix the setting of exchange id flag
  NFS: Don't use vm_map_ram() in readdir
  NFSv4: Ensure continued open and lockowner name uniqueness
  NFS: Move cl_delegations to the nfs_server struct
  NFS: Introduce nfs_detach_delegations()
  NFS: Move cl_state_owners and related fields to the nfs_server struct
  NFS: Allow walking nfs_client.cl_superblocks list outside client.c
  pnfs: layout roc code
  pnfs: update nfs4_callback_recallany to handle layouts
  pnfs: add CB_LAYOUTRECALL handling
  pnfs: CB_LAYOUTRECALL xdr code
  pnfs: change lo refcounting to atomic_t
  pnfs: check that partial LAYOUTGET return is ignored
  pnfs: add layout to client list before sending rpc
  pnfs: serialize LAYOUTGET(openstateid)
  pnfs: layoutget rpc code cleanup
  pnfs: change how lsegs are removed from layout list
  pnfs: change layout state seqlock to a spinlock
  pnfs: add prefix to struct pnfs_layout_hdr fields
  pnfs: add prefix to struct pnfs_layout_segment fields
  ...
parents 7c955fca 357f54d6

fs/lockd/Makefile

+3 −3
Original line number Original line Diff line number Diff line
@@ -4,7 +4,7 @@ 




obj-$(CONFIG_LOCKD) += lockd.o

obj-$(CONFIG_LOCKD) += lockd.o





lockd-objs-y := clntlock.o clntproc.o host.o svc.o svclock.o svcshare.o \

lockd-objs-y := clntlock.o clntproc.o clntxdr.o host.o svc.o svclock.o \

	        svcproc.o svcsubs.o mon.o xdr.o grace.o

	        svcshare.o svcproc.o svcsubs.o mon.o xdr.o grace.o

lockd-objs-$(CONFIG_LOCKD_V4) += xdr4.o svc4proc.o

lockd-objs-$(CONFIG_LOCKD_V4) += clnt4xdr.o xdr4.o svc4proc.o

lockd-objs		      := $(lockd-objs-y)
 
lockd-objs		      := $(lockd-objs-y)

fs/lockd/clnt4xdr.c

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

 * linux/fs/lockd/clnt4xdr.c

 *

 * XDR functions to encode/decode NLM version 4 RPC arguments and results.

 *

 * NLM client-side only.

 *

 * Copyright (C) 2010, Oracle.  All rights reserved.

 */



#include <linux/types.h>

#include <linux/sunrpc/xdr.h>

#include <linux/sunrpc/clnt.h>

#include <linux/sunrpc/stats.h>

#include <linux/lockd/lockd.h>



#define NLMDBG_FACILITY		NLMDBG_XDR



#if (NLMCLNT_OHSIZE > XDR_MAX_NETOBJ)

#  error "NLM host name cannot be larger than XDR_MAX_NETOBJ!"

#endif



#if (NLMCLNT_OHSIZE > NLM_MAXSTRLEN)

#  error "NLM host name cannot be larger than NLM's maximum string length!"

#endif



/*

 * Declare the space requirements for NLM arguments and replies as

 * number of 32bit-words

 */

#define NLM4_void_sz		(0)

#define NLM4_cookie_sz		(1+(NLM_MAXCOOKIELEN>>2))

#define NLM4_caller_sz		(1+(NLMCLNT_OHSIZE>>2))

#define NLM4_owner_sz		(1+(NLMCLNT_OHSIZE>>2))

#define NLM4_fhandle_sz		(1+(NFS3_FHSIZE>>2))

#define NLM4_lock_sz		(5+NLM4_caller_sz+NLM4_owner_sz+NLM4_fhandle_sz)

#define NLM4_holder_sz		(6+NLM4_owner_sz)



#define NLM4_testargs_sz	(NLM4_cookie_sz+1+NLM4_lock_sz)

#define NLM4_lockargs_sz	(NLM4_cookie_sz+4+NLM4_lock_sz)

#define NLM4_cancargs_sz	(NLM4_cookie_sz+2+NLM4_lock_sz)

#define NLM4_unlockargs_sz	(NLM4_cookie_sz+NLM4_lock_sz)



#define NLM4_testres_sz		(NLM4_cookie_sz+1+NLM4_holder_sz)

#define NLM4_res_sz		(NLM4_cookie_sz+1)

#define NLM4_norep_sz		(0)





static s64 loff_t_to_s64(loff_t offset)

{

	s64 res;



	if (offset >= NLM4_OFFSET_MAX)

		res = NLM4_OFFSET_MAX;

	else if (offset <= -NLM4_OFFSET_MAX)

		res = -NLM4_OFFSET_MAX;

	else

		res = offset;

	return res;

}



static void nlm4_compute_offsets(const struct nlm_lock *lock,

				 u64 *l_offset, u64 *l_len)

{

	const struct file_lock *fl = &lock->fl;



	BUG_ON(fl->fl_start > NLM4_OFFSET_MAX);

	BUG_ON(fl->fl_end > NLM4_OFFSET_MAX &&

				fl->fl_end != OFFSET_MAX);



	*l_offset = loff_t_to_s64(fl->fl_start);

	if (fl->fl_end == OFFSET_MAX)

		*l_len = 0;

	else

		*l_len = loff_t_to_s64(fl->fl_end - fl->fl_start + 1);

}



/*

 * Handle decode buffer overflows out-of-line.

 */

static void print_overflow_msg(const char *func, const struct xdr_stream *xdr)

{

	dprintk("lockd: %s prematurely hit the end of our receive buffer. "

		"Remaining buffer length is %tu words.\n",

		func, xdr->end - xdr->p);

}





/*

 * Encode/decode NLMv4 basic data types

 *

 * Basic NLMv4 data types are defined in Appendix II, section 6.1.4

 * of RFC 1813: "NFS Version 3 Protocol Specification" and in Chapter

 * 10 of X/Open's "Protocols for Interworking: XNFS, Version 3W".

 *

 * Not all basic data types have their own encoding and decoding

 * functions.  For run-time efficiency, some data types are encoded

 * or decoded inline.

 */



static void encode_bool(struct xdr_stream *xdr, const int value)

{

	__be32 *p;



	p = xdr_reserve_space(xdr, 4);

	*p = value ? xdr_one : xdr_zero;

}



static void encode_int32(struct xdr_stream *xdr, const s32 value)

{

	__be32 *p;



	p = xdr_reserve_space(xdr, 4);

	*p = cpu_to_be32(value);

}



/*

 *	typedef opaque netobj<MAXNETOBJ_SZ>

 */

static void encode_netobj(struct xdr_stream *xdr,

			  const u8 *data, const unsigned int length)

{

	__be32 *p;



	BUG_ON(length > XDR_MAX_NETOBJ);

	p = xdr_reserve_space(xdr, 4 + length);

	xdr_encode_opaque(p, data, length);

}



static int decode_netobj(struct xdr_stream *xdr,

			 struct xdr_netobj *obj)

{

	u32 length;

	__be32 *p;



	p = xdr_inline_decode(xdr, 4);

	if (unlikely(p == NULL))

		goto out_overflow;

	length = be32_to_cpup(p++);

	if (unlikely(length > XDR_MAX_NETOBJ))

		goto out_size;

	obj->len = length;

	obj->data = (u8 *)p;

	return 0;

out_size:

	dprintk("NFS: returned netobj was too long: %u\n", length);

	return -EIO;

out_overflow:

	print_overflow_msg(__func__, xdr);

	return -EIO;

}



/*

 *	netobj cookie;

 */

static void encode_cookie(struct xdr_stream *xdr,

			  const struct nlm_cookie *cookie)

{

	BUG_ON(cookie->len > NLM_MAXCOOKIELEN);

	encode_netobj(xdr, (u8 *)&cookie->data, cookie->len);

}



static int decode_cookie(struct xdr_stream *xdr,

			     struct nlm_cookie *cookie)

{

	u32 length;

	__be32 *p;



	p = xdr_inline_decode(xdr, 4);

	if (unlikely(p == NULL))

		goto out_overflow;

	length = be32_to_cpup(p++);

	/* apparently HPUX can return empty cookies */

	if (length == 0)

		goto out_hpux;

	if (length > NLM_MAXCOOKIELEN)

		goto out_size;

	p = xdr_inline_decode(xdr, length);

	if (unlikely(p == NULL))

		goto out_overflow;

	cookie->len = length;

	memcpy(cookie->data, p, length);

	return 0;

out_hpux:

	cookie->len = 4;

	memset(cookie->data, 0, 4);

	return 0;

out_size:

	dprintk("NFS: returned cookie was too long: %u\n", length);

	return -EIO;

out_overflow:

	print_overflow_msg(__func__, xdr);

	return -EIO;

}



/*

 *	netobj fh;

 */

static void encode_fh(struct xdr_stream *xdr, const struct nfs_fh *fh)

{

	BUG_ON(fh->size > NFS3_FHSIZE);

	encode_netobj(xdr, (u8 *)&fh->data, fh->size);

}



/*

 *	enum nlm4_stats {

 *		NLM4_GRANTED = 0,

 *		NLM4_DENIED = 1,

 *		NLM4_DENIED_NOLOCKS = 2,

 *		NLM4_BLOCKED = 3,

 *		NLM4_DENIED_GRACE_PERIOD = 4,

 *		NLM4_DEADLCK = 5,

 *		NLM4_ROFS = 6,

 *		NLM4_STALE_FH = 7,

 *		NLM4_FBIG = 8,

 *		NLM4_FAILED = 9

 *	};

 *

 *	struct nlm4_stat {

 *		nlm4_stats stat;

 *	};

 *

 * NB: we don't swap bytes for the NLM status values.  The upper

 * layers deal directly with the status value in network byte

 * order.

 */

static void encode_nlm4_stat(struct xdr_stream *xdr,

			     const __be32 stat)

{

	__be32 *p;



	BUG_ON(be32_to_cpu(stat) > NLM_FAILED);

	p = xdr_reserve_space(xdr, 4);

	*p = stat;

}



static int decode_nlm4_stat(struct xdr_stream *xdr, __be32 *stat)

{

	__be32 *p;



	p = xdr_inline_decode(xdr, 4);

	if (unlikely(p == NULL))

		goto out_overflow;

	if (unlikely(*p > nlm4_failed))

		goto out_bad_xdr;

	*stat = *p;

	return 0;

out_bad_xdr:

	dprintk("%s: server returned invalid nlm4_stats value: %u\n",

			__func__, be32_to_cpup(p));

	return -EIO;

out_overflow:

	print_overflow_msg(__func__, xdr);

	return -EIO;

}



/*

 *	struct nlm4_holder {

 *		bool	exclusive;

 *		int32	svid;

 *		netobj	oh;

 *		uint64	l_offset;

 *		uint64	l_len;

 *	};

 */

static void encode_nlm4_holder(struct xdr_stream *xdr,

			       const struct nlm_res *result)

{

	const struct nlm_lock *lock = &result->lock;

	u64 l_offset, l_len;

	__be32 *p;



	encode_bool(xdr, lock->fl.fl_type == F_RDLCK);

	encode_int32(xdr, lock->svid);

	encode_netobj(xdr, lock->oh.data, lock->oh.len);



	p = xdr_reserve_space(xdr, 4 + 4);

	nlm4_compute_offsets(lock, &l_offset, &l_len);

	p = xdr_encode_hyper(p, l_offset);

	xdr_encode_hyper(p, l_len);

}



static int decode_nlm4_holder(struct xdr_stream *xdr, struct nlm_res *result)

{

	struct nlm_lock *lock = &result->lock;

	struct file_lock *fl = &lock->fl;

	u64 l_offset, l_len;

	u32 exclusive;

	int error;

	__be32 *p;

	s32 end;



	memset(lock, 0, sizeof(*lock));

	locks_init_lock(fl);



	p = xdr_inline_decode(xdr, 4 + 4);

	if (unlikely(p == NULL))

		goto out_overflow;

	exclusive = be32_to_cpup(p++);

	lock->svid = be32_to_cpup(p);

	fl->fl_pid = (pid_t)lock->svid;



	error = decode_netobj(xdr, &lock->oh);

	if (unlikely(error))

		goto out;



	p = xdr_inline_decode(xdr, 8 + 8);

	if (unlikely(p == NULL))

		goto out_overflow;



	fl->fl_flags = FL_POSIX;

	fl->fl_type  = exclusive != 0 ? F_WRLCK : F_RDLCK;

	p = xdr_decode_hyper(p, &l_offset);

	xdr_decode_hyper(p, &l_len);

	end = l_offset + l_len - 1;



	fl->fl_start = (loff_t)l_offset;

	if (l_len == 0 || end < 0)

		fl->fl_end = OFFSET_MAX;

	else

		fl->fl_end = (loff_t)end;

	error = 0;

out:

	return error;

out_overflow:

	print_overflow_msg(__func__, xdr);

	return -EIO;

}



/*

 *	string caller_name<LM_MAXSTRLEN>;

 */

static void encode_caller_name(struct xdr_stream *xdr, const char *name)

{

	/* NB: client-side does not set lock->len */

	u32 length = strlen(name);

	__be32 *p;



	BUG_ON(length > NLM_MAXSTRLEN);

	p = xdr_reserve_space(xdr, 4 + length);

	xdr_encode_opaque(p, name, length);

}



/*

 *	struct nlm4_lock {

 *		string	caller_name<LM_MAXSTRLEN>;

 *		netobj	fh;

 *		netobj	oh;

 *		int32	svid;

 *		uint64	l_offset;

 *		uint64	l_len;

 *	};

 */

static void encode_nlm4_lock(struct xdr_stream *xdr,

			     const struct nlm_lock *lock)

{

	u64 l_offset, l_len;

	__be32 *p;



	encode_caller_name(xdr, lock->caller);

	encode_fh(xdr, &lock->fh);

	encode_netobj(xdr, lock->oh.data, lock->oh.len);



	p = xdr_reserve_space(xdr, 4 + 8 + 8);

	*p++ = cpu_to_be32(lock->svid);



	nlm4_compute_offsets(lock, &l_offset, &l_len);

	p = xdr_encode_hyper(p, l_offset);

	xdr_encode_hyper(p, l_len);

}





/*

 * NLMv4 XDR encode functions

 *

 * NLMv4 argument types are defined in Appendix II of RFC 1813:

 * "NFS Version 3 Protocol Specification" and Chapter 10 of X/Open's

 * "Protocols for Interworking: XNFS, Version 3W".

 */



/*

 *	struct nlm4_testargs {

 *		netobj cookie;

 *		bool exclusive;

 *		struct nlm4_lock alock;

 *	};

 */

static void nlm4_xdr_enc_testargs(struct rpc_rqst *req,

				  struct xdr_stream *xdr,

				  const struct nlm_args *args)

{

	const struct nlm_lock *lock = &args->lock;



	encode_cookie(xdr, &args->cookie);

	encode_bool(xdr, lock->fl.fl_type == F_WRLCK);

	encode_nlm4_lock(xdr, lock);

}



/*

 *	struct nlm4_lockargs {

 *		netobj cookie;

 *		bool block;

 *		bool exclusive;

 *		struct nlm4_lock alock;

 *		bool reclaim;

 *		int state;

 *	};

 */

static void nlm4_xdr_enc_lockargs(struct rpc_rqst *req,

				  struct xdr_stream *xdr,

				  const struct nlm_args *args)

{

	const struct nlm_lock *lock = &args->lock;



	encode_cookie(xdr, &args->cookie);

	encode_bool(xdr, args->block);

	encode_bool(xdr, lock->fl.fl_type == F_WRLCK);

	encode_nlm4_lock(xdr, lock);

	encode_bool(xdr, args->reclaim);

	encode_int32(xdr, args->state);

}



/*

 *	struct nlm4_cancargs {

 *		netobj cookie;

 *		bool block;

 *		bool exclusive;

 *		struct nlm4_lock alock;

 *	};

 */

static void nlm4_xdr_enc_cancargs(struct rpc_rqst *req,

				  struct xdr_stream *xdr,

				  const struct nlm_args *args)

{

	const struct nlm_lock *lock = &args->lock;



	encode_cookie(xdr, &args->cookie);

	encode_bool(xdr, args->block);

	encode_bool(xdr, lock->fl.fl_type == F_WRLCK);

	encode_nlm4_lock(xdr, lock);

}



/*

 *	struct nlm4_unlockargs {

 *		netobj cookie;

 *		struct nlm4_lock alock;

 *	};

 */

static void nlm4_xdr_enc_unlockargs(struct rpc_rqst *req,

				    struct xdr_stream *xdr,

				    const struct nlm_args *args)

{

	const struct nlm_lock *lock = &args->lock;



	encode_cookie(xdr, &args->cookie);

	encode_nlm4_lock(xdr, lock);

}



/*

 *	struct nlm4_res {

 *		netobj cookie;

 *		nlm4_stat stat;

 *	};

 */

static void nlm4_xdr_enc_res(struct rpc_rqst *req,

			     struct xdr_stream *xdr,

			     const struct nlm_res *result)

{

	encode_cookie(xdr, &result->cookie);

	encode_nlm4_stat(xdr, result->status);

}



/*

 *	union nlm4_testrply switch (nlm4_stats stat) {

 *	case NLM4_DENIED:

 *		struct nlm4_holder holder;

 *	default:

 *		void;

 *	};

 *

 *	struct nlm4_testres {

 *		netobj cookie;

 *		nlm4_testrply test_stat;

 *	};

 */

static void nlm4_xdr_enc_testres(struct rpc_rqst *req,

				 struct xdr_stream *xdr,

				 const struct nlm_res *result)

{

	encode_cookie(xdr, &result->cookie);

	encode_nlm4_stat(xdr, result->status);

	if (result->status == nlm_lck_denied)

		encode_nlm4_holder(xdr, result);

}





/*

 * NLMv4 XDR decode functions

 *

 * NLMv4 argument types are defined in Appendix II of RFC 1813:

 * "NFS Version 3 Protocol Specification" and Chapter 10 of X/Open's

 * "Protocols for Interworking: XNFS, Version 3W".

 */



/*

 *	union nlm4_testrply switch (nlm4_stats stat) {

 *	case NLM4_DENIED:

 *		struct nlm4_holder holder;

 *	default:

 *		void;

 *	};

 *

 *	struct nlm4_testres {

 *		netobj cookie;

 *		nlm4_testrply test_stat;

 *	};

 */

static int decode_nlm4_testrply(struct xdr_stream *xdr,

				struct nlm_res *result)

{

	int error;



	error = decode_nlm4_stat(xdr, &result->status);

	if (unlikely(error))

		goto out;

	if (result->status == nlm_lck_denied)

		error = decode_nlm4_holder(xdr, result);

out:

	return error;

}



static int nlm4_xdr_dec_testres(struct rpc_rqst *req,

				struct xdr_stream *xdr,

				struct nlm_res *result)

{

	int error;



	error = decode_cookie(xdr, &result->cookie);

	if (unlikely(error))

		goto out;

	error = decode_nlm4_testrply(xdr, result);

out:

	return error;

}



/*

 *	struct nlm4_res {

 *		netobj cookie;

 *		nlm4_stat stat;

 *	};

 */

static int nlm4_xdr_dec_res(struct rpc_rqst *req,

			    struct xdr_stream *xdr,

			    struct nlm_res *result)

{

	int error;



	error = decode_cookie(xdr, &result->cookie);

	if (unlikely(error))

		goto out;

	error = decode_nlm4_stat(xdr, &result->status);

out:

	return error;

}





/*

 * For NLM, a void procedure really returns nothing

 */

#define nlm4_xdr_dec_norep	NULL



#define PROC(proc, argtype, restype)					\

[NLMPROC_##proc] = {							\

	.p_proc      = NLMPROC_##proc,					\

	.p_encode    = (kxdreproc_t)nlm4_xdr_enc_##argtype,		\

	.p_decode    = (kxdrdproc_t)nlm4_xdr_dec_##restype,		\

	.p_arglen    = NLM4_##argtype##_sz,				\

	.p_replen    = NLM4_##restype##_sz,				\

	.p_statidx   = NLMPROC_##proc,					\

	.p_name      = #proc,						\

	}



static struct rpc_procinfo	nlm4_procedures[] = {

	PROC(TEST,		testargs,	testres),

	PROC(LOCK,		lockargs,	res),

	PROC(CANCEL,		cancargs,	res),

	PROC(UNLOCK,		unlockargs,	res),

	PROC(GRANTED,		testargs,	res),

	PROC(TEST_MSG,		testargs,	norep),

	PROC(LOCK_MSG,		lockargs,	norep),

	PROC(CANCEL_MSG,	cancargs,	norep),

	PROC(UNLOCK_MSG,	unlockargs,	norep),

	PROC(GRANTED_MSG,	testargs,	norep),

	PROC(TEST_RES,		testres,	norep),

	PROC(LOCK_RES,		res,		norep),

	PROC(CANCEL_RES,	res,		norep),

	PROC(UNLOCK_RES,	res,		norep),

	PROC(GRANTED_RES,	res,		norep),

};



struct rpc_version	nlm_version4 = {

	.number		= 4,

	.nrprocs	= ARRAY_SIZE(nlm4_procedures),

	.procs		= nlm4_procedures,

};

fs/lockd/clntlock.c

+2 −2
Original line number Original line Diff line number Diff line
@@ -79,7 +79,7 @@ EXPORT_SYMBOL_GPL(nlmclnt_init); 
 */

 */

void nlmclnt_done(struct nlm_host *host)

void nlmclnt_done(struct nlm_host *host)

{

{

	nlm_release_host(host);

	nlmclnt_release_host(host);

	lockd_down();

	lockd_down();

}

}

EXPORT_SYMBOL_GPL(nlmclnt_done);

EXPORT_SYMBOL_GPL(nlmclnt_done);
@@ -273,7 +273,7 @@ reclaimer(void *ptr) 
	spin_unlock(&nlm_blocked_lock);

	spin_unlock(&nlm_blocked_lock);





	/* Release host handle after use */

	/* Release host handle after use */

	nlm_release_host(host);

	nlmclnt_release_host(host);

	lockd_down();

	lockd_down();

	return 0;

	return 0;

}
 
}

fs/lockd/clntproc.c

+9 −9
Original line number Original line Diff line number Diff line
@@ -58,7 +58,7 @@ static void nlm_put_lockowner(struct nlm_lockowner *lockowner) 
		return;

		return;

	list_del(&lockowner->list);

	list_del(&lockowner->list);

	spin_unlock(&lockowner->host->h_lock);

	spin_unlock(&lockowner->host->h_lock);

	nlm_release_host(lockowner->host);

	nlmclnt_release_host(lockowner->host);

	kfree(lockowner);

	kfree(lockowner);

}

}
@@ -207,22 +207,22 @@ struct nlm_rqst *nlm_alloc_call(struct nlm_host *host) 
		printk("nlm_alloc_call: failed, waiting for memory\n");

		printk("nlm_alloc_call: failed, waiting for memory\n");

		schedule_timeout_interruptible(5*HZ);

		schedule_timeout_interruptible(5*HZ);

	}

	}

	nlm_release_host(host);

	nlmclnt_release_host(host);

	return NULL;

	return NULL;

}

}





void nlm_release_call(struct nlm_rqst *call)

void nlmclnt_release_call(struct nlm_rqst *call)

{

{

	if (!atomic_dec_and_test(&call->a_count))

	if (!atomic_dec_and_test(&call->a_count))

		return;

		return;

	nlm_release_host(call->a_host);

	nlmclnt_release_host(call->a_host);

	nlmclnt_release_lockargs(call);

	nlmclnt_release_lockargs(call);

	kfree(call);

	kfree(call);

}

}





static void nlmclnt_rpc_release(void *data)

static void nlmclnt_rpc_release(void *data)

{

{

	nlm_release_call(data);

	nlmclnt_release_call(data);

}

}





static int nlm_wait_on_grace(wait_queue_head_t *queue)

static int nlm_wait_on_grace(wait_queue_head_t *queue)
@@ -436,7 +436,7 @@ nlmclnt_test(struct nlm_rqst *req, struct file_lock *fl) 
			status = nlm_stat_to_errno(req->a_res.status);

			status = nlm_stat_to_errno(req->a_res.status);

	}

	}

out:

out:

	nlm_release_call(req);

	nlmclnt_release_call(req);

	return status;

	return status;

}

}
@@ -593,7 +593,7 @@ nlmclnt_lock(struct nlm_rqst *req, struct file_lock *fl) 
out_unblock:

out_unblock:

	nlmclnt_finish_block(block);

	nlmclnt_finish_block(block);

out:

out:

	nlm_release_call(req);

	nlmclnt_release_call(req);

	return status;

	return status;

out_unlock:

out_unlock:

	/* Fatal error: ensure that we remove the lock altogether */

	/* Fatal error: ensure that we remove the lock altogether */
@@ -694,7 +694,7 @@ nlmclnt_unlock(struct nlm_rqst *req, struct file_lock *fl) 
	/* What to do now? I'm out of my depth... */

	/* What to do now? I'm out of my depth... */

	status = -ENOLCK;

	status = -ENOLCK;

out:

out:

	nlm_release_call(req);

	nlmclnt_release_call(req);

	return status;

	return status;

}

}
@@ -755,7 +755,7 @@ static int nlmclnt_cancel(struct nlm_host *host, int block, struct file_lock *fl 
			NLMPROC_CANCEL, &nlmclnt_cancel_ops);

			NLMPROC_CANCEL, &nlmclnt_cancel_ops);

	if (status == 0 && req->a_res.status == nlm_lck_denied)

	if (status == 0 && req->a_res.status == nlm_lck_denied)

		status = -ENOLCK;

		status = -ENOLCK;

	nlm_release_call(req);

	nlmclnt_release_call(req);

	return status;

	return status;

}

}

fs/lockd/clntxdr.c

0 → 100644
+627 −0

File added.

Preview size limit exceeded, changes collapsed.