svcproc.c 14.9 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
/*
 * linux/fs/lockd/svcproc.c
 *
 * Lockd server procedures. We don't implement the NLM_*_RES 
 * procedures because we don't use the async procedures.
 *
 * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
 */

#include <linux/types.h>
#include <linux/time.h>
#include <linux/slab.h>
#include <linux/in.h>
#include <linux/sunrpc/svc.h>
#include <linux/sunrpc/clnt.h>
#include <linux/nfsd/nfsd.h>
#include <linux/lockd/lockd.h>
#include <linux/lockd/share.h>
#include <linux/lockd/sm_inter.h>


#define NLMDBG_FACILITY		NLMDBG_CLIENT

#ifdef CONFIG_LOCKD_V4
A
Al Viro 已提交
25 26
static __be32
cast_to_nlm(__be32 status, u32 vers)
L
Linus Torvalds 已提交
27 28 29 30 31 32 33 34 35
{
	/* Note: status is assumed to be in network byte order !!! */
	if (vers != 4){
		switch (status) {
		case nlm_granted:
		case nlm_lck_denied:
		case nlm_lck_denied_nolocks:
		case nlm_lck_blocked:
		case nlm_lck_denied_grace_period:
M
Marc Eshel 已提交
36
		case nlm_drop_reply:
L
Linus Torvalds 已提交
37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55
			break;
		case nlm4_deadlock:
			status = nlm_lck_denied;
			break;
		default:
			status = nlm_lck_denied_nolocks;
		}
	}

	return (status);
}
#define	cast_status(status) (cast_to_nlm(status, rqstp->rq_vers))
#else
#define cast_status(status) (status)
#endif

/*
 * Obtain client and file from arguments
 */
A
Al Viro 已提交
56
static __be32
L
Linus Torvalds 已提交
57 58 59 60 61 62
nlmsvc_retrieve_args(struct svc_rqst *rqstp, struct nlm_args *argp,
			struct nlm_host **hostp, struct nlm_file **filp)
{
	struct nlm_host		*host = NULL;
	struct nlm_file		*file = NULL;
	struct nlm_lock		*lock = &argp->lock;
A
Al Viro 已提交
63
	__be32			error = 0;
L
Linus Torvalds 已提交
64 65 66 67 68 69

	/* nfsd callbacks must have been installed for this procedure */
	if (!nlmsvc_ops)
		return nlm_lck_denied_nolocks;

	/* Obtain host handle */
70
	if (!(host = nlmsvc_lookup_host(rqstp, lock->caller, lock->len))
71
	 || (argp->monitor && nsm_monitor(host) < 0))
L
Linus Torvalds 已提交
72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89
		goto no_locks;
	*hostp = host;

	/* Obtain file pointer. Not used by FREE_ALL call. */
	if (filp != NULL) {
		if ((error = nlm_lookup_file(rqstp, &file, &lock->fh)) != 0)
			goto no_locks;
		*filp = file;

		/* Set up the missing parts of the file_lock structure */
		lock->fl.fl_file  = file->f_file;
		lock->fl.fl_owner = (fl_owner_t) host;
		lock->fl.fl_lmops = &nlmsvc_lock_operations;
	}

	return 0;

no_locks:
90
	nlm_release_host(host);
91 92
	if (error)
		return error;
L
Linus Torvalds 已提交
93 94 95 96 97 98
	return nlm_lck_denied_nolocks;
}

/*
 * NULL: Test for presence of service
 */
A
Al Viro 已提交
99
static __be32
L
Linus Torvalds 已提交
100 101 102 103 104 105 106 107 108
nlmsvc_proc_null(struct svc_rqst *rqstp, void *argp, void *resp)
{
	dprintk("lockd: NULL          called\n");
	return rpc_success;
}

/*
 * TEST: Check for conflicting lock
 */
A
Al Viro 已提交
109
static __be32
L
Linus Torvalds 已提交
110 111 112 113 114
nlmsvc_proc_test(struct svc_rqst *rqstp, struct nlm_args *argp,
				         struct nlm_res  *resp)
{
	struct nlm_host	*host;
	struct nlm_file	*file;
115
	__be32 rc = rpc_success;
L
Linus Torvalds 已提交
116 117 118 119 120 121

	dprintk("lockd: TEST          called\n");
	resp->cookie = argp->cookie;

	/* Obtain client and file */
	if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file)))
122
		return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
L
Linus Torvalds 已提交
123 124

	/* Now check for conflicting locks */
125
	resp->status = cast_status(nlmsvc_testlock(rqstp, file, host, &argp->lock, &resp->lock, &resp->cookie));
M
Marc Eshel 已提交
126
	if (resp->status == nlm_drop_reply)
127 128 129 130
		rc = rpc_drop_reply;
	else
		dprintk("lockd: TEST          status %d vers %d\n",
			ntohl(resp->status), rqstp->rq_vers);
L
Linus Torvalds 已提交
131 132 133

	nlm_release_host(host);
	nlm_release_file(file);
134
	return rc;
L
Linus Torvalds 已提交
135 136
}

A
Al Viro 已提交
137
static __be32
L
Linus Torvalds 已提交
138 139 140 141 142
nlmsvc_proc_lock(struct svc_rqst *rqstp, struct nlm_args *argp,
				         struct nlm_res  *resp)
{
	struct nlm_host	*host;
	struct nlm_file	*file;
143
	__be32 rc = rpc_success;
L
Linus Torvalds 已提交
144 145 146 147 148 149 150

	dprintk("lockd: LOCK          called\n");

	resp->cookie = argp->cookie;

	/* Obtain client and file */
	if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file)))
151
		return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
L
Linus Torvalds 已提交
152 153 154 155 156 157 158 159 160 161 162 163 164 165

#if 0
	/* If supplied state doesn't match current state, we assume it's
	 * an old request that time-warped somehow. Any error return would
	 * do in this case because it's irrelevant anyway.
	 *
	 * NB: We don't retrieve the remote host's state yet.
	 */
	if (host->h_nsmstate && host->h_nsmstate != argp->state) {
		resp->status = nlm_lck_denied_nolocks;
	} else
#endif

	/* Now try to lock the file */
166
	resp->status = cast_status(nlmsvc_lock(rqstp, file, host, &argp->lock,
167 168
					       argp->block, &argp->cookie,
					       argp->reclaim));
169
	if (resp->status == nlm_drop_reply)
170 171 172
		rc = rpc_drop_reply;
	else
		dprintk("lockd: LOCK         status %d\n", ntohl(resp->status));
L
Linus Torvalds 已提交
173 174 175

	nlm_release_host(host);
	nlm_release_file(file);
176
	return rc;
L
Linus Torvalds 已提交
177 178
}

A
Al Viro 已提交
179
static __be32
L
Linus Torvalds 已提交
180 181 182 183 184 185 186 187 188 189 190
nlmsvc_proc_cancel(struct svc_rqst *rqstp, struct nlm_args *argp,
				           struct nlm_res  *resp)
{
	struct nlm_host	*host;
	struct nlm_file	*file;

	dprintk("lockd: CANCEL        called\n");

	resp->cookie = argp->cookie;

	/* Don't accept requests during grace period */
191
	if (locks_in_grace()) {
L
Linus Torvalds 已提交
192 193 194 195 196 197
		resp->status = nlm_lck_denied_grace_period;
		return rpc_success;
	}

	/* Obtain client and file */
	if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file)))
198
		return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
L
Linus Torvalds 已提交
199 200 201 202 203 204 205 206 207 208 209 210 211

	/* Try to cancel request. */
	resp->status = cast_status(nlmsvc_cancel_blocked(file, &argp->lock));

	dprintk("lockd: CANCEL        status %d\n", ntohl(resp->status));
	nlm_release_host(host);
	nlm_release_file(file);
	return rpc_success;
}

/*
 * UNLOCK: release a lock
 */
A
Al Viro 已提交
212
static __be32
L
Linus Torvalds 已提交
213 214 215 216 217 218 219 220 221 222 223
nlmsvc_proc_unlock(struct svc_rqst *rqstp, struct nlm_args *argp,
				           struct nlm_res  *resp)
{
	struct nlm_host	*host;
	struct nlm_file	*file;

	dprintk("lockd: UNLOCK        called\n");

	resp->cookie = argp->cookie;

	/* Don't accept new lock requests during grace period */
224
	if (locks_in_grace()) {
L
Linus Torvalds 已提交
225 226 227 228 229 230
		resp->status = nlm_lck_denied_grace_period;
		return rpc_success;
	}

	/* Obtain client and file */
	if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file)))
231
		return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
L
Linus Torvalds 已提交
232 233 234 235 236 237 238 239 240 241 242 243 244 245

	/* Now try to remove the lock */
	resp->status = cast_status(nlmsvc_unlock(file, &argp->lock));

	dprintk("lockd: UNLOCK        status %d\n", ntohl(resp->status));
	nlm_release_host(host);
	nlm_release_file(file);
	return rpc_success;
}

/*
 * GRANTED: A server calls us to tell that a process' lock request
 * was granted
 */
A
Al Viro 已提交
246
static __be32
L
Linus Torvalds 已提交
247 248 249 250 251 252
nlmsvc_proc_granted(struct svc_rqst *rqstp, struct nlm_args *argp,
				            struct nlm_res  *resp)
{
	resp->cookie = argp->cookie;

	dprintk("lockd: GRANTED       called\n");
253
	resp->status = nlmclnt_grant(svc_addr(rqstp), &argp->lock);
L
Linus Torvalds 已提交
254 255 256 257
	dprintk("lockd: GRANTED       status %d\n", ntohl(resp->status));
	return rpc_success;
}

258 259 260 261 262
/*
 * This is the generic lockd callback for async RPC calls
 */
static void nlmsvc_callback_exit(struct rpc_task *task, void *data)
{
C
Chuck Lever 已提交
263
	dprintk("lockd: %5u callback returned %d\n", task->tk_pid,
264 265 266 267 268
			-task->tk_status);
}

static void nlmsvc_callback_release(void *data)
{
269
	lock_kernel();
270
	nlm_release_call(data);
271
	unlock_kernel();
272 273 274 275 276 277 278
}

static const struct rpc_call_ops nlmsvc_callback_ops = {
	.rpc_call_done = nlmsvc_callback_exit,
	.rpc_release = nlmsvc_callback_release,
};

L
Linus Torvalds 已提交
279 280 281 282 283
/*
 * `Async' versions of the above service routines. They aren't really,
 * because we send the callback before the reply proper. I hope this
 * doesn't break any clients.
 */
A
Al Viro 已提交
284 285
static __be32 nlmsvc_callback(struct svc_rqst *rqstp, u32 proc, struct nlm_args *argp,
		__be32 (*func)(struct svc_rqst *, struct nlm_args *, struct nlm_res  *))
L
Linus Torvalds 已提交
286
{
287 288
	struct nlm_host	*host;
	struct nlm_rqst	*call;
A
Al Viro 已提交
289
	__be32 stat;
L
Linus Torvalds 已提交
290

291 292 293
	host = nlmsvc_lookup_host(rqstp,
				  argp->lock.caller,
				  argp->lock.len);
294 295 296 297 298 299 300 301 302 303 304 305
	if (host == NULL)
		return rpc_system_err;

	call = nlm_alloc_call(host);
	if (call == NULL)
		return rpc_system_err;

	stat = func(rqstp, argp, &call->a_res);
	if (stat != 0) {
		nlm_release_call(call);
		return stat;
	}
L
Linus Torvalds 已提交
306

307 308 309 310
	call->a_flags = RPC_TASK_ASYNC;
	if (nlm_async_reply(call, proc, &nlmsvc_callback_ops) < 0)
		return rpc_system_err;
	return rpc_success;
L
Linus Torvalds 已提交
311 312
}

A
Al Viro 已提交
313
static __be32 nlmsvc_proc_test_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
L
Linus Torvalds 已提交
314 315
					     void	     *resp)
{
316 317 318
	dprintk("lockd: TEST_MSG      called\n");
	return nlmsvc_callback(rqstp, NLMPROC_TEST_RES, argp, nlmsvc_proc_test);
}
L
Linus Torvalds 已提交
319

A
Al Viro 已提交
320
static __be32 nlmsvc_proc_lock_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
321 322
					     void	     *resp)
{
L
Linus Torvalds 已提交
323
	dprintk("lockd: LOCK_MSG      called\n");
324
	return nlmsvc_callback(rqstp, NLMPROC_LOCK_RES, argp, nlmsvc_proc_lock);
L
Linus Torvalds 已提交
325 326
}

A
Al Viro 已提交
327
static __be32 nlmsvc_proc_cancel_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
L
Linus Torvalds 已提交
328 329 330
					       void	       *resp)
{
	dprintk("lockd: CANCEL_MSG    called\n");
331
	return nlmsvc_callback(rqstp, NLMPROC_CANCEL_RES, argp, nlmsvc_proc_cancel);
L
Linus Torvalds 已提交
332 333
}

A
Al Viro 已提交
334
static __be32
L
Linus Torvalds 已提交
335 336 337 338
nlmsvc_proc_unlock_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
                                               void            *resp)
{
	dprintk("lockd: UNLOCK_MSG    called\n");
339
	return nlmsvc_callback(rqstp, NLMPROC_UNLOCK_RES, argp, nlmsvc_proc_unlock);
L
Linus Torvalds 已提交
340 341
}

A
Al Viro 已提交
342
static __be32
L
Linus Torvalds 已提交
343 344 345 346
nlmsvc_proc_granted_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
                                                void            *resp)
{
	dprintk("lockd: GRANTED_MSG   called\n");
347
	return nlmsvc_callback(rqstp, NLMPROC_GRANTED_RES, argp, nlmsvc_proc_granted);
L
Linus Torvalds 已提交
348 349 350 351 352
}

/*
 * SHARE: create a DOS share or alter existing share.
 */
A
Al Viro 已提交
353
static __be32
L
Linus Torvalds 已提交
354 355 356 357 358 359 360 361 362 363 364
nlmsvc_proc_share(struct svc_rqst *rqstp, struct nlm_args *argp,
				          struct nlm_res  *resp)
{
	struct nlm_host	*host;
	struct nlm_file	*file;

	dprintk("lockd: SHARE         called\n");

	resp->cookie = argp->cookie;

	/* Don't accept new lock requests during grace period */
365
	if (locks_in_grace() && !argp->reclaim) {
L
Linus Torvalds 已提交
366 367 368 369 370 371
		resp->status = nlm_lck_denied_grace_period;
		return rpc_success;
	}

	/* Obtain client and file */
	if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file)))
372
		return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
L
Linus Torvalds 已提交
373 374 375 376 377 378 379 380 381 382 383 384 385

	/* Now try to create the share */
	resp->status = cast_status(nlmsvc_share_file(host, file, argp));

	dprintk("lockd: SHARE         status %d\n", ntohl(resp->status));
	nlm_release_host(host);
	nlm_release_file(file);
	return rpc_success;
}

/*
 * UNSHARE: Release a DOS share.
 */
A
Al Viro 已提交
386
static __be32
L
Linus Torvalds 已提交
387 388 389 390 391 392 393 394 395 396 397
nlmsvc_proc_unshare(struct svc_rqst *rqstp, struct nlm_args *argp,
				            struct nlm_res  *resp)
{
	struct nlm_host	*host;
	struct nlm_file	*file;

	dprintk("lockd: UNSHARE       called\n");

	resp->cookie = argp->cookie;

	/* Don't accept requests during grace period */
398
	if (locks_in_grace()) {
L
Linus Torvalds 已提交
399 400 401 402 403 404
		resp->status = nlm_lck_denied_grace_period;
		return rpc_success;
	}

	/* Obtain client and file */
	if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file)))
405
		return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
L
Linus Torvalds 已提交
406 407 408 409 410 411 412 413 414 415 416 417 418

	/* Now try to unshare the file */
	resp->status = cast_status(nlmsvc_unshare_file(host, file, argp));

	dprintk("lockd: UNSHARE       status %d\n", ntohl(resp->status));
	nlm_release_host(host);
	nlm_release_file(file);
	return rpc_success;
}

/*
 * NM_LOCK: Create an unmonitored lock
 */
A
Al Viro 已提交
419
static __be32
L
Linus Torvalds 已提交
420 421 422 423 424 425 426 427 428 429 430 431
nlmsvc_proc_nm_lock(struct svc_rqst *rqstp, struct nlm_args *argp,
				            struct nlm_res  *resp)
{
	dprintk("lockd: NM_LOCK       called\n");

	argp->monitor = 0;		/* just clean the monitor flag */
	return nlmsvc_proc_lock(rqstp, argp, resp);
}

/*
 * FREE_ALL: Release all locks and shares held by client
 */
A
Al Viro 已提交
432
static __be32
L
Linus Torvalds 已提交
433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449
nlmsvc_proc_free_all(struct svc_rqst *rqstp, struct nlm_args *argp,
					     void            *resp)
{
	struct nlm_host	*host;

	/* Obtain client */
	if (nlmsvc_retrieve_args(rqstp, argp, &host, NULL))
		return rpc_success;

	nlmsvc_free_host_resources(host);
	nlm_release_host(host);
	return rpc_success;
}

/*
 * SM_NOTIFY: private callback from statd (not part of official NLM proto)
 */
A
Al Viro 已提交
450
static __be32
L
Linus Torvalds 已提交
451 452 453
nlmsvc_proc_sm_notify(struct svc_rqst *rqstp, struct nlm_reboot *argp,
					      void	        *resp)
{
454 455
	struct sockaddr_in	saddr;

L
Linus Torvalds 已提交
456
	dprintk("lockd: SM_NOTIFY     called\n");
457 458

	if (!nlm_privileged_requester(rqstp)) {
459 460 461
		char buf[RPC_MAX_ADDRBUFLEN];
		printk(KERN_WARNING "lockd: rejected NSM callback from %s\n",
				svc_print_addr(rqstp, buf, sizeof(buf)));
L
Linus Torvalds 已提交
462 463 464 465 466 467
		return rpc_system_err;
	}

	/* Obtain the host pointer for this NFS server and try to
	 * reclaim all locks we hold on this server.
	 */
468
	memset(&saddr, 0, sizeof(saddr));
469
	saddr.sin_family = AF_INET;
L
Linus Torvalds 已提交
470
	saddr.sin_addr.s_addr = argp->addr;
471
	nlm_host_rebooted(&saddr, argp->mon, argp->len, argp->state);
L
Linus Torvalds 已提交
472 473 474 475 476 477 478

	return rpc_success;
}

/*
 * client sent a GRANTED_RES, let's remove the associated block
 */
A
Al Viro 已提交
479
static __be32
L
Linus Torvalds 已提交
480 481 482 483 484 485 486 487
nlmsvc_proc_granted_res(struct svc_rqst *rqstp, struct nlm_res  *argp,
                                                void            *resp)
{
	if (!nlmsvc_ops)
		return rpc_success;

	dprintk("lockd: GRANTED_RES   called\n");

488
	nlmsvc_grant_reply(&argp->cookie, argp->status);
L
Linus Torvalds 已提交
489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554
	return rpc_success;
}

/*
 * NLM Server procedures.
 */

#define nlmsvc_encode_norep	nlmsvc_encode_void
#define nlmsvc_decode_norep	nlmsvc_decode_void
#define nlmsvc_decode_testres	nlmsvc_decode_void
#define nlmsvc_decode_lockres	nlmsvc_decode_void
#define nlmsvc_decode_unlockres	nlmsvc_decode_void
#define nlmsvc_decode_cancelres	nlmsvc_decode_void
#define nlmsvc_decode_grantedres	nlmsvc_decode_void

#define nlmsvc_proc_none	nlmsvc_proc_null
#define nlmsvc_proc_test_res	nlmsvc_proc_null
#define nlmsvc_proc_lock_res	nlmsvc_proc_null
#define nlmsvc_proc_cancel_res	nlmsvc_proc_null
#define nlmsvc_proc_unlock_res	nlmsvc_proc_null

struct nlm_void			{ int dummy; };

#define PROC(name, xargt, xrest, argt, rest, respsize)	\
 { .pc_func	= (svc_procfunc) nlmsvc_proc_##name,	\
   .pc_decode	= (kxdrproc_t) nlmsvc_decode_##xargt,	\
   .pc_encode	= (kxdrproc_t) nlmsvc_encode_##xrest,	\
   .pc_release	= NULL,					\
   .pc_argsize	= sizeof(struct nlm_##argt),		\
   .pc_ressize	= sizeof(struct nlm_##rest),		\
   .pc_xdrressize = respsize,				\
 }

#define	Ck	(1+XDR_QUADLEN(NLM_MAXCOOKIELEN))	/* cookie */
#define	St	1				/* status */
#define	No	(1+1024/4)			/* Net Obj */
#define	Rg	2				/* range - offset + size */

struct svc_procedure		nlmsvc_procedures[] = {
  PROC(null,		void,		void,		void,	void, 1),
  PROC(test,		testargs,	testres,	args,	res, Ck+St+2+No+Rg),
  PROC(lock,		lockargs,	res,		args,	res, Ck+St),
  PROC(cancel,		cancargs,	res,		args,	res, Ck+St),
  PROC(unlock,		unlockargs,	res,		args,	res, Ck+St),
  PROC(granted,		testargs,	res,		args,	res, Ck+St),
  PROC(test_msg,	testargs,	norep,		args,	void, 1),
  PROC(lock_msg,	lockargs,	norep,		args,	void, 1),
  PROC(cancel_msg,	cancargs,	norep,		args,	void, 1),
  PROC(unlock_msg,	unlockargs,	norep,		args,	void, 1),
  PROC(granted_msg,	testargs,	norep,		args,	void, 1),
  PROC(test_res,	testres,	norep,		res,	void, 1),
  PROC(lock_res,	lockres,	norep,		res,	void, 1),
  PROC(cancel_res,	cancelres,	norep,		res,	void, 1),
  PROC(unlock_res,	unlockres,	norep,		res,	void, 1),
  PROC(granted_res,	res,		norep,		res,	void, 1),
  /* statd callback */
  PROC(sm_notify,	reboot,		void,		reboot,	void, 1),
  PROC(none,		void,		void,		void,	void, 1),
  PROC(none,		void,		void,		void,	void, 1),
  PROC(none,		void,		void,		void,	void, 1),
  PROC(share,		shareargs,	shareres,	args,	res, Ck+St+1),
  PROC(unshare,		shareargs,	shareres,	args,	res, Ck+St+1),
  PROC(nm_lock,		lockargs,	res,		args,	res, Ck+St),
  PROC(free_all,	notify,		void,		args,	void, 0),

};