forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2024-02-20 102a0743326a03cd1a1202ceda21e175b7d3575c 
 kernel/fs/nfs/delegation.c
....@@ -1,3 +1,4 @@
1
+// SPDX-License-Identifier: GPL-2.0-only
12 /*
23  * linux/fs/nfs/delegation.c
34  *
....@@ -24,13 +25,44 @@
2425 #include "internal.h"
2526 #include "nfs4trace.h"
2627 
28
+#define NFS_DEFAULT_DELEGATION_WATERMARK (5000U)
29
+
30
+static atomic_long_t nfs_active_delegations;
31
+static unsigned nfs_delegation_watermark = NFS_DEFAULT_DELEGATION_WATERMARK;
32
+
33
+static void __nfs_free_delegation(struct nfs_delegation *delegation)
34
+{
35
+	put_cred(delegation->cred);
36
+	delegation->cred = NULL;
37
+	kfree_rcu(delegation, rcu);
38
+}
39
+
40
+static void nfs_mark_delegation_revoked(struct nfs_delegation *delegation)
41
+{
42
+	if (!test_and_set_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) {
43
+		delegation->stateid.type = NFS4_INVALID_STATEID_TYPE;
44
+		atomic_long_dec(&nfs_active_delegations);
45
+		if (!test_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
46
+			nfs_clear_verifier_delegated(delegation->inode);
47
+	}
48
+}
49
+
50
+static struct nfs_delegation *nfs_get_delegation(struct nfs_delegation *delegation)
51
+{
52
+	refcount_inc(&delegation->refcount);
53
+	return delegation;
54
+}
55
+
56
+static void nfs_put_delegation(struct nfs_delegation *delegation)
57
+{
58
+	if (refcount_dec_and_test(&delegation->refcount))
59
+		__nfs_free_delegation(delegation);
60
+}
61
+
2762 static void nfs_free_delegation(struct nfs_delegation *delegation)
2863 {
29
-	if (delegation->cred) {
30
-		put_rpccred(delegation->cred);
31
-		delegation->cred = NULL;
32
-	}
33
-	kfree_rcu(delegation, rcu);
64
+	nfs_mark_delegation_revoked(delegation);
65
+	nfs_put_delegation(delegation);
3466 }
3567 
3668 /**
....@@ -41,6 +73,13 @@
4173 void nfs_mark_delegation_referenced(struct nfs_delegation *delegation)
4274 {
4375 	set_bit(NFS_DELEGATION_REFERENCED, &delegation->flags);
76
+}
77
+
78
+static void nfs_mark_return_delegation(struct nfs_server *server,
79
+				       struct nfs_delegation *delegation)
80
+{
81
+	set_bit(NFS_DELEGATION_RETURN, &delegation->flags);
82
+	set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
4483 }
4584 
4685 static bool
....@@ -146,8 +185,8 @@
146185 	int err;
147186 
148187 again:
149
-	spin_lock(&inode->i_lock);
150
-	list_for_each_entry(ctx, &nfsi->open_files, list) {
188
+	rcu_read_lock();
189
+	list_for_each_entry_rcu(ctx, &nfsi->open_files, list) {
151190 		state = ctx->state;
152191 		if (state == NULL)
153192 			continue;
....@@ -157,8 +196,9 @@
157196 			continue;
158197 		if (!nfs4_stateid_match(&state->stateid, stateid))
159198 			continue;
160
-		get_nfs_open_context(ctx);
161
-		spin_unlock(&inode->i_lock);
199
+		if (!get_nfs_open_context(ctx))
200
+			continue;
201
+		rcu_read_unlock();
162202 		sp = state->owner;
163203 		/* Block nfs4_proc_unlck */
164204 		mutex_lock(&sp->so_delegreturn_mutex);
....@@ -174,7 +214,7 @@
174214 			return err;
175215 		goto again;
176216 	}
177
-	spin_unlock(&inode->i_lock);
217
+	rcu_read_unlock();
178218 	return 0;
179219 }
180220 
....@@ -187,49 +227,51 @@
187227  * @pagemod_limit: write delegation "space_limit"
188228  *
189229  */
190
-void nfs_inode_reclaim_delegation(struct inode *inode, struct rpc_cred *cred,
191
-				  fmode_t type,
192
-				  const nfs4_stateid *stateid,
230
+void nfs_inode_reclaim_delegation(struct inode *inode, const struct cred *cred,
231
+				  fmode_t type, const nfs4_stateid *stateid,
193232 				  unsigned long pagemod_limit)
194233 {
195234 	struct nfs_delegation *delegation;
196
-	struct rpc_cred *oldcred = NULL;
235
+	const struct cred *oldcred = NULL;
197236 
198237 	rcu_read_lock();
199238 	delegation = rcu_dereference(NFS_I(inode)->delegation);
200239 	if (delegation != NULL) {
201240 		spin_lock(&delegation->lock);
202
-		if (delegation->inode != NULL) {
203
-			nfs4_stateid_copy(&delegation->stateid, stateid);
204
-			delegation->type = type;
205
-			delegation->pagemod_limit = pagemod_limit;
206
-			oldcred = delegation->cred;
207
-			delegation->cred = get_rpccred(cred);
208
-			clear_bit(NFS_DELEGATION_NEED_RECLAIM,
209
-				  &delegation->flags);
210
-			spin_unlock(&delegation->lock);
211
-			rcu_read_unlock();
212
-			put_rpccred(oldcred);
213
-			trace_nfs4_reclaim_delegation(inode, type);
214
-			return;
215
-		}
216
-		/* We appear to have raced with a delegation return. */
241
+		nfs4_stateid_copy(&delegation->stateid, stateid);
242
+		delegation->type = type;
243
+		delegation->pagemod_limit = pagemod_limit;
244
+		oldcred = delegation->cred;
245
+		delegation->cred = get_cred(cred);
246
+		clear_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags);
247
+		if (test_and_clear_bit(NFS_DELEGATION_REVOKED,
248
+				       &delegation->flags))
249
+			atomic_long_inc(&nfs_active_delegations);
217250 		spin_unlock(&delegation->lock);
251
+		rcu_read_unlock();
252
+		put_cred(oldcred);
253
+		trace_nfs4_reclaim_delegation(inode, type);
254
+	} else {
255
+		rcu_read_unlock();
256
+		nfs_inode_set_delegation(inode, cred, type, stateid,
257
+					 pagemod_limit);
218258 	}
219
-	rcu_read_unlock();
220
-	nfs_inode_set_delegation(inode, cred, type, stateid, pagemod_limit);
221259 }
222260 
223261 static int nfs_do_return_delegation(struct inode *inode, struct nfs_delegation *delegation, int issync)
224262 {
263
+	const struct cred *cred;
225264 	int res = 0;
226265 
227
-	if (!test_bit(NFS_DELEGATION_REVOKED, &delegation->flags))
228
-		res = nfs4_proc_delegreturn(inode,
229
-				delegation->cred,
266
+	if (!test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) {
267
+		spin_lock(&delegation->lock);
268
+		cred = get_cred(delegation->cred);
269
+		spin_unlock(&delegation->lock);
270
+		res = nfs4_proc_delegreturn(inode, cred,
230271 				&delegation->stateid,
231272 				issync);
232
-	nfs_free_delegation(delegation);
273
+		put_cred(cred);
274
+	}
233275 	return res;
234276 }
235277 
....@@ -255,9 +297,14 @@
255297 	if (delegation == NULL)
256298 		goto out;
257299 	spin_lock(&delegation->lock);
258
-	if (!test_and_set_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
259
-		ret = delegation;
300
+	if (!test_and_set_bit(NFS_DELEGATION_RETURNING, &delegation->flags)) {
301
+		clear_bit(NFS_DELEGATION_RETURN_DELAYED, &delegation->flags);
302
+		/* Refcount matched in nfs_end_delegation_return() */
303
+		ret = nfs_get_delegation(delegation);
304
+	}
260305 	spin_unlock(&delegation->lock);
306
+	if (ret)
307
+		nfs_clear_verifier_delegated(&nfsi->vfs_inode);
261308 out:
262309 	return ret;
263310 }
....@@ -273,16 +320,17 @@
273320 	return delegation;
274321 }
275322 
276
-static void
277
-nfs_abort_delegation_return(struct nfs_delegation *delegation,
278
-		struct nfs_client *clp)
323
+static void nfs_abort_delegation_return(struct nfs_delegation *delegation,
324
+					struct nfs_client *clp, int err)
279325 {
280326 
281327 	spin_lock(&delegation->lock);
282328 	clear_bit(NFS_DELEGATION_RETURNING, &delegation->flags);
283
-	set_bit(NFS_DELEGATION_RETURN, &delegation->flags);
329
+	if (err == -EAGAIN) {
330
+		set_bit(NFS_DELEGATION_RETURN_DELAYED, &delegation->flags);
331
+		set_bit(NFS4CLNT_DELEGRETURN_DELAYED, &clp->cl_state);
332
+	}
284333 	spin_unlock(&delegation->lock);
285
-	set_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state);
286334 }
287335 
288336 static struct nfs_delegation *
....@@ -298,7 +346,10 @@
298346 		return NULL;
299347 
300348 	spin_lock(&delegation->lock);
301
-	set_bit(NFS_DELEGATION_RETURNING, &delegation->flags);
349
+	if (!delegation->inode) {
350
+		spin_unlock(&delegation->lock);
351
+		return NULL;
352
+	}
302353 	list_del_rcu(&delegation->super_list);
303354 	delegation->inode = NULL;
304355 	rcu_assign_pointer(nfsi->delegation, NULL);
....@@ -325,10 +376,24 @@
325376 	struct nfs_server *server = NFS_SERVER(inode);
326377 	struct nfs_delegation *delegation;
327378 
328
-	delegation = nfs_start_delegation_return(nfsi);
329
-	if (delegation == NULL)
330
-		return NULL;
331
-	return nfs_detach_delegation(nfsi, delegation, server);
379
+	rcu_read_lock();
380
+	delegation = rcu_dereference(nfsi->delegation);
381
+	if (delegation != NULL)
382
+		delegation = nfs_detach_delegation(nfsi, delegation, server);
383
+	rcu_read_unlock();
384
+	return delegation;
385
+}
386
+
387
+static void
388
+nfs_update_delegation_cred(struct nfs_delegation *delegation,
389
+		const struct cred *cred)
390
+{
391
+	const struct cred *old;
392
+
393
+	if (cred_fscmp(delegation->cred, cred) != 0) {
394
+		old = xchg(&delegation->cred, get_cred(cred));
395
+		put_cred(old);
396
+	}
332397 }
333398 
334399 static void
....@@ -339,6 +404,14 @@
339404 		delegation->stateid.seqid = update->stateid.seqid;
340405 		smp_wmb();
341406 		delegation->type = update->type;
407
+		delegation->pagemod_limit = update->pagemod_limit;
408
+		if (test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) {
409
+			delegation->change_attr = update->change_attr;
410
+			nfs_update_delegation_cred(delegation, update->cred);
411
+			/* smp_mb__before_atomic() is implicit due to xchg() */
412
+			clear_bit(NFS_DELEGATION_REVOKED, &delegation->flags);
413
+			atomic_long_inc(&nfs_active_delegations);
414
+		}
342415 	}
343416 }
344417 
....@@ -352,7 +425,7 @@
352425  *
353426  * Returns zero on success, or a negative errno value.
354427  */
355
-int nfs_inode_set_delegation(struct inode *inode, struct rpc_cred *cred,
428
+int nfs_inode_set_delegation(struct inode *inode, const struct cred *cred,
356429 				  fmode_t type,
357430 				  const nfs4_stateid *stateid,
358431 				  unsigned long pagemod_limit)
....@@ -368,10 +441,11 @@
368441 	if (delegation == NULL)
369442 		return -ENOMEM;
370443 	nfs4_stateid_copy(&delegation->stateid, stateid);
444
+	refcount_set(&delegation->refcount, 1);
371445 	delegation->type = type;
372446 	delegation->pagemod_limit = pagemod_limit;
373447 	delegation->change_attr = inode_peek_iversion_raw(inode);
374
-	delegation->cred = get_rpccred(cred);
448
+	delegation->cred = get_cred(cred);
375449 	delegation->inode = inode;
376450 	delegation->flags = 1<<NFS_DELEGATION_REFERENCED;
377451 	spin_lock_init(&delegation->lock);
....@@ -379,14 +453,18 @@
379453 	spin_lock(&clp->cl_lock);
380454 	old_delegation = rcu_dereference_protected(nfsi->delegation,
381455 					lockdep_is_held(&clp->cl_lock));
382
-	if (old_delegation != NULL) {
383
-		/* Is this an update of the existing delegation? */
384
-		if (nfs4_stateid_match_other(&old_delegation->stateid,
385
-					&delegation->stateid)) {
386
-			nfs_update_inplace_delegation(old_delegation,
387
-					delegation);
388
-			goto out;
389
-		}
456
+	if (old_delegation == NULL)
457
+		goto add_new;
458
+	/* Is this an update of the existing delegation? */
459
+	if (nfs4_stateid_match_other(&old_delegation->stateid,
460
+				&delegation->stateid)) {
461
+		spin_lock(&old_delegation->lock);
462
+		nfs_update_inplace_delegation(old_delegation,
463
+				delegation);
464
+		spin_unlock(&old_delegation->lock);
465
+		goto out;
466
+	}
467
+	if (!test_bit(NFS_DELEGATION_REVOKED, &old_delegation->flags)) {
390468 		/*
391469 		 * Deal with broken servers that hand out two
392470 		 * delegations for the same file.
....@@ -405,14 +483,16 @@
405483 		if (test_and_set_bit(NFS_DELEGATION_RETURNING,
406484 					&old_delegation->flags))
407485 			goto out;
408
-		freeme = nfs_detach_delegation_locked(nfsi,
409
-				old_delegation, clp);
410
-		if (freeme == NULL)
411
-			goto out;
412486 	}
487
+	freeme = nfs_detach_delegation_locked(nfsi, old_delegation, clp);
488
+	if (freeme == NULL)
489
+		goto out;
490
+add_new:
413491 	list_add_tail_rcu(&delegation->super_list, &server->delegations);
414492 	rcu_assign_pointer(nfsi->delegation, delegation);
415493 	delegation = NULL;
494
+
495
+	atomic_long_inc(&nfs_active_delegations);
416496 
417497 	trace_nfs4_set_delegation(inode, type);
418498 
....@@ -423,9 +503,11 @@
423503 out:
424504 	spin_unlock(&clp->cl_lock);
425505 	if (delegation != NULL)
426
-		nfs_free_delegation(delegation);
427
-	if (freeme != NULL)
506
+		__nfs_free_delegation(delegation);
507
+	if (freeme != NULL) {
428508 		nfs_do_return_delegation(inode, freeme, 0);
509
+		nfs_free_delegation(freeme);
510
+	}
429511 	return status;
430512 }
431513 
....@@ -435,7 +517,6 @@
435517 static int nfs_end_delegation_return(struct inode *inode, struct nfs_delegation *delegation, int issync)
436518 {
437519 	struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
438
-	struct nfs_inode *nfsi = NFS_I(inode);
439520 	int err = 0;
440521 
441522 	if (delegation == NULL)
....@@ -454,14 +535,14 @@
454535 	} while (err == 0);
455536 
456537 	if (err) {
457
-		nfs_abort_delegation_return(delegation, clp);
538
+		nfs_abort_delegation_return(delegation, clp, err);
458539 		goto out;
459540 	}
460
-	if (!nfs_detach_delegation(nfsi, delegation, NFS_SERVER(inode)))
461
-		goto out;
462541 
463542 	err = nfs_do_return_delegation(inode, delegation, issync);
464543 out:
544
+	/* Refcount matched in nfs_start_delegation_return_locked() */
545
+	nfs_put_delegation(delegation);
465546 	return err;
466547 }
467548 
....@@ -469,11 +550,9 @@
469550 {
470551 	bool ret = false;
471552 
472
-	if (test_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
473
-		goto out;
474553 	if (test_and_clear_bit(NFS_DELEGATION_RETURN, &delegation->flags))
475554 		ret = true;
476
-	if (test_and_clear_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags) && !ret) {
555
+	else if (test_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags)) {
477556 		struct inode *inode;
478557 
479558 		spin_lock(&delegation->lock);
....@@ -482,6 +561,117 @@
482561 			ret = true;
483562 		spin_unlock(&delegation->lock);
484563 	}
564
+	if (ret)
565
+		clear_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags);
566
+	if (test_bit(NFS_DELEGATION_RETURNING, &delegation->flags) ||
567
+	    test_bit(NFS_DELEGATION_RETURN_DELAYED, &delegation->flags) ||
568
+	    test_bit(NFS_DELEGATION_REVOKED, &delegation->flags))
569
+		ret = false;
570
+
571
+	return ret;
572
+}
573
+
574
+static int nfs_server_return_marked_delegations(struct nfs_server *server,
575
+		void __always_unused *data)
576
+{
577
+	struct nfs_delegation *delegation;
578
+	struct nfs_delegation *prev;
579
+	struct inode *inode;
580
+	struct inode *place_holder = NULL;
581
+	struct nfs_delegation *place_holder_deleg = NULL;
582
+	int err = 0;
583
+
584
+restart:
585
+	/*
586
+	 * To avoid quadratic looping we hold a reference
587
+	 * to an inode place_holder.  Each time we restart, we
588
+	 * list delegation in the server from the delegations
589
+	 * of that inode.
590
+	 * prev is an RCU-protected pointer to a delegation which
591
+	 * wasn't marked for return and might be a good choice for
592
+	 * the next place_holder.
593
+	 */
594
+	prev = NULL;
595
+	delegation = NULL;
596
+	rcu_read_lock();
597
+	if (place_holder)
598
+		delegation = rcu_dereference(NFS_I(place_holder)->delegation);
599
+	if (!delegation || delegation != place_holder_deleg)
600
+		delegation = list_entry_rcu(server->delegations.next,
601
+					    struct nfs_delegation, super_list);
602
+	list_for_each_entry_from_rcu(delegation, &server->delegations, super_list) {
603
+		struct inode *to_put = NULL;
604
+
605
+		if (test_bit(NFS_DELEGATION_INODE_FREEING, &delegation->flags))
606
+			continue;
607
+		if (!nfs_delegation_need_return(delegation)) {
608
+			if (nfs4_is_valid_delegation(delegation, 0))
609
+				prev = delegation;
610
+			continue;
611
+		}
612
+
613
+		if (prev) {
614
+			struct inode *tmp = nfs_delegation_grab_inode(prev);
615
+			if (tmp) {
616
+				to_put = place_holder;
617
+				place_holder = tmp;
618
+				place_holder_deleg = prev;
619
+			}
620
+		}
621
+
622
+		inode = nfs_delegation_grab_inode(delegation);
623
+		if (inode == NULL) {
624
+			rcu_read_unlock();
625
+			iput(to_put);
626
+			goto restart;
627
+		}
628
+		delegation = nfs_start_delegation_return_locked(NFS_I(inode));
629
+		rcu_read_unlock();
630
+
631
+		iput(to_put);
632
+
633
+		err = nfs_end_delegation_return(inode, delegation, 0);
634
+		iput(inode);
635
+		cond_resched();
636
+		if (!err)
637
+			goto restart;
638
+		set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
639
+		goto out;
640
+	}
641
+	rcu_read_unlock();
642
+out:
643
+	iput(place_holder);
644
+	return err;
645
+}
646
+
647
+static bool nfs_server_clear_delayed_delegations(struct nfs_server *server)
648
+{
649
+	struct nfs_delegation *d;
650
+	bool ret = false;
651
+
652
+	list_for_each_entry_rcu (d, &server->delegations, super_list) {
653
+		if (!test_bit(NFS_DELEGATION_RETURN_DELAYED, &d->flags))
654
+			continue;
655
+		nfs_mark_return_delegation(server, d);
656
+		clear_bit(NFS_DELEGATION_RETURN_DELAYED, &d->flags);
657
+		ret = true;
658
+	}
659
+	return ret;
660
+}
661
+
662
+static bool nfs_client_clear_delayed_delegations(struct nfs_client *clp)
663
+{
664
+	struct nfs_server *server;
665
+	bool ret = false;
666
+
667
+	if (!test_and_clear_bit(NFS4CLNT_DELEGRETURN_DELAYED, &clp->cl_state))
668
+		goto out;
669
+	rcu_read_lock();
670
+	list_for_each_entry_rcu (server, &clp->cl_superblocks, client_link) {
671
+		if (nfs_server_clear_delayed_delegations(server))
672
+			ret = true;
673
+	}
674
+	rcu_read_unlock();
485675 out:
486676 	return ret;
487677 }
....@@ -498,106 +688,35 @@
498688  */
499689 int nfs_client_return_marked_delegations(struct nfs_client *clp)
500690 {
501
-	struct nfs_delegation *delegation;
502
-	struct nfs_delegation *prev;
503
-	struct nfs_server *server;
504
-	struct inode *inode;
505
-	struct inode *place_holder = NULL;
506
-	struct nfs_delegation *place_holder_deleg = NULL;
507
-	int err = 0;
508
-
509
-restart:
510
-	/*
511
-	 * To avoid quadratic looping we hold a reference
512
-	 * to an inode place_holder.  Each time we restart, we
513
-	 * list nfs_servers from the server of that inode, and
514
-	 * delegation in the server from the delegations of that
515
-	 * inode.
516
-	 * prev is an RCU-protected pointer to a delegation which
517
-	 * wasn't marked for return and might be a good choice for
518
-	 * the next place_holder.
519
-	 */
520
-	rcu_read_lock();
521
-	prev = NULL;
522
-	if (place_holder)
523
-		server = NFS_SERVER(place_holder);
524
-	else
525
-		server = list_entry_rcu(clp->cl_superblocks.next,
526
-					struct nfs_server, client_link);
527
-	list_for_each_entry_from_rcu(server, &clp->cl_superblocks, client_link) {
528
-		delegation = NULL;
529
-		if (place_holder && server == NFS_SERVER(place_holder))
530
-			delegation = rcu_dereference(NFS_I(place_holder)->delegation);
531
-		if (!delegation || delegation != place_holder_deleg)
532
-			delegation = list_entry_rcu(server->delegations.next,
533
-						    struct nfs_delegation, super_list);
534
-		list_for_each_entry_from_rcu(delegation, &server->delegations, super_list) {
535
-			struct inode *to_put = NULL;
536
-
537
-			if (!nfs_delegation_need_return(delegation)) {
538
-				prev = delegation;
539
-				continue;
540
-			}
541
-			if (!nfs_sb_active(server->super))
542
-				break; /* continue in outer loop */
543
-
544
-			if (prev) {
545
-				struct inode *tmp;
546
-
547
-				tmp = nfs_delegation_grab_inode(prev);
548
-				if (tmp) {
549
-					to_put = place_holder;
550
-					place_holder = tmp;
551
-					place_holder_deleg = prev;
552
-				}
553
-			}
554
-
555
-			inode = nfs_delegation_grab_inode(delegation);
556
-			if (inode == NULL) {
557
-				rcu_read_unlock();
558
-				if (to_put)
559
-					iput(to_put);
560
-				nfs_sb_deactive(server->super);
561
-				goto restart;
562
-			}
563
-			delegation = nfs_start_delegation_return_locked(NFS_I(inode));
564
-			rcu_read_unlock();
565
-
566
-			if (to_put)
567
-				iput(to_put);
568
-
569
-			err = nfs_end_delegation_return(inode, delegation, 0);
570
-			iput(inode);
571
-			nfs_sb_deactive(server->super);
572
-			cond_resched();
573
-			if (!err)
574
-				goto restart;
575
-			set_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state);
576
-			if (place_holder)
577
-				iput(place_holder);
578
-			return err;
579
-		}
580
-	}
581
-	rcu_read_unlock();
582
-	if (place_holder)
583
-		iput(place_holder);
691
+	int err = nfs_client_for_each_server(
692
+		clp, nfs_server_return_marked_delegations, NULL);
693
+	if (err)
694
+		return err;
695
+	/* If a return was delayed, sleep to prevent hard looping */
696
+	if (nfs_client_clear_delayed_delegations(clp))
697
+		ssleep(1);
584698 	return 0;
585699 }
586700 
587701 /**
588
- * nfs_inode_return_delegation_noreclaim - return delegation, don't reclaim opens
702
+ * nfs_inode_evict_delegation - return delegation, don't reclaim opens
589703  * @inode: inode to process
590704  *
591705  * Does not protect against delegation reclaims, therefore really only safe
592
- * to be called from nfs4_clear_inode().
706
+ * to be called from nfs4_clear_inode(). Guaranteed to always free
707
+ * the delegation structure.
593708  */
594
-void nfs_inode_return_delegation_noreclaim(struct inode *inode)
709
+void nfs_inode_evict_delegation(struct inode *inode)
595710 {
596711 	struct nfs_delegation *delegation;
597712 
598713 	delegation = nfs_inode_detach_delegation(inode);
599
-	if (delegation != NULL)
714
+	if (delegation != NULL) {
715
+		set_bit(NFS_DELEGATION_RETURNING, &delegation->flags);
716
+		set_bit(NFS_DELEGATION_INODE_FREEING, &delegation->flags);
600717 		nfs_do_return_delegation(inode, delegation, 1);
718
+		nfs_free_delegation(delegation);
719
+	}
601720 }
602721 
603722 /**
....@@ -624,6 +743,43 @@
624743 }
625744 
626745 /**
746
+ * nfs_inode_return_delegation_on_close - asynchronously return a delegation
747
+ * @inode: inode to process
748
+ *
749
+ * This routine is called on file close in order to determine if the
750
+ * inode delegation needs to be returned immediately.
751
+ */
752
+void nfs4_inode_return_delegation_on_close(struct inode *inode)
753
+{
754
+	struct nfs_delegation *delegation;
755
+	struct nfs_delegation *ret = NULL;
756
+
757
+	if (!inode)
758
+		return;
759
+	rcu_read_lock();
760
+	delegation = nfs4_get_valid_delegation(inode);
761
+	if (!delegation)
762
+		goto out;
763
+	if (test_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags) ||
764
+	    atomic_long_read(&nfs_active_delegations) >= nfs_delegation_watermark) {
765
+		spin_lock(&delegation->lock);
766
+		if (delegation->inode &&
767
+		    list_empty(&NFS_I(inode)->open_files) &&
768
+		    !test_and_set_bit(NFS_DELEGATION_RETURNING, &delegation->flags)) {
769
+			clear_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags);
770
+			/* Refcount matched in nfs_end_delegation_return() */
771
+			ret = nfs_get_delegation(delegation);
772
+		}
773
+		spin_unlock(&delegation->lock);
774
+		if (ret)
775
+			nfs_clear_verifier_delegated(inode);
776
+	}
777
+out:
778
+	rcu_read_unlock();
779
+	nfs_end_delegation_return(inode, ret, 0);
780
+}
781
+
782
+/**
627783  * nfs4_inode_make_writeable
628784  * @inode: pointer to inode
629785  *
....@@ -633,23 +789,24 @@
633789  */
634790 int nfs4_inode_make_writeable(struct inode *inode)
635791 {
636
-	if (!nfs4_has_session(NFS_SERVER(inode)->nfs_client) ||
637
-	    !nfs4_check_delegation(inode, FMODE_WRITE))
638
-		return nfs4_inode_return_delegation(inode);
639
-	return 0;
792
+	struct nfs_delegation *delegation;
793
+
794
+	rcu_read_lock();
795
+	delegation = nfs4_get_valid_delegation(inode);
796
+	if (delegation == NULL ||
797
+	    (nfs4_has_session(NFS_SERVER(inode)->nfs_client) &&
798
+	     (delegation->type & FMODE_WRITE))) {
799
+		rcu_read_unlock();
800
+		return 0;
801
+	}
802
+	rcu_read_unlock();
803
+	return nfs4_inode_return_delegation(inode);
640804 }
641805 
642806 static void nfs_mark_return_if_closed_delegation(struct nfs_server *server,
643807 		struct nfs_delegation *delegation)
644808 {
645809 	set_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags);
646
-	set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
647
-}
648
-
649
-static void nfs_mark_return_delegation(struct nfs_server *server,
650
-		struct nfs_delegation *delegation)
651
-{
652
-	set_bit(NFS_DELEGATION_RETURN, &delegation->flags);
653810 	set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
654811 }
655812 
....@@ -694,7 +851,7 @@
694851 
695852 /**
696853  * nfs_super_return_all_delegations - return delegations for one superblock
697
- * @sb: sb to process
854
+ * @server: pointer to nfs_server to process
698855  *
699856  */
700857 void nfs_server_return_all_delegations(struct nfs_server *server)
....@@ -739,15 +896,7 @@
739896 	rcu_read_unlock();
740897 }
741898 
742
-static void nfs_mark_delegation_revoked(struct nfs_server *server,
743
-		struct nfs_delegation *delegation)
744
-{
745
-	set_bit(NFS_DELEGATION_REVOKED, &delegation->flags);
746
-	delegation->stateid.type = NFS4_INVALID_STATEID_TYPE;
747
-	nfs_mark_return_delegation(server, delegation);
748
-}
749
-
750
-static bool nfs_revoke_delegation(struct inode *inode,
899
+static void nfs_revoke_delegation(struct inode *inode,
751900 		const nfs4_stateid *stateid)
752901 {
753902 	struct nfs_delegation *delegation;
....@@ -761,29 +910,69 @@
761910 	if (stateid == NULL) {
762911 		nfs4_stateid_copy(&tmp, &delegation->stateid);
763912 		stateid = &tmp;
764
-	} else if (!nfs4_stateid_match(stateid, &delegation->stateid))
765
-		goto out;
766
-	nfs_mark_delegation_revoked(NFS_SERVER(inode), delegation);
913
+	} else {
914
+		if (!nfs4_stateid_match_other(stateid, &delegation->stateid))
915
+			goto out;
916
+		spin_lock(&delegation->lock);
917
+		if (stateid->seqid) {
918
+			if (nfs4_stateid_is_newer(&delegation->stateid, stateid)) {
919
+				spin_unlock(&delegation->lock);
920
+				goto out;
921
+			}
922
+			delegation->stateid.seqid = stateid->seqid;
923
+		}
924
+		spin_unlock(&delegation->lock);
925
+	}
926
+	nfs_mark_delegation_revoked(delegation);
767927 	ret = true;
768928 out:
769929 	rcu_read_unlock();
770930 	if (ret)
771931 		nfs_inode_find_state_and_recover(inode, stateid);
772
-	return ret;
773932 }
774933 
775934 void nfs_remove_bad_delegation(struct inode *inode,
776935 		const nfs4_stateid *stateid)
777936 {
778
-	struct nfs_delegation *delegation;
779
-
780
-	if (!nfs_revoke_delegation(inode, stateid))
781
-		return;
782
-	delegation = nfs_inode_detach_delegation(inode);
783
-	if (delegation)
784
-		nfs_free_delegation(delegation);
937
+	nfs_revoke_delegation(inode, stateid);
785938 }
786939 EXPORT_SYMBOL_GPL(nfs_remove_bad_delegation);
940
+
941
+void nfs_delegation_mark_returned(struct inode *inode,
942
+		const nfs4_stateid *stateid)
943
+{
944
+	struct nfs_delegation *delegation;
945
+
946
+	if (!inode)
947
+		return;
948
+
949
+	rcu_read_lock();
950
+	delegation = rcu_dereference(NFS_I(inode)->delegation);
951
+	if (!delegation)
952
+		goto out_rcu_unlock;
953
+
954
+	spin_lock(&delegation->lock);
955
+	if (!nfs4_stateid_match_other(stateid, &delegation->stateid))
956
+		goto out_spin_unlock;
957
+	if (stateid->seqid) {
958
+		/* If delegation->stateid is newer, dont mark as returned */
959
+		if (nfs4_stateid_is_newer(&delegation->stateid, stateid))
960
+			goto out_clear_returning;
961
+		if (delegation->stateid.seqid != stateid->seqid)
962
+			delegation->stateid.seqid = stateid->seqid;
963
+	}
964
+
965
+	nfs_mark_delegation_revoked(delegation);
966
+
967
+out_clear_returning:
968
+	clear_bit(NFS_DELEGATION_RETURNING, &delegation->flags);
969
+out_spin_unlock:
970
+	spin_unlock(&delegation->lock);
971
+out_rcu_unlock:
972
+	rcu_read_unlock();
973
+
974
+	nfs_inode_find_state_and_recover(inode, stateid);
975
+}
787976 
788977 /**
789978  * nfs_expire_unused_delegation_types
....@@ -840,7 +1029,7 @@
8401029 	struct nfs_delegation *delegation;
8411030 
8421031 	rcu_read_lock();
843
-	delegation = rcu_dereference(NFS_I(inode)->delegation);
1032
+	delegation = nfs4_get_valid_delegation(inode);
8441033 	if (delegation == NULL)
8451034 		goto out_enoent;
8461035 	if (stateid != NULL &&
....@@ -861,21 +1050,24 @@
8611050 				 const struct nfs_fh *fhandle)
8621051 {
8631052 	struct nfs_delegation *delegation;
864
-	struct inode *freeme, *res = NULL;
1053
+	struct super_block *freeme = NULL;
1054
+	struct inode *res = NULL;
8651055 
8661056 	list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
8671057 		spin_lock(&delegation->lock);
8681058 		if (delegation->inode != NULL &&
1059
+		    !test_bit(NFS_DELEGATION_REVOKED, &delegation->flags) &&
8691060 		    nfs_compare_fh(fhandle, &NFS_I(delegation->inode)->fh) == 0) {
870
-			freeme = igrab(delegation->inode);
871
-			if (freeme && nfs_sb_active(freeme->i_sb))
872
-				res = freeme;
1061
+			if (nfs_sb_active(server->super)) {
1062
+				freeme = server->super;
1063
+				res = igrab(delegation->inode);
1064
+			}
8731065 			spin_unlock(&delegation->lock);
8741066 			if (res != NULL)
8751067 				return res;
8761068 			if (freeme) {
8771069 				rcu_read_unlock();
878
-				iput(freeme);
1070
+				nfs_sb_deactive(freeme);
8791071 				rcu_read_lock();
8801072 			}
8811073 			return ERR_PTR(-EAGAIN);
....@@ -941,6 +1133,42 @@
9411133 	rcu_read_unlock();
9421134 }
9431135 
1136
+static int nfs_server_reap_unclaimed_delegations(struct nfs_server *server,
1137
+		void __always_unused *data)
1138
+{
1139
+	struct nfs_delegation *delegation;
1140
+	struct inode *inode;
1141
+restart:
1142
+	rcu_read_lock();
1143
+restart_locked:
1144
+	list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
1145
+		if (test_bit(NFS_DELEGATION_INODE_FREEING,
1146
+					&delegation->flags) ||
1147
+		    test_bit(NFS_DELEGATION_RETURNING,
1148
+					&delegation->flags) ||
1149
+		    test_bit(NFS_DELEGATION_NEED_RECLAIM,
1150
+					&delegation->flags) == 0)
1151
+			continue;
1152
+		inode = nfs_delegation_grab_inode(delegation);
1153
+		if (inode == NULL)
1154
+			goto restart_locked;
1155
+		delegation = nfs_start_delegation_return_locked(NFS_I(inode));
1156
+		rcu_read_unlock();
1157
+		if (delegation != NULL) {
1158
+			if (nfs_detach_delegation(NFS_I(inode), delegation,
1159
+						server) != NULL)
1160
+				nfs_free_delegation(delegation);
1161
+			/* Match nfs_start_delegation_return_locked */
1162
+			nfs_put_delegation(delegation);
1163
+		}
1164
+		iput(inode);
1165
+		cond_resched();
1166
+		goto restart;
1167
+	}
1168
+	rcu_read_unlock();
1169
+	return 0;
1170
+}
1171
+
9441172 /**
9451173  * nfs_delegation_reap_unclaimed - reap unclaimed delegations after reboot recovery is done
9461174  * @clp: nfs_client to process
....@@ -948,45 +1176,8 @@
9481176  */
9491177 void nfs_delegation_reap_unclaimed(struct nfs_client *clp)
9501178 {
951
-	struct nfs_delegation *delegation;
952
-	struct nfs_server *server;
953
-	struct inode *inode;
954
-
955
-restart:
956
-	rcu_read_lock();
957
-	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
958
-		list_for_each_entry_rcu(delegation, &server->delegations,
959
-								super_list) {
960
-			if (test_bit(NFS_DELEGATION_INODE_FREEING,
961
-						&delegation->flags) ||
962
-			    test_bit(NFS_DELEGATION_RETURNING,
963
-						&delegation->flags) ||
964
-			    test_bit(NFS_DELEGATION_NEED_RECLAIM,
965
-						&delegation->flags) == 0)
966
-				continue;
967
-			if (!nfs_sb_active(server->super))
968
-				break; /* continue in outer loop */
969
-			inode = nfs_delegation_grab_inode(delegation);
970
-			if (inode == NULL) {
971
-				rcu_read_unlock();
972
-				nfs_sb_deactive(server->super);
973
-				goto restart;
974
-			}
975
-			delegation = nfs_start_delegation_return_locked(NFS_I(inode));
976
-			rcu_read_unlock();
977
-			if (delegation != NULL) {
978
-				delegation = nfs_detach_delegation(NFS_I(inode),
979
-					delegation, server);
980
-				if (delegation != NULL)
981
-					nfs_free_delegation(delegation);
982
-			}
983
-			iput(inode);
984
-			nfs_sb_deactive(server->super);
985
-			cond_resched();
986
-			goto restart;
987
-		}
988
-	}
989
-	rcu_read_unlock();
1179
+	nfs_client_for_each_server(clp, nfs_server_reap_unclaimed_delegations,
1180
+			NULL);
9901181 }
9911182 
9921183 static inline bool nfs4_server_rebooted(const struct nfs_client *clp)
....@@ -1045,6 +1236,76 @@
10451236 }
10461237 
10471238 /**
1239
+ * nfs_test_expired_all_delegations - test all delegations for a client
1240
+ * @clp: nfs_client to process
1241
+ *
1242
+ * Helper for handling "recallable state revoked" status from server.
1243
+ */
1244
+void nfs_test_expired_all_delegations(struct nfs_client *clp)
1245
+{
1246
+	nfs_mark_test_expired_all_delegations(clp);
1247
+	nfs4_schedule_state_manager(clp);
1248
+}
1249
+
1250
+static void
1251
+nfs_delegation_test_free_expired(struct inode *inode,
1252
+		nfs4_stateid *stateid,
1253
+		const struct cred *cred)
1254
+{
1255
+	struct nfs_server *server = NFS_SERVER(inode);
1256
+	const struct nfs4_minor_version_ops *ops = server->nfs_client->cl_mvops;
1257
+	int status;
1258
+
1259
+	if (!cred)
1260
+		return;
1261
+	status = ops->test_and_free_expired(server, stateid, cred);
1262
+	if (status == -NFS4ERR_EXPIRED || status == -NFS4ERR_BAD_STATEID)
1263
+		nfs_remove_bad_delegation(inode, stateid);
1264
+}
1265
+
1266
+static int nfs_server_reap_expired_delegations(struct nfs_server *server,
1267
+		void __always_unused *data)
1268
+{
1269
+	struct nfs_delegation *delegation;
1270
+	struct inode *inode;
1271
+	const struct cred *cred;
1272
+	nfs4_stateid stateid;
1273
+restart:
1274
+	rcu_read_lock();
1275
+restart_locked:
1276
+	list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
1277
+		if (test_bit(NFS_DELEGATION_INODE_FREEING,
1278
+					&delegation->flags) ||
1279
+		    test_bit(NFS_DELEGATION_RETURNING,
1280
+					&delegation->flags) ||
1281
+		    test_bit(NFS_DELEGATION_TEST_EXPIRED,
1282
+					&delegation->flags) == 0)
1283
+			continue;
1284
+		inode = nfs_delegation_grab_inode(delegation);
1285
+		if (inode == NULL)
1286
+			goto restart_locked;
1287
+		spin_lock(&delegation->lock);
1288
+		cred = get_cred_rcu(delegation->cred);
1289
+		nfs4_stateid_copy(&stateid, &delegation->stateid);
1290
+		spin_unlock(&delegation->lock);
1291
+		clear_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags);
1292
+		rcu_read_unlock();
1293
+		nfs_delegation_test_free_expired(inode, &stateid, cred);
1294
+		put_cred(cred);
1295
+		if (!nfs4_server_rebooted(server->nfs_client)) {
1296
+			iput(inode);
1297
+			cond_resched();
1298
+			goto restart;
1299
+		}
1300
+		nfs_inode_mark_test_expired_delegation(server,inode);
1301
+		iput(inode);
1302
+		return -EAGAIN;
1303
+	}
1304
+	rcu_read_unlock();
1305
+	return 0;
1306
+}
1307
+
1308
+/**
10481309  * nfs_reap_expired_delegations - reap expired delegations
10491310  * @clp: nfs_client to process
10501311  *
....@@ -1055,56 +1316,8 @@
10551316  */
10561317 void nfs_reap_expired_delegations(struct nfs_client *clp)
10571318 {
1058
-	const struct nfs4_minor_version_ops *ops = clp->cl_mvops;
1059
-	struct nfs_delegation *delegation;
1060
-	struct nfs_server *server;
1061
-	struct inode *inode;
1062
-	struct rpc_cred *cred;
1063
-	nfs4_stateid stateid;
1064
-
1065
-restart:
1066
-	rcu_read_lock();
1067
-	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
1068
-		list_for_each_entry_rcu(delegation, &server->delegations,
1069
-								super_list) {
1070
-			if (test_bit(NFS_DELEGATION_INODE_FREEING,
1071
-						&delegation->flags) ||
1072
-			    test_bit(NFS_DELEGATION_RETURNING,
1073
-						&delegation->flags) ||
1074
-			    test_bit(NFS_DELEGATION_TEST_EXPIRED,
1075
-						&delegation->flags) == 0)
1076
-				continue;
1077
-			if (!nfs_sb_active(server->super))
1078
-				break; /* continue in outer loop */
1079
-			inode = nfs_delegation_grab_inode(delegation);
1080
-			if (inode == NULL) {
1081
-				rcu_read_unlock();
1082
-				nfs_sb_deactive(server->super);
1083
-				goto restart;
1084
-			}
1085
-			cred = get_rpccred_rcu(delegation->cred);
1086
-			nfs4_stateid_copy(&stateid, &delegation->stateid);
1087
-			clear_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags);
1088
-			rcu_read_unlock();
1089
-			if (cred != NULL &&
1090
-			    ops->test_and_free_expired(server, &stateid, cred) < 0) {
1091
-				nfs_revoke_delegation(inode, &stateid);
1092
-				nfs_inode_find_state_and_recover(inode, &stateid);
1093
-			}
1094
-			put_rpccred(cred);
1095
-			if (nfs4_server_rebooted(clp)) {
1096
-				nfs_inode_mark_test_expired_delegation(server,inode);
1097
-				iput(inode);
1098
-				nfs_sb_deactive(server->super);
1099
-				return;
1100
-			}
1101
-			iput(inode);
1102
-			nfs_sb_deactive(server->super);
1103
-			cond_resched();
1104
-			goto restart;
1105
-		}
1106
-	}
1107
-	rcu_read_unlock();
1319
+	nfs_client_for_each_server(clp, nfs_server_reap_expired_delegations,
1320
+			NULL);
11081321 }
11091322 
11101323 void nfs_inode_find_delegation_state_and_recover(struct inode *inode,
....@@ -1117,7 +1330,8 @@
11171330 	rcu_read_lock();
11181331 	delegation = rcu_dereference(NFS_I(inode)->delegation);
11191332 	if (delegation &&
1120
-	    nfs4_stateid_match_other(&delegation->stateid, stateid)) {
1333
+	    nfs4_stateid_match_or_older(&delegation->stateid, stateid) &&
1334
+	    !test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) {
11211335 		nfs_mark_test_expired_delegation(NFS_SERVER(inode), delegation);
11221336 		found = true;
11231337 	}
....@@ -1166,7 +1380,9 @@
11661380 	rcu_read_lock();
11671381 	delegation = rcu_dereference(NFS_I(inode)->delegation);
11681382 	if (delegation != NULL &&
1169
-	    nfs4_stateid_match_other(dst, &delegation->stateid)) {
1383
+	    nfs4_stateid_match_other(dst, &delegation->stateid) &&
1384
+	    nfs4_stateid_is_newer(&delegation->stateid, dst) &&
1385
+	    !test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) {
11701386 		dst->seqid = delegation->stateid.seqid;
11711387 		ret = true;
11721388 	}
....@@ -1186,22 +1402,27 @@
11861402  * otherwise "false" is returned.
11871403  */
11881404 bool nfs4_copy_delegation_stateid(struct inode *inode, fmode_t flags,
1189
-		nfs4_stateid *dst, struct rpc_cred **cred)
1405
+		nfs4_stateid *dst, const struct cred **cred)
11901406 {
11911407 	struct nfs_inode *nfsi = NFS_I(inode);
11921408 	struct nfs_delegation *delegation;
1193
-	bool ret;
1409
+	bool ret = false;
11941410 
11951411 	flags &= FMODE_READ|FMODE_WRITE;
11961412 	rcu_read_lock();
11971413 	delegation = rcu_dereference(nfsi->delegation);
1414
+	if (!delegation)
1415
+		goto out;
1416
+	spin_lock(&delegation->lock);
11981417 	ret = nfs4_is_valid_delegation(delegation, flags);
11991418 	if (ret) {
12001419 		nfs4_stateid_copy(dst, &delegation->stateid);
12011420 		nfs_mark_delegation_referenced(delegation);
12021421 		if (cred)
1203
-			*cred = get_rpccred(delegation->cred);
1422
+			*cred = get_cred(delegation->cred);
12041423 	}
1424
+	spin_unlock(&delegation->lock);
1425
+out:
12051426 	rcu_read_unlock();
12061427 	return ret;
12071428 }
....@@ -1230,3 +1451,5 @@
12301451 	rcu_read_unlock();
12311452 	return ret;
12321453 }
1454
+
1455
+module_param_named(delegation_watermark, nfs_delegation_watermark, uint, 0644);