callback_proc.c 9.3 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 "nfs4_fs.h"
L
Linus Torvalds 已提交
11 12
#include "callback.h"
#include "delegation.h"
13
#include "internal.h"
L
Linus Torvalds 已提交
14

15
#ifdef NFS_DEBUG
L
Linus Torvalds 已提交
16
#define NFSDBG_FACILITY NFSDBG_CALLBACK
17
#endif
L
Linus Torvalds 已提交
18
 
19
__be32 nfs4_callback_getattr(struct cb_getattrargs *args, struct cb_getattrres *res)
L
Linus Torvalds 已提交
20
{
21
	struct nfs_client *clp;
L
Linus Torvalds 已提交
22 23 24
	struct nfs_delegation *delegation;
	struct nfs_inode *nfsi;
	struct inode *inode;
25

L
Linus Torvalds 已提交
26 27
	res->bitmap[0] = res->bitmap[1] = 0;
	res->status = htonl(NFS4ERR_BADHANDLE);
28
	clp = nfs_find_client(args->addr, 4);
L
Linus Torvalds 已提交
29 30
	if (clp == NULL)
		goto out;
31 32 33 34

	dprintk("NFS: GETATTR callback request from %s\n",
		rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR));

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

A
Alexandros Batsakis 已提交
64 65 66 67 68 69 70 71 72 73
static int (*nfs_validate_delegation_stateid(struct nfs_client *clp))(struct nfs_delegation *, const nfs4_stateid *)
{
#if defined(CONFIG_NFS_V4_1)
	if (clp->cl_minorversion > 0)
		return nfs41_validate_delegation_stateid;
#endif
	return nfs4_validate_delegation_stateid;
}


74
__be32 nfs4_callback_recall(struct cb_recallargs *args, void *dummy)
L
Linus Torvalds 已提交
75
{
76
	struct nfs_client *clp;
L
Linus Torvalds 已提交
77
	struct inode *inode;
78
	__be32 res;
L
Linus Torvalds 已提交
79 80
	
	res = htonl(NFS4ERR_BADHANDLE);
81
	clp = nfs_find_client(args->addr, 4);
L
Linus Torvalds 已提交
82 83
	if (clp == NULL)
		goto out;
84 85 86 87

	dprintk("NFS: RECALL callback request from %s\n",
		rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR));

88 89 90 91 92 93
	do {
		struct nfs_client *prev = clp;

		inode = nfs_delegation_find_inode(clp, &args->fh);
		if (inode != NULL) {
			/* Set up a helper thread to actually return the delegation */
A
Alexandros Batsakis 已提交
94 95
			switch (nfs_async_inode_return_delegation(inode, &args->stateid,
								  nfs_validate_delegation_stateid(clp))) {
96 97 98 99 100 101 102 103 104 105 106 107 108 109 110
				case 0:
					res = 0;
					break;
				case -ENOENT:
					if (res != 0)
						res = htonl(NFS4ERR_BAD_STATEID);
					break;
				default:
					res = htonl(NFS4ERR_RESOURCE);
			}
			iput(inode);
		}
		clp = nfs_find_client_next(prev);
		nfs_put_client(prev);
	} while (clp != NULL);
L
Linus Torvalds 已提交
111
out:
112
	dprintk("%s: exit with status = %d\n", __func__, ntohl(res));
L
Linus Torvalds 已提交
113 114
	return res;
}
115

A
Alexandros Batsakis 已提交
116 117 118 119 120 121 122 123
int nfs4_validate_delegation_stateid(struct nfs_delegation *delegation, const nfs4_stateid *stateid)
{
	if (delegation == NULL || memcmp(delegation->stateid.data, stateid->data,
					 sizeof(delegation->stateid.data)) != 0)
		return 0;
	return 1;
}

124 125
#if defined(CONFIG_NFS_V4_1)

A
Alexandros Batsakis 已提交
126 127 128 129 130 131 132 133 134 135 136 137 138 139 140
int nfs41_validate_delegation_stateid(struct nfs_delegation *delegation, const nfs4_stateid *stateid)
{
	if (delegation == NULL)
		return 0;

	/* seqid is 4-bytes long */
	if (((u32 *) &stateid->data)[0] != 0)
		return 0;
	if (memcmp(&delegation->stateid.data[4], &stateid->data[4],
		   sizeof(stateid->data)-4))
		return 0;

	return 1;
}

141 142 143 144 145 146 147 148 149 150 151 152 153 154 155
/*
 * 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.
 *
 * We don't yet implement a duplicate request cache, so at this time
 * we will log replays, and process them as if we had not seen them before,
 * but we don't bump the sequence in the slot.  Not too worried about it,
 * 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.
 */
static int
156
validate_seqid(struct nfs4_slot_table *tbl, struct cb_sequenceargs * args)
157 158 159 160
{
	struct nfs4_slot *slot;

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

163
	if (args->csa_slotid > NFS41_BC_MAX_CALLBACKS)
164 165
		return htonl(NFS4ERR_BADSLOT);

166
	slot = tbl->slots + args->csa_slotid;
167 168 169
	dprintk("%s slot table seqid: %d\n", __func__, slot->seq_nr);

	/* Normal */
170
	if (likely(args->csa_sequenceid == slot->seq_nr + 1)) {
171 172 173 174 175
		slot->seq_nr++;
		return htonl(NFS4_OK);
	}

	/* Replay */
176
	if (args->csa_sequenceid == slot->seq_nr) {
177
		dprintk("%s seqid %d is a replay - no DRC available\n",
178
			__func__, args->csa_sequenceid);
179 180 181 182
		return htonl(NFS4_OK);
	}

	/* Wraparound */
183
	if (args->csa_sequenceid == 1 && (slot->seq_nr + 1) == 0) {
184 185 186 187 188 189 190 191
		slot->seq_nr = 1;
		return htonl(NFS4_OK);
	}

	/* Misordered request */
	return htonl(NFS4ERR_SEQ_MISORDERED);
}

192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227
/*
 * Returns a pointer to a held 'struct nfs_client' that matches the server's
 * address, major version number, and session ID.  It is the caller's
 * responsibility to release the returned reference.
 *
 * Returns NULL if there are no connections with sessions, or if no session
 * matches the one of interest.
 */
 static struct nfs_client *find_client_with_session(
	const struct sockaddr *addr, u32 nfsversion,
	struct nfs4_sessionid *sessionid)
{
	struct nfs_client *clp;

	clp = nfs_find_client(addr, 4);
	if (clp == NULL)
		return NULL;

	do {
		struct nfs_client *prev = clp;

		if (clp->cl_session != NULL) {
			if (memcmp(clp->cl_session->sess_id.data,
					sessionid->data,
					NFS4_MAX_SESSIONID_LEN) == 0) {
				/* Returns a held reference to clp */
				return clp;
			}
		}
		clp = nfs_find_client_next(prev);
		nfs_put_client(prev);
	} while (clp != NULL);

	return NULL;
}

228 229 230 231 232 233 234 235 236 237 238 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 276 277 278 279 280 281 282
/*
 * 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;
}

283 284 285
unsigned nfs4_callback_sequence(struct cb_sequenceargs *args,
				struct cb_sequenceres *res)
{
286 287
	struct nfs_client *clp;
	int i, status;
288

289 290 291 292 293
	status = htonl(NFS4ERR_BADSESSION);
	clp = find_client_with_session(args->csa_addr, 4, &args->csa_sessionid);
	if (clp == NULL)
		goto out;

294
	status = validate_seqid(&clp->cl_session->bc_slot_table, args);
295 296 297
	if (status)
		goto out_putclient;

298 299 300 301 302 303 304 305 306 307
	/*
	 * 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);
		goto out_putclient;
	}

308 309 310 311 312 313 314
	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;

315 316 317
out_putclient:
	nfs_put_client(clp);
out:
318 319 320 321
	for (i = 0; i < args->csa_nrclists; i++)
		kfree(args->csa_rclists[i].rcl_refcalls);
	kfree(args->csa_rclists);

322 323
	dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
	res->csr_status = status;
324
	return res->csr_status;
325 326
}

327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354
unsigned nfs4_callback_recallany(struct cb_recallanyargs *args, void *dummy)
{
	struct nfs_client *clp;
	int status;
	fmode_t flags = 0;

	status = htonl(NFS4ERR_OP_NOT_IN_SESSION);
	clp = nfs_find_client(args->craa_addr, 4);
	if (clp == NULL)
		goto out;

	dprintk("NFS: RECALL_ANY callback request from %s\n",
		rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR));

	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;

	if (flags)
		nfs_expire_all_delegation_types(clp, flags);
	status = htonl(NFS4_OK);
out:
	dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
	return status;
}
355
#endif /* CONFIG_NFS_V4_1 */