callback_proc.c 14.5 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9
/*
 * linux/fs/nfs/callback_proc.c
 *
 * Copyright (C) 2004 Trond Myklebust
 *
 * NFSv4 callback procedures
 */
#include <linux/nfs4.h>
#include <linux/nfs_fs.h>
10
#include <linux/slab.h>
11
#include <linux/rcupdate.h>
12
#include "nfs4_fs.h"
L
Linus Torvalds 已提交
13 14
#include "callback.h"
#include "delegation.h"
15
#include "internal.h"
F
Fred Isaman 已提交
16
#include "pnfs.h"
17
#include "nfs4session.h"
18
#include "nfs4trace.h"
L
Linus Torvalds 已提交
19

20
#ifdef NFS_DEBUG
L
Linus Torvalds 已提交
21
#define NFSDBG_FACILITY NFSDBG_CALLBACK
22
#endif
23 24 25 26

__be32 nfs4_callback_getattr(struct cb_getattrargs *args,
			     struct cb_getattrres *res,
			     struct cb_process_state *cps)
L
Linus Torvalds 已提交
27 28 29 30
{
	struct nfs_delegation *delegation;
	struct nfs_inode *nfsi;
	struct inode *inode;
31

32 33 34 35
	res->status = htonl(NFS4ERR_OP_NOT_IN_SESSION);
	if (!cps->clp) /* Always set for v4.0. Set in cb_sequence for v4.1 */
		goto out;

L
Linus Torvalds 已提交
36 37
	res->bitmap[0] = res->bitmap[1] = 0;
	res->status = htonl(NFS4ERR_BADHANDLE);
38

39
	dprintk_rcu("NFS: GETATTR callback request from %s\n",
40
		rpc_peeraddr2str(cps->clp->cl_rpcclient, RPC_DISPLAY_ADDR));
41

42
	inode = nfs_delegation_find_inode(cps->clp, &args->fh);
L
Linus Torvalds 已提交
43
	if (inode == NULL)
44
		goto out;
L
Linus Torvalds 已提交
45
	nfsi = NFS_I(inode);
46 47
	rcu_read_lock();
	delegation = rcu_dereference(nfsi->delegation);
L
Linus Torvalds 已提交
48 49 50
	if (delegation == NULL || (delegation->type & FMODE_WRITE) == 0)
		goto out_iput;
	res->size = i_size_read(inode);
51
	res->change_attr = delegation->change_attr;
52
	if (nfsi->nrequests != 0)
53
		res->change_attr++;
L
Linus Torvalds 已提交
54 55 56 57 58 59 60 61
	res->ctime = inode->i_ctime;
	res->mtime = inode->i_mtime;
	res->bitmap[0] = (FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE) &
		args->bitmap[0];
	res->bitmap[1] = (FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY) &
		args->bitmap[1];
	res->status = 0;
out_iput:
62
	rcu_read_unlock();
L
Linus Torvalds 已提交
63 64
	iput(inode);
out:
65
	dprintk("%s: exit with status = %d\n", __func__, ntohl(res->status));
L
Linus Torvalds 已提交
66 67 68
	return res->status;
}

69 70
__be32 nfs4_callback_recall(struct cb_recallargs *args, void *dummy,
			    struct cb_process_state *cps)
L
Linus Torvalds 已提交
71 72
{
	struct inode *inode;
73
	__be32 res;
L
Linus Torvalds 已提交
74
	
75 76
	res = htonl(NFS4ERR_OP_NOT_IN_SESSION);
	if (!cps->clp) /* Always set for v4.0. Set in cb_sequence for v4.1 */
L
Linus Torvalds 已提交
77
		goto out;
78

79
	dprintk_rcu("NFS: RECALL callback request from %s\n",
80 81 82 83 84 85 86 87 88 89 90 91
		rpc_peeraddr2str(cps->clp->cl_rpcclient, RPC_DISPLAY_ADDR));

	res = htonl(NFS4ERR_BADHANDLE);
	inode = nfs_delegation_find_inode(cps->clp, &args->fh);
	if (inode == NULL)
		goto out;
	/* Set up a helper thread to actually return the delegation */
	switch (nfs_async_inode_return_delegation(inode, &args->stateid)) {
	case 0:
		res = 0;
		break;
	case -ENOENT:
92
		res = htonl(NFS4ERR_BAD_STATEID);
93 94 95 96
		break;
	default:
		res = htonl(NFS4ERR_RESOURCE);
	}
97
	trace_nfs4_recall_delegation(inode, -ntohl(res));
98
	iput(inode);
L
Linus Torvalds 已提交
99
out:
100
	dprintk("%s: exit with status = %d\n", __func__, ntohl(res));
L
Linus Torvalds 已提交
101 102
	return res;
}
103 104 105

#if defined(CONFIG_NFS_V4_1)

106 107 108 109 110 111 112 113 114
/*
 * Lookup a layout by filehandle.
 *
 * Note: gets a refcount on the layout hdr and on its respective inode.
 * Caller must put the layout hdr and the inode.
 *
 * TODO: keep track of all layouts (and delegations) in a hash table
 * hashed by filehandle.
 */
115 116
static struct pnfs_layout_hdr * get_layout_by_fh_locked(struct nfs_client *clp,
		struct nfs_fh *fh, nfs4_stateid *stateid)
F
Fred Isaman 已提交
117
{
118
	struct nfs_server *server;
F
Fred Isaman 已提交
119
	struct inode *ino;
120
	struct pnfs_layout_hdr *lo;
F
Fred Isaman 已提交
121

122 123
	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
		list_for_each_entry(lo, &server->layouts, plh_layouts) {
124 125
			if (!nfs4_stateid_match_other(&lo->plh_stateid, stateid))
				continue;
126
			if (nfs_compare_fh(fh, &NFS_I(lo->plh_inode)->fh))
127 128 129
				continue;
			ino = igrab(lo->plh_inode);
			if (!ino)
130
				break;
131 132 133 134 135
			spin_lock(&ino->i_lock);
			/* Is this layout in the process of being freed? */
			if (NFS_I(ino)->layout != lo) {
				spin_unlock(&ino->i_lock);
				iput(ino);
136
				break;
137
			}
138
			pnfs_get_layout_hdr(lo);
139
			spin_unlock(&ino->i_lock);
140
			return lo;
141
		}
F
Fred Isaman 已提交
142
	}
143 144 145 146

	return NULL;
}

147 148
static struct pnfs_layout_hdr * get_layout_by_fh(struct nfs_client *clp,
		struct nfs_fh *fh, nfs4_stateid *stateid)
149 150 151 152 153
{
	struct pnfs_layout_hdr *lo;

	spin_lock(&clp->cl_lock);
	rcu_read_lock();
154
	lo = get_layout_by_fh_locked(clp, fh, stateid);
155
	rcu_read_unlock();
F
Fred Isaman 已提交
156
	spin_unlock(&clp->cl_lock);
157

158 159 160 161 162 163 164 165 166 167 168
	return lo;
}

static u32 initiate_file_draining(struct nfs_client *clp,
				  struct cb_layoutrecallargs *args)
{
	struct inode *ino;
	struct pnfs_layout_hdr *lo;
	u32 rv = NFS4ERR_NOMATCHING_LAYOUT;
	LIST_HEAD(free_me_list);

169
	lo = get_layout_by_fh(clp, &args->cbl_fh, &args->cbl_stateid);
170
	if (!lo)
171
		goto out;
F
Fred Isaman 已提交
172

173
	ino = lo->plh_inode;
174 175 176 177 178 179 180

	spin_lock(&ino->i_lock);
	pnfs_set_layout_stateid(lo, &args->cbl_stateid, true);
	spin_unlock(&ino->i_lock);

	pnfs_layoutcommit_inode(ino, false);

F
Fred Isaman 已提交
181 182
	spin_lock(&ino->i_lock);
	if (test_bit(NFS_LAYOUT_BULK_RECALL, &lo->plh_flags) ||
183
	    pnfs_mark_matching_lsegs_invalid(lo, &free_me_list,
184
					&args->cbl_range)) {
F
Fred Isaman 已提交
185
		rv = NFS4ERR_DELAY;
186 187 188 189 190 191 192 193
		goto unlock;
	}

	if (NFS_SERVER(ino)->pnfs_curr_ld->return_range) {
		NFS_SERVER(ino)->pnfs_curr_ld->return_range(lo,
			&args->cbl_range);
	}
unlock:
F
Fred Isaman 已提交
194 195
	spin_unlock(&ino->i_lock);
	pnfs_free_lseg_list(&free_me_list);
196
	pnfs_put_layout_hdr(lo);
F
Fred Isaman 已提交
197
	iput(ino);
198
out:
F
Fred Isaman 已提交
199 200 201 202 203 204
	return rv;
}

static u32 initiate_bulk_draining(struct nfs_client *clp,
				  struct cb_layoutrecallargs *args)
{
205
	int stat;
206

207 208 209 210 211 212 213
	if (args->cbl_recall_type == RETURN_FSID)
		stat = pnfs_destroy_layouts_byfsid(clp, &args->cbl_fsid, true);
	else
		stat = pnfs_destroy_layouts_byclid(clp, true);
	if (stat != 0)
		return NFS4ERR_DELAY;
	return NFS4ERR_NOMATCHING_LAYOUT;
F
Fred Isaman 已提交
214 215 216 217 218
}

static u32 do_callback_layoutrecall(struct nfs_client *clp,
				    struct cb_layoutrecallargs *args)
{
219
	u32 res;
F
Fred Isaman 已提交
220 221 222 223 224 225 226 227 228 229 230

	dprintk("%s enter, type=%i\n", __func__, args->cbl_recall_type);
	if (args->cbl_recall_type == RETURN_FILE)
		res = initiate_file_draining(clp, args);
	else
		res = initiate_bulk_draining(clp, args);
	dprintk("%s returning %i\n", __func__, res);
	return res;

}

F
Fred Isaman 已提交
231 232 233
__be32 nfs4_callback_layoutrecall(struct cb_layoutrecallargs *args,
				  void *dummy, struct cb_process_state *cps)
{
F
Fred Isaman 已提交
234 235 236 237 238 239 240 241 242 243 244
	u32 res;

	dprintk("%s: -->\n", __func__);

	if (cps->clp)
		res = do_callback_layoutrecall(cps->clp, args);
	else
		res = NFS4ERR_OP_NOT_IN_SESSION;

	dprintk("%s: exit with status = %d\n", __func__, res);
	return cpu_to_be32(res);
F
Fred Isaman 已提交
245 246
}

247 248 249 250 251 252 253 254 255 256 257
static void pnfs_recall_all_layouts(struct nfs_client *clp)
{
	struct cb_layoutrecallargs args;

	/* Pretend we got a CB_LAYOUTRECALL(ALL) */
	memset(&args, 0, sizeof(args));
	args.cbl_recall_type = RETURN_ALL;
	/* FIXME we ignore errors, what should we do? */
	do_callback_layoutrecall(clp, &args);
}

M
Marc Eshel 已提交
258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291
__be32 nfs4_callback_devicenotify(struct cb_devicenotifyargs *args,
				  void *dummy, struct cb_process_state *cps)
{
	int i;
	__be32 res = 0;
	struct nfs_client *clp = cps->clp;
	struct nfs_server *server = NULL;

	dprintk("%s: -->\n", __func__);

	if (!clp) {
		res = cpu_to_be32(NFS4ERR_OP_NOT_IN_SESSION);
		goto out;
	}

	for (i = 0; i < args->ndevs; i++) {
		struct cb_devicenotifyitem *dev = &args->devs[i];

		if (!server ||
		    server->pnfs_curr_ld->id != dev->cbd_layout_type) {
			rcu_read_lock();
			list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
				if (server->pnfs_curr_ld &&
				    server->pnfs_curr_ld->id == dev->cbd_layout_type) {
					rcu_read_unlock();
					goto found;
				}
			rcu_read_unlock();
			dprintk("%s: layout type %u not found\n",
				__func__, dev->cbd_layout_type);
			continue;
		}

	found:
292
		nfs4_delete_deviceid(server->pnfs_curr_ld, clp, &dev->cbd_dev_id);
M
Marc Eshel 已提交
293 294 295 296 297 298 299 300 301
	}

out:
	kfree(args->devs);
	dprintk("%s: exit with status = %u\n",
		__func__, be32_to_cpu(res));
	return res;
}

302 303 304 305 306
/*
 * Validate the sequenceID sent by the server.
 * Return success if the sequenceID is one more than what we last saw on
 * this slot, accounting for wraparound.  Increments the slot's sequence.
 *
307 308
 * We don't yet implement a duplicate request cache, instead we set the
 * back channel ca_maxresponsesize_cached to zero. This is OK for now
309 310 311 312 313 314
 * since we only currently implement idempotent callbacks anyway.
 *
 * We have a single slot backchannel at this time, so we don't bother
 * checking the used_slots bit array on the table.  The lower layer guarantees
 * a single outstanding callback request at a time.
 */
315
static __be32
316
validate_seqid(struct nfs4_slot_table *tbl, struct cb_sequenceargs * args)
317 318 319
{
	struct nfs4_slot *slot;

320
	dprintk("%s enter. slotid %u seqid %u\n",
321
		__func__, args->csa_slotid, args->csa_sequenceid);
322

323
	if (args->csa_slotid >= NFS41_BC_MAX_CALLBACKS)
324 325
		return htonl(NFS4ERR_BADSLOT);

326
	slot = tbl->slots + args->csa_slotid;
327
	dprintk("%s slot table seqid: %u\n", __func__, slot->seq_nr);
328 329

	/* Normal */
330
	if (likely(args->csa_sequenceid == slot->seq_nr + 1)) {
331
		slot->seq_nr++;
332
		goto out_ok;
333 334 335
	}

	/* Replay */
336
	if (args->csa_sequenceid == slot->seq_nr) {
337
		dprintk("%s seqid %u is a replay\n",
338
			__func__, args->csa_sequenceid);
339 340 341 342 343 344 345
		/* Signal process_op to set this error on next op */
		if (args->csa_cachethis == 0)
			return htonl(NFS4ERR_RETRY_UNCACHED_REP);

		/* The ca_maxresponsesize_cached is 0 with no DRC */
		else if (args->csa_cachethis == 1)
			return htonl(NFS4ERR_REP_TOO_BIG_TO_CACHE);
346 347 348
	}

	/* Wraparound */
349
	if (args->csa_sequenceid == 1 && (slot->seq_nr + 1) == 0) {
350
		slot->seq_nr = 1;
351
		goto out_ok;
352 353 354 355
	}

	/* Misordered request */
	return htonl(NFS4ERR_SEQ_MISORDERED);
356 357 358
out_ok:
	tbl->highest_used_slotid = args->csa_slotid;
	return htonl(NFS4_OK);
359 360
}

361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415
/*
 * For each referring call triple, check the session's slot table for
 * a match.  If the slot is in use and the sequence numbers match, the
 * client is still waiting for a response to the original request.
 */
static bool referring_call_exists(struct nfs_client *clp,
				  uint32_t nrclists,
				  struct referring_call_list *rclists)
{
	bool status = 0;
	int i, j;
	struct nfs4_session *session;
	struct nfs4_slot_table *tbl;
	struct referring_call_list *rclist;
	struct referring_call *ref;

	/*
	 * XXX When client trunking is implemented, this becomes
	 * a session lookup from within the loop
	 */
	session = clp->cl_session;
	tbl = &session->fc_slot_table;

	for (i = 0; i < nrclists; i++) {
		rclist = &rclists[i];
		if (memcmp(session->sess_id.data,
			   rclist->rcl_sessionid.data,
			   NFS4_MAX_SESSIONID_LEN) != 0)
			continue;

		for (j = 0; j < rclist->rcl_nrefcalls; j++) {
			ref = &rclist->rcl_refcalls[j];

			dprintk("%s: sessionid %x:%x:%x:%x sequenceid %u "
				"slotid %u\n", __func__,
				((u32 *)&rclist->rcl_sessionid.data)[0],
				((u32 *)&rclist->rcl_sessionid.data)[1],
				((u32 *)&rclist->rcl_sessionid.data)[2],
				((u32 *)&rclist->rcl_sessionid.data)[3],
				ref->rc_sequenceid, ref->rc_slotid);

			spin_lock(&tbl->slot_tbl_lock);
			status = (test_bit(ref->rc_slotid, tbl->used_slots) &&
				  tbl->slots[ref->rc_slotid].seq_nr ==
					ref->rc_sequenceid);
			spin_unlock(&tbl->slot_tbl_lock);
			if (status)
				goto out;
		}
	}

out:
	return status;
}

416
__be32 nfs4_callback_sequence(struct cb_sequenceargs *args,
417 418
			      struct cb_sequenceres *res,
			      struct cb_process_state *cps)
419
{
420
	struct nfs4_slot_table *tbl;
421
	struct nfs_client *clp;
422
	int i;
423
	__be32 status = htonl(NFS4ERR_BADSESSION);
424

425 426
	clp = nfs4_find_client_sessionid(cps->net, args->csa_addr,
					 &args->csa_sessionid, cps->minorversion);
427 428 429
	if (clp == NULL)
		goto out;

430 431
	if (!(clp->cl_session->flags & SESSION4_BACK_CHAN))
		goto out;
432 433 434
	tbl = &clp->cl_session->bc_slot_table;

	spin_lock(&tbl->slot_tbl_lock);
435
	/* state manager is resetting the session */
436
	if (test_bit(NFS4_SLOT_TBL_DRAINING, &tbl->slot_tbl_state)) {
437 438
		spin_unlock(&tbl->slot_tbl_lock);
		status = htonl(NFS4ERR_DELAY);
439 440 441 442 443
		/* Return NFS4ERR_BADSESSION if we're draining the session
		 * in order to reset it.
		 */
		if (test_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state))
			status = htonl(NFS4ERR_BADSESSION);
444 445 446
		goto out;
	}

447
	status = validate_seqid(&clp->cl_session->bc_slot_table, args);
448
	spin_unlock(&tbl->slot_tbl_lock);
449
	if (status)
450
		goto out;
451

452 453
	cps->slotid = args->csa_slotid;

454 455 456 457 458 459 460
	/*
	 * Check for pending referring calls.  If a match is found, a
	 * related callback was received before the response to the original
	 * call.
	 */
	if (referring_call_exists(clp, args->csa_nrclists, args->csa_rclists)) {
		status = htonl(NFS4ERR_DELAY);
461
		goto out;
462 463
	}

464 465 466 467 468 469 470
	memcpy(&res->csr_sessionid, &args->csa_sessionid,
	       sizeof(res->csr_sessionid));
	res->csr_sequenceid = args->csa_sequenceid;
	res->csr_slotid = args->csa_slotid;
	res->csr_highestslotid = NFS41_BC_MAX_CALLBACKS - 1;
	res->csr_target_highestslotid = NFS41_BC_MAX_CALLBACKS - 1;

471
out:
472
	cps->clp = clp; /* put in nfs4_callback_compound */
473 474 475 476
	for (i = 0; i < args->csa_nrclists; i++)
		kfree(args->csa_rclists[i].rcl_refcalls);
	kfree(args->csa_rclists);

477 478 479 480
	if (status == htonl(NFS4ERR_RETRY_UNCACHED_REP)) {
		cps->drc_status = status;
		status = 0;
	} else
481
		res->csr_status = status;
482

483
	trace_nfs4_cb_sequence(args, res, status);
484 485 486
	dprintk("%s: exit with status = %d res->csr_status %d\n", __func__,
		ntohl(status), ntohl(res->csr_status));
	return status;
487 488
}

489 490 491 492 493 494
static bool
validate_bitmap_values(unsigned long mask)
{
	return (mask & ~RCA4_TYPE_MASK_ALL) == 0;
}

495 496
__be32 nfs4_callback_recallany(struct cb_recallanyargs *args, void *dummy,
			       struct cb_process_state *cps)
497
{
498
	__be32 status;
499 500
	fmode_t flags = 0;

501
	status = cpu_to_be32(NFS4ERR_OP_NOT_IN_SESSION);
502
	if (!cps->clp) /* set in cb_sequence */
503 504
		goto out;

505
	dprintk_rcu("NFS: RECALL_ANY callback request from %s\n",
506
		rpc_peeraddr2str(cps->clp->cl_rpcclient, RPC_DISPLAY_ADDR));
507

508 509 510 511 512
	status = cpu_to_be32(NFS4ERR_INVAL);
	if (!validate_bitmap_values(args->craa_type_mask))
		goto out;

	status = cpu_to_be32(NFS4_OK);
513 514 515 516 517 518
	if (test_bit(RCA4_TYPE_MASK_RDATA_DLG, (const unsigned long *)
		     &args->craa_type_mask))
		flags = FMODE_READ;
	if (test_bit(RCA4_TYPE_MASK_WDATA_DLG, (const unsigned long *)
		     &args->craa_type_mask))
		flags |= FMODE_WRITE;
519 520 521
	if (test_bit(RCA4_TYPE_MASK_FILE_LAYOUT, (const unsigned long *)
		     &args->craa_type_mask))
		pnfs_recall_all_layouts(cps->clp);
522
	if (flags)
523
		nfs_expire_unused_delegation_types(cps->clp, flags);
524 525 526 527
out:
	dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
	return status;
}
A
Andy Adamson 已提交
528 529

/* Reduce the fore channel's max_slots to the target value */
530 531
__be32 nfs4_callback_recallslot(struct cb_recallslotargs *args, void *dummy,
				struct cb_process_state *cps)
A
Andy Adamson 已提交
532 533
{
	struct nfs4_slot_table *fc_tbl;
534
	__be32 status;
A
Andy Adamson 已提交
535 536

	status = htonl(NFS4ERR_OP_NOT_IN_SESSION);
537
	if (!cps->clp) /* set in cb_sequence */
A
Andy Adamson 已提交
538 539
		goto out;

540
	dprintk_rcu("NFS: CB_RECALL_SLOT request from %s target highest slotid %u\n",
541
		rpc_peeraddr2str(cps->clp->cl_rpcclient, RPC_DISPLAY_ADDR),
542
		args->crsa_target_highest_slotid);
A
Andy Adamson 已提交
543

544
	fc_tbl = &cps->clp->cl_session->fc_slot_table;
A
Andy Adamson 已提交
545

546
	status = htonl(NFS4_OK);
A
Andy Adamson 已提交
547

548
	nfs41_set_target_slotid(fc_tbl, args->crsa_target_highest_slotid);
549
	nfs41_server_notify_target_slotid_update(cps->clp);
A
Andy Adamson 已提交
550 551 552 553
out:
	dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
	return status;
}
554
#endif /* CONFIG_NFS_V4_1 */