callback_proc.c 14.1 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"
L
Linus Torvalds 已提交
18

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

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

31 32 33 34
	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 已提交
35 36
	res->bitmap[0] = res->bitmap[1] = 0;
	res->status = htonl(NFS4ERR_BADHANDLE);
37

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

41
	inode = nfs_delegation_find_inode(cps->clp, &args->fh);
L
Linus Torvalds 已提交
42
	if (inode == NULL)
43
		goto out;
L
Linus Torvalds 已提交
44
	nfsi = NFS_I(inode);
45 46
	rcu_read_lock();
	delegation = rcu_dereference(nfsi->delegation);
L
Linus Torvalds 已提交
47 48 49
	if (delegation == NULL || (delegation->type & FMODE_WRITE) == 0)
		goto out_iput;
	res->size = i_size_read(inode);
50 51 52
	res->change_attr = delegation->change_attr;
	if (nfsi->npages != 0)
		res->change_attr++;
L
Linus Torvalds 已提交
53 54 55 56 57 58 59 60
	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:
61
	rcu_read_unlock();
L
Linus Torvalds 已提交
62 63
	iput(inode);
out:
64
	dprintk("%s: exit with status = %d\n", __func__, ntohl(res->status));
L
Linus Torvalds 已提交
65 66 67
	return res->status;
}

68 69
__be32 nfs4_callback_recall(struct cb_recallargs *args, void *dummy,
			    struct cb_process_state *cps)
L
Linus Torvalds 已提交
70 71
{
	struct inode *inode;
72
	__be32 res;
L
Linus Torvalds 已提交
73
	
74 75
	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 已提交
76
		goto out;
77

78
	dprintk_rcu("NFS: RECALL callback request from %s\n",
79 80 81 82 83 84 85 86 87 88 89 90
		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:
91
		res = htonl(NFS4ERR_BAD_STATEID);
92 93 94 95 96
		break;
	default:
		res = htonl(NFS4ERR_RESOURCE);
	}
	iput(inode);
L
Linus Torvalds 已提交
97
out:
98
	dprintk("%s: exit with status = %d\n", __func__, ntohl(res));
L
Linus Torvalds 已提交
99 100
	return res;
}
101 102 103

#if defined(CONFIG_NFS_V4_1)

104 105 106 107 108 109 110 111 112 113
/*
 * 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.
 */
static struct pnfs_layout_hdr * get_layout_by_fh_locked(struct nfs_client *clp, struct nfs_fh *fh)
F
Fred Isaman 已提交
114
{
115
	struct nfs_server *server;
F
Fred Isaman 已提交
116
	struct inode *ino;
117
	struct pnfs_layout_hdr *lo;
F
Fred Isaman 已提交
118

119 120
	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
		list_for_each_entry(lo, &server->layouts, plh_layouts) {
121
			if (nfs_compare_fh(fh, &NFS_I(lo->plh_inode)->fh))
122 123 124 125
				continue;
			ino = igrab(lo->plh_inode);
			if (!ino)
				continue;
126 127 128 129 130 131 132
			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);
				continue;
			}
133
			pnfs_get_layout_hdr(lo);
134
			spin_unlock(&ino->i_lock);
135
			return lo;
136
		}
F
Fred Isaman 已提交
137
	}
138 139 140 141 142 143 144 145 146 147 148

	return NULL;
}

static struct pnfs_layout_hdr * get_layout_by_fh(struct nfs_client *clp, struct nfs_fh *fh)
{
	struct pnfs_layout_hdr *lo;

	spin_lock(&clp->cl_lock);
	rcu_read_lock();
	lo = get_layout_by_fh_locked(clp, fh);
149
	rcu_read_unlock();
F
Fred Isaman 已提交
150
	spin_unlock(&clp->cl_lock);
151

152 153 154 155 156 157 158 159 160 161 162 163 164
	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);

	lo = get_layout_by_fh(clp, &args->cbl_fh);
	if (!lo)
F
Fred Isaman 已提交
165 166
		return NFS4ERR_NOMATCHING_LAYOUT;

167
	ino = lo->plh_inode;
F
Fred Isaman 已提交
168 169
	spin_lock(&ino->i_lock);
	if (test_bit(NFS_LAYOUT_BULK_RECALL, &lo->plh_flags) ||
170
	    pnfs_mark_matching_lsegs_invalid(lo, &free_me_list,
171
					&args->cbl_range))
F
Fred Isaman 已提交
172 173 174 175 176 177
		rv = NFS4ERR_DELAY;
	else
		rv = NFS4ERR_NOMATCHING_LAYOUT;
	pnfs_set_layout_stateid(lo, &args->cbl_stateid, true);
	spin_unlock(&ino->i_lock);
	pnfs_free_lseg_list(&free_me_list);
178
	pnfs_put_layout_hdr(lo);
F
Fred Isaman 已提交
179 180 181 182 183 184 185
	iput(ino);
	return rv;
}

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

188 189 190 191 192 193 194
	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 已提交
195 196 197 198 199
}

static u32 do_callback_layoutrecall(struct nfs_client *clp,
				    struct cb_layoutrecallargs *args)
{
200
	u32 res;
F
Fred Isaman 已提交
201 202 203 204 205 206 207 208 209 210 211

	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 已提交
212 213 214
__be32 nfs4_callback_layoutrecall(struct cb_layoutrecallargs *args,
				  void *dummy, struct cb_process_state *cps)
{
F
Fred Isaman 已提交
215 216 217 218 219 220 221 222 223 224 225
	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 已提交
226 227
}

228 229 230 231 232 233 234 235 236 237 238
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 已提交
239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275
__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:
		if (dev->cbd_notify_type == NOTIFY_DEVICEID4_CHANGE)
			dprintk("%s: NOTIFY_DEVICEID4_CHANGE not supported, "
				"deleting instead\n", __func__);
276
		nfs4_delete_deviceid(server->pnfs_curr_ld, clp, &dev->cbd_dev_id);
M
Marc Eshel 已提交
277 278 279 280 281 282 283 284 285
	}

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

286 287 288 289 290
/*
 * 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.
 *
291 292
 * 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
293 294 295 296 297 298
 * 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.
 */
299
static __be32
300
validate_seqid(struct nfs4_slot_table *tbl, struct cb_sequenceargs * args)
301 302 303 304
{
	struct nfs4_slot *slot;

	dprintk("%s enter. slotid %d seqid %d\n",
305
		__func__, args->csa_slotid, args->csa_sequenceid);
306

307
	if (args->csa_slotid >= NFS41_BC_MAX_CALLBACKS)
308 309
		return htonl(NFS4ERR_BADSLOT);

310
	slot = tbl->slots + args->csa_slotid;
311 312 313
	dprintk("%s slot table seqid: %d\n", __func__, slot->seq_nr);

	/* Normal */
314
	if (likely(args->csa_sequenceid == slot->seq_nr + 1)) {
315
		slot->seq_nr++;
316
		goto out_ok;
317 318 319
	}

	/* Replay */
320
	if (args->csa_sequenceid == slot->seq_nr) {
321
		dprintk("%s seqid %d is a replay\n",
322
			__func__, args->csa_sequenceid);
323 324 325 326 327 328 329
		/* 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);
330 331 332
	}

	/* Wraparound */
333
	if (args->csa_sequenceid == 1 && (slot->seq_nr + 1) == 0) {
334
		slot->seq_nr = 1;
335
		goto out_ok;
336 337 338 339
	}

	/* Misordered request */
	return htonl(NFS4ERR_SEQ_MISORDERED);
340 341 342
out_ok:
	tbl->highest_used_slotid = args->csa_slotid;
	return htonl(NFS4_OK);
343 344
}

345 346 347 348 349 350 351 352 353 354 355 356 357 358 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
/*
 * 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;
}

400
__be32 nfs4_callback_sequence(struct cb_sequenceargs *args,
401 402
			      struct cb_sequenceres *res,
			      struct cb_process_state *cps)
403
{
404
	struct nfs4_slot_table *tbl;
405
	struct nfs_client *clp;
406
	int i;
407
	__be32 status = htonl(NFS4ERR_BADSESSION);
408

409 410
	clp = nfs4_find_client_sessionid(cps->net, args->csa_addr,
					 &args->csa_sessionid, cps->minorversion);
411 412 413
	if (clp == NULL)
		goto out;

414 415 416
	tbl = &clp->cl_session->bc_slot_table;

	spin_lock(&tbl->slot_tbl_lock);
417
	/* state manager is resetting the session */
418
	if (test_bit(NFS4_SLOT_TBL_DRAINING, &tbl->slot_tbl_state)) {
419 420
		spin_unlock(&tbl->slot_tbl_lock);
		status = htonl(NFS4ERR_DELAY);
421 422 423 424 425
		/* 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);
426 427 428
		goto out;
	}

429
	status = validate_seqid(&clp->cl_session->bc_slot_table, args);
430
	spin_unlock(&tbl->slot_tbl_lock);
431
	if (status)
432
		goto out;
433

434 435
	cps->slotid = args->csa_slotid;

436 437 438 439 440 441 442
	/*
	 * 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);
443
		goto out;
444 445
	}

446 447 448 449 450 451 452
	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;

453
out:
454
	cps->clp = clp; /* put in nfs4_callback_compound */
455 456 457 458
	for (i = 0; i < args->csa_nrclists; i++)
		kfree(args->csa_rclists[i].rcl_refcalls);
	kfree(args->csa_rclists);

459 460 461 462
	if (status == htonl(NFS4ERR_RETRY_UNCACHED_REP)) {
		cps->drc_status = status;
		status = 0;
	} else
463
		res->csr_status = status;
464

465 466 467
	dprintk("%s: exit with status = %d res->csr_status %d\n", __func__,
		ntohl(status), ntohl(res->csr_status));
	return status;
468 469
}

470 471 472 473 474 475
static bool
validate_bitmap_values(unsigned long mask)
{
	return (mask & ~RCA4_TYPE_MASK_ALL) == 0;
}

476 477
__be32 nfs4_callback_recallany(struct cb_recallanyargs *args, void *dummy,
			       struct cb_process_state *cps)
478
{
479
	__be32 status;
480 481
	fmode_t flags = 0;

482
	status = cpu_to_be32(NFS4ERR_OP_NOT_IN_SESSION);
483
	if (!cps->clp) /* set in cb_sequence */
484 485
		goto out;

486
	dprintk_rcu("NFS: RECALL_ANY callback request from %s\n",
487
		rpc_peeraddr2str(cps->clp->cl_rpcclient, RPC_DISPLAY_ADDR));
488

489 490 491 492 493
	status = cpu_to_be32(NFS4ERR_INVAL);
	if (!validate_bitmap_values(args->craa_type_mask))
		goto out;

	status = cpu_to_be32(NFS4_OK);
494 495 496 497 498 499
	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;
500 501 502
	if (test_bit(RCA4_TYPE_MASK_FILE_LAYOUT, (const unsigned long *)
		     &args->craa_type_mask))
		pnfs_recall_all_layouts(cps->clp);
503
	if (flags)
504
		nfs_expire_unused_delegation_types(cps->clp, flags);
505 506 507 508
out:
	dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
	return status;
}
A
Andy Adamson 已提交
509 510

/* Reduce the fore channel's max_slots to the target value */
511 512
__be32 nfs4_callback_recallslot(struct cb_recallslotargs *args, void *dummy,
				struct cb_process_state *cps)
A
Andy Adamson 已提交
513 514
{
	struct nfs4_slot_table *fc_tbl;
515
	__be32 status;
A
Andy Adamson 已提交
516 517

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

521
	dprintk_rcu("NFS: CB_RECALL_SLOT request from %s target highest slotid %d\n",
522
		rpc_peeraddr2str(cps->clp->cl_rpcclient, RPC_DISPLAY_ADDR),
523
		args->crsa_target_highest_slotid);
A
Andy Adamson 已提交
524

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

527
	status = htonl(NFS4_OK);
A
Andy Adamson 已提交
528

529
	nfs41_set_target_slotid(fc_tbl, args->crsa_target_highest_slotid);
530
	nfs41_server_notify_target_slotid_update(cps->clp);
A
Andy Adamson 已提交
531 532 533 534
out:
	dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
	return status;
}
535
#endif /* CONFIG_NFS_V4_1 */