update kernel to 5.10.198

hc

2024-01-03 2f7c68cb55ecb7331f2381deb497c27155f32faf

 kernel/drivers/nvme/target/fcloop.c
..
..
@@ -570,10 +570,11 @@
570
570
 	struct fcloop_fcpreq *tfcp_req =
571
571
 		container_of(work, struct fcloop_fcpreq, fcp_rcv_work);
572
572
 	struct nvmefc_fcp_req *fcpreq = tfcp_req->fcpreq;
573
+	unsigned long flags;
573
574
 	int ret = 0;
574
575
 	bool aborted = false;
575
576
 
576
-	spin_lock_irq(&tfcp_req->reqlock);
577
+	spin_lock_irqsave(&tfcp_req->reqlock, flags);
577
578
 	switch (tfcp_req->inistate) {
578
579
 	case INI_IO_START:
579
580
 		tfcp_req->inistate = INI_IO_ACTIVE;
..
..
@@ -582,11 +583,11 @@
582
583
 		aborted = true;
583
584
 		break;
584
585
 	default:
585
-		spin_unlock_irq(&tfcp_req->reqlock);
586
+		spin_unlock_irqrestore(&tfcp_req->reqlock, flags);
586
587
 		WARN_ON(1);
587
588
 		return;
588
589
 	}
589
-	spin_unlock_irq(&tfcp_req->reqlock);
590
+	spin_unlock_irqrestore(&tfcp_req->reqlock, flags);
590
591
 
591
592
 	if (unlikely(aborted))
592
593
 		ret = -ECANCELED;
..
..
@@ -607,8 +608,9 @@
607
608
 		container_of(work, struct fcloop_fcpreq, abort_rcv_work);
608
609
 	struct nvmefc_fcp_req *fcpreq;
609
610
 	bool completed = false;
611
+	unsigned long flags;
610
612
 
611
-	spin_lock_irq(&tfcp_req->reqlock);
613
+	spin_lock_irqsave(&tfcp_req->reqlock, flags);
612
614
 	fcpreq = tfcp_req->fcpreq;
613
615
 	switch (tfcp_req->inistate) {
614
616
 	case INI_IO_ABORTED:
..
..
@@ -617,11 +619,11 @@
617
619
 		completed = true;
618
620
 		break;
619
621
 	default:
620
-		spin_unlock_irq(&tfcp_req->reqlock);
622
+		spin_unlock_irqrestore(&tfcp_req->reqlock, flags);
621
623
 		WARN_ON(1);
622
624
 		return;
623
625
 	}
624
-	spin_unlock_irq(&tfcp_req->reqlock);
626
+	spin_unlock_irqrestore(&tfcp_req->reqlock, flags);
625
627
 
626
628
 	if (unlikely(completed)) {
627
629
 		/* remove reference taken in original abort downcall */
..
..
@@ -633,9 +635,9 @@
633
635
 		nvmet_fc_rcv_fcp_abort(tfcp_req->tport->targetport,
634
636
 					&tfcp_req->tgt_fcp_req);
635
637
 
636
-	spin_lock_irq(&tfcp_req->reqlock);
638
+	spin_lock_irqsave(&tfcp_req->reqlock, flags);
637
639
 	tfcp_req->fcpreq = NULL;
638
-	spin_unlock_irq(&tfcp_req->reqlock);
640
+	spin_unlock_irqrestore(&tfcp_req->reqlock, flags);
639
641
 
640
642
 	fcloop_call_host_done(fcpreq, tfcp_req, -ECANCELED);
641
643
 	/* call_host_done releases reference for abort downcall */
..
..
@@ -651,11 +653,12 @@
651
653
 	struct fcloop_fcpreq *tfcp_req =
652
654
 		container_of(work, struct fcloop_fcpreq, tio_done_work);
653
655
 	struct nvmefc_fcp_req *fcpreq;
656
+	unsigned long flags;
654
657
 
655
-	spin_lock_irq(&tfcp_req->reqlock);
658
+	spin_lock_irqsave(&tfcp_req->reqlock, flags);
656
659
 	fcpreq = tfcp_req->fcpreq;
657
660
 	tfcp_req->inistate = INI_IO_COMPLETED;
658
-	spin_unlock_irq(&tfcp_req->reqlock);
661
+	spin_unlock_irqrestore(&tfcp_req->reqlock, flags);
659
662
 
660
663
 	fcloop_call_host_done(fcpreq, tfcp_req, tfcp_req->status);
661
664
 }
..
..
@@ -759,13 +762,14 @@
759
762
 	u32 rsplen = 0, xfrlen = 0;
760
763
 	int fcp_err = 0, active, aborted;
761
764
 	u8 op = tgt_fcpreq->op;
765
+	unsigned long flags;
762
766
 
763
-	spin_lock_irq(&tfcp_req->reqlock);
767
+	spin_lock_irqsave(&tfcp_req->reqlock, flags);
764
768
 	fcpreq = tfcp_req->fcpreq;
765
769
 	active = tfcp_req->active;
766
770
 	aborted = tfcp_req->aborted;
767
771
 	tfcp_req->active = true;
768
-	spin_unlock_irq(&tfcp_req->reqlock);
772
+	spin_unlock_irqrestore(&tfcp_req->reqlock, flags);
769
773
 
770
774
 	if (unlikely(active))
771
775
 		/* illegal - call while i/o active */
..
..
@@ -773,9 +777,9 @@
773
777
 
774
778
 	if (unlikely(aborted)) {
775
779
 		/* target transport has aborted i/o prior */
776
-		spin_lock_irq(&tfcp_req->reqlock);
780
+		spin_lock_irqsave(&tfcp_req->reqlock, flags);
777
781
 		tfcp_req->active = false;
778
-		spin_unlock_irq(&tfcp_req->reqlock);
782
+		spin_unlock_irqrestore(&tfcp_req->reqlock, flags);
779
783
 		tgt_fcpreq->transferred_length = 0;
780
784
 		tgt_fcpreq->fcp_error = -ECANCELED;
781
785
 		tgt_fcpreq->done(tgt_fcpreq);
..
..
@@ -832,9 +836,9 @@
832
836
 		break;
833
837
 	}
834
838
 
835
-	spin_lock_irq(&tfcp_req->reqlock);
839
+	spin_lock_irqsave(&tfcp_req->reqlock, flags);
836
840
 	tfcp_req->active = false;
837
-	spin_unlock_irq(&tfcp_req->reqlock);
841
+	spin_unlock_irqrestore(&tfcp_req->reqlock, flags);
838
842
 
839
843
 	tgt_fcpreq->transferred_length = xfrlen;
840
844
 	tgt_fcpreq->fcp_error = fcp_err;
..
..
@@ -848,15 +852,16 @@
848
852
 			struct nvmefc_tgt_fcp_req *tgt_fcpreq)
849
853
 {
850
854
 	struct fcloop_fcpreq *tfcp_req = tgt_fcp_req_to_fcpreq(tgt_fcpreq);
855
+	unsigned long flags;
851
856
 
852
857
 	/*
853
858
 	 * mark aborted only in case there were 2 threads in transport
854
859
 	 * (one doing io, other doing abort) and only kills ops posted
855
860
 	 * after the abort request
856
861
 	 */
857
-	spin_lock_irq(&tfcp_req->reqlock);
862
+	spin_lock_irqsave(&tfcp_req->reqlock, flags);
858
863
 	tfcp_req->aborted = true;
859
-	spin_unlock_irq(&tfcp_req->reqlock);
864
+	spin_unlock_irqrestore(&tfcp_req->reqlock, flags);
860
865
 
861
866
 	tfcp_req->status = NVME_SC_INTERNAL;
862
867
 
..
..
@@ -898,6 +903,7 @@
898
903
 	struct fcloop_ini_fcpreq *inireq = fcpreq->private;
899
904
 	struct fcloop_fcpreq *tfcp_req;
900
905
 	bool abortio = true;
906
+	unsigned long flags;
901
907
 
902
908
 	spin_lock(&inireq->inilock);
903
909
 	tfcp_req = inireq->tfcp_req;
..
..
@@ -910,7 +916,7 @@
910
916
 		return;
911
917
 
912
918
 	/* break initiator/target relationship for io */
913
-	spin_lock_irq(&tfcp_req->reqlock);
919
+	spin_lock_irqsave(&tfcp_req->reqlock, flags);
914
920
 	switch (tfcp_req->inistate) {
915
921
 	case INI_IO_START:
916
922
 	case INI_IO_ACTIVE:
..
..
@@ -920,11 +926,11 @@
920
926
 		abortio = false;
921
927
 		break;
922
928
 	default:
923
-		spin_unlock_irq(&tfcp_req->reqlock);
929
+		spin_unlock_irqrestore(&tfcp_req->reqlock, flags);
924
930
 		WARN_ON(1);
925
931
 		return;
926
932
 	}
927
-	spin_unlock_irq(&tfcp_req->reqlock);
933
+	spin_unlock_irqrestore(&tfcp_req->reqlock, flags);
928
934
 
929
935
 	if (abortio)
930
936
 		/* leave the reference while the work item is scheduled */