kernel_5.10 no rt

hc

2023-12-11 6778948f9de86c3cfaf36725a7c87dcff9ba247f

 kernel/fs/ceph/snap.c
..
..
@@ -3,11 +3,13 @@
3
3
 
4
4
 #include <linux/sort.h>
5
5
 #include <linux/slab.h>
6
-
6
+#include <linux/iversion.h>
7
7
 #include "super.h"
8
8
 #include "mds_client.h"
9
-
10
9
 #include <linux/ceph/decode.h>
10
+
11
+/* unused map expires after 5 minutes */
12
+#define CEPH_SNAPID_MAP_TIMEOUT	(5 * 60 * HZ)
11
13
 
12
14
 /*
13
15
  * Snapshots in ceph are driven in large part by cooperation from the
..
..
@@ -58,24 +60,26 @@
58
60
 /*
59
61
  * increase ref count for the realm
60
62
  *
61
- * caller must hold snap_rwsem for write.
63
+ * caller must hold snap_rwsem.
62
64
  */
63
65
 void ceph_get_snap_realm(struct ceph_mds_client *mdsc,
64
66
 			 struct ceph_snap_realm *realm)
65
67
 {
66
-	dout("get_realm %p %d -> %d\n", realm,
67
-	     atomic_read(&realm->nref), atomic_read(&realm->nref)+1);
68
+	lockdep_assert_held(&mdsc->snap_rwsem);
69
+
68
70
 	/*
69
-	 * since we _only_ increment realm refs or empty the empty
70
-	 * list with snap_rwsem held, adjusting the empty list here is
71
-	 * safe.  we do need to protect against concurrent empty list
72
-	 * additions, however.
71
+	 * The 0->1 and 1->0 transitions must take the snap_empty_lock
72
+	 * atomically with the refcount change. Go ahead and bump the
73
+	 * nref here, unless it's 0, in which case we take the spinlock
74
+	 * and then do the increment and remove it from the list.
73
75
 	 */
74
-	if (atomic_inc_return(&realm->nref) == 1) {
75
-		spin_lock(&mdsc->snap_empty_lock);
76
+	if (atomic_inc_not_zero(&realm->nref))
77
+		return;
78
+
79
+	spin_lock(&mdsc->snap_empty_lock);
80
+	if (atomic_inc_return(&realm->nref) == 1)
76
81
 		list_del_init(&realm->empty_item);
77
-		spin_unlock(&mdsc->snap_empty_lock);
78
-	}
82
+	spin_unlock(&mdsc->snap_empty_lock);
79
83
 }
80
84
 
81
85
 static void __insert_snap_realm(struct rb_root *root,
..
..
@@ -111,6 +115,8 @@
111
115
 {
112
116
 	struct ceph_snap_realm *realm;
113
117
 
118
+	lockdep_assert_held_write(&mdsc->snap_rwsem);
119
+
114
120
 	realm = kzalloc(sizeof(*realm), GFP_NOFS);
115
121
 	if (!realm)
116
122
 		return ERR_PTR(-ENOMEM);
..
..
@@ -124,6 +130,8 @@
124
130
 	INIT_LIST_HEAD(&realm->inodes_with_caps);
125
131
 	spin_lock_init(&realm->inodes_with_caps_lock);
126
132
 	__insert_snap_realm(&mdsc->snap_realms, realm);
133
+	mdsc->num_snap_realms++;
134
+
127
135
 	dout("create_snap_realm %llx %p\n", realm->ino, realm);
128
136
 	return realm;
129
137
 }
..
..
@@ -131,13 +139,15 @@
131
139
 /*
132
140
  * lookup the realm rooted at @ino.
133
141
  *
134
- * caller must hold snap_rwsem for write.
142
+ * caller must hold snap_rwsem.
135
143
  */
136
144
 static struct ceph_snap_realm *__lookup_snap_realm(struct ceph_mds_client *mdsc,
137
145
 						   u64 ino)
138
146
 {
139
147
 	struct rb_node *n = mdsc->snap_realms.rb_node;
140
148
 	struct ceph_snap_realm *r;
149
+
150
+	lockdep_assert_held(&mdsc->snap_rwsem);
141
151
 
142
152
 	while (n) {
143
153
 		r = rb_entry(n, struct ceph_snap_realm, node);
..
..
@@ -172,9 +182,12 @@
172
182
 static void __destroy_snap_realm(struct ceph_mds_client *mdsc,
173
183
 				 struct ceph_snap_realm *realm)
174
184
 {
185
+	lockdep_assert_held_write(&mdsc->snap_rwsem);
186
+
175
187
 	dout("__destroy_snap_realm %p %llx\n", realm, realm->ino);
176
188
 
177
189
 	rb_erase(&realm->node, &mdsc->snap_realms);
190
+	mdsc->num_snap_realms--;
178
191
 
179
192
 	if (realm->parent) {
180
193
 		list_del_init(&realm->child_item);
..
..
@@ -193,28 +206,30 @@
193
206
 static void __put_snap_realm(struct ceph_mds_client *mdsc,
194
207
 			     struct ceph_snap_realm *realm)
195
208
 {
196
-	dout("__put_snap_realm %llx %p %d -> %d\n", realm->ino, realm,
197
-	     atomic_read(&realm->nref), atomic_read(&realm->nref)-1);
209
+	lockdep_assert_held_write(&mdsc->snap_rwsem);
210
+
211
+	/*
212
+	 * We do not require the snap_empty_lock here, as any caller that
213
+	 * increments the value must hold the snap_rwsem.
214
+	 */
198
215
 	if (atomic_dec_and_test(&realm->nref))
199
216
 		__destroy_snap_realm(mdsc, realm);
200
217
 }
201
218
 
202
219
 /*
203
- * caller needn't hold any locks
220
+ * See comments in ceph_get_snap_realm. Caller needn't hold any locks.
204
221
  */
205
222
 void ceph_put_snap_realm(struct ceph_mds_client *mdsc,
206
223
 			 struct ceph_snap_realm *realm)
207
224
 {
208
-	dout("put_snap_realm %llx %p %d -> %d\n", realm->ino, realm,
209
-	     atomic_read(&realm->nref), atomic_read(&realm->nref)-1);
210
-	if (!atomic_dec_and_test(&realm->nref))
225
+	if (!atomic_dec_and_lock(&realm->nref, &mdsc->snap_empty_lock))
211
226
 		return;
212
227
 
213
228
 	if (down_write_trylock(&mdsc->snap_rwsem)) {
229
+		spin_unlock(&mdsc->snap_empty_lock);
214
230
 		__destroy_snap_realm(mdsc, realm);
215
231
 		up_write(&mdsc->snap_rwsem);
216
232
 	} else {
217
-		spin_lock(&mdsc->snap_empty_lock);
218
233
 		list_add(&realm->empty_item, &mdsc->snap_empty);
219
234
 		spin_unlock(&mdsc->snap_empty_lock);
220
235
 	}
..
..
@@ -230,6 +245,8 @@
230
245
 static void __cleanup_empty_realms(struct ceph_mds_client *mdsc)
231
246
 {
232
247
 	struct ceph_snap_realm *realm;
248
+
249
+	lockdep_assert_held_write(&mdsc->snap_rwsem);
233
250
 
234
251
 	spin_lock(&mdsc->snap_empty_lock);
235
252
 	while (!list_empty(&mdsc->snap_empty)) {
..
..
@@ -263,6 +280,8 @@
263
280
 				    u64 parentino)
264
281
 {
265
282
 	struct ceph_snap_realm *parent;
283
+
284
+	lockdep_assert_held_write(&mdsc->snap_rwsem);
266
285
 
267
286
 	if (realm->parent_ino == parentino)
268
287
 		return 0;
..
..
@@ -468,6 +487,9 @@
468
487
 		pr_err("ENOMEM allocating ceph_cap_snap on %p\n", inode);
469
488
 		return;
470
489
 	}
490
+	capsnap->cap_flush.is_capsnap = true;
491
+	INIT_LIST_HEAD(&capsnap->cap_flush.i_list);
492
+	INIT_LIST_HEAD(&capsnap->cap_flush.g_list);
471
493
 
472
494
 	spin_lock(&ci->i_ceph_lock);
473
495
 	used = __ceph_caps_used(ci);
..
..
@@ -597,13 +619,15 @@
597
619
 			    struct ceph_cap_snap *capsnap)
598
620
 {
599
621
 	struct inode *inode = &ci->vfs_inode;
600
-	struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
622
+	struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(inode->i_sb);
601
623
 
602
624
 	BUG_ON(capsnap->writing);
603
625
 	capsnap->size = inode->i_size;
604
626
 	capsnap->mtime = inode->i_mtime;
605
627
 	capsnap->atime = inode->i_atime;
606
628
 	capsnap->ctime = inode->i_ctime;
629
+	capsnap->btime = ci->i_btime;
630
+	capsnap->change_attr = inode_peek_iversion_raw(inode);
607
631
 	capsnap->time_warp_seq = ci->i_time_warp_seq;
608
632
 	capsnap->truncate_size = ci->i_truncate_size;
609
633
 	capsnap->truncate_seq = ci->i_truncate_seq;
..
..
@@ -646,13 +670,15 @@
646
670
 		if (!inode)
647
671
 			continue;
648
672
 		spin_unlock(&realm->inodes_with_caps_lock);
649
-		iput(lastinode);
673
+		/* avoid calling iput_final() while holding
674
+		 * mdsc->snap_rwsem or in mds dispatch threads */
675
+		ceph_async_iput(lastinode);
650
676
 		lastinode = inode;
651
677
 		ceph_queue_cap_snap(ci);
652
678
 		spin_lock(&realm->inodes_with_caps_lock);
653
679
 	}
654
680
 	spin_unlock(&realm->inodes_with_caps_lock);
655
-	iput(lastinode);
681
+	ceph_async_iput(lastinode);
656
682
 
657
683
 	dout("queue_realm_cap_snaps %p %llx done\n", realm, realm->ino);
658
684
 }
..
..
@@ -671,14 +697,19 @@
671
697
 	struct ceph_mds_snap_realm *ri;    /* encoded */
672
698
 	__le64 *snaps;                     /* encoded */
673
699
 	__le64 *prior_parent_snaps;        /* encoded */
674
-	struct ceph_snap_realm *realm = NULL;
700
+	struct ceph_snap_realm *realm;
675
701
 	struct ceph_snap_realm *first_realm = NULL;
676
-	int invalidate = 0;
702
+	struct ceph_snap_realm *realm_to_rebuild = NULL;
703
+	int rebuild_snapcs;
677
704
 	int err = -ENOMEM;
678
705
 	LIST_HEAD(dirty_realms);
679
706
 
707
+	lockdep_assert_held_write(&mdsc->snap_rwsem);
708
+
680
709
 	dout("update_snap_trace deletion=%d\n", deletion);
681
710
 more:
711
+	realm = NULL;
712
+	rebuild_snapcs = 0;
682
713
 	ceph_decode_need(&p, e, sizeof(*ri), bad);
683
714
 	ri = p;
684
715
 	p += sizeof(*ri);
..
..
@@ -702,7 +733,7 @@
702
733
 	err = adjust_snap_realm_parent(mdsc, realm, le64_to_cpu(ri->parent));
703
734
 	if (err < 0)
704
735
 		goto fail;
705
-	invalidate += err;
736
+	rebuild_snapcs += err;
706
737
 
707
738
 	if (le64_to_cpu(ri->seq) > realm->seq) {
708
739
 		dout("update_snap_trace updating %llx %p %lld -> %lld\n",
..
..
@@ -727,22 +758,30 @@
727
758
 		if (realm->seq > mdsc->last_snap_seq)
728
759
 			mdsc->last_snap_seq = realm->seq;
729
760
 
730
-		invalidate = 1;
761
+		rebuild_snapcs = 1;
731
762
 	} else if (!realm->cached_context) {
732
763
 		dout("update_snap_trace %llx %p seq %lld new\n",
733
764
 		     realm->ino, realm, realm->seq);
734
-		invalidate = 1;
765
+		rebuild_snapcs = 1;
735
766
 	} else {
736
767
 		dout("update_snap_trace %llx %p seq %lld unchanged\n",
737
768
 		     realm->ino, realm, realm->seq);
738
769
 	}
739
770
 
740
-	dout("done with %llx %p, invalidated=%d, %p %p\n", realm->ino,
741
-	     realm, invalidate, p, e);
771
+	dout("done with %llx %p, rebuild_snapcs=%d, %p %p\n", realm->ino,
772
+	     realm, rebuild_snapcs, p, e);
742
773
 
743
-	/* invalidate when we reach the _end_ (root) of the trace */
744
-	if (invalidate && p >= e)
745
-		rebuild_snap_realms(realm, &dirty_realms);
774
+	/*
775
+	 * this will always track the uppest parent realm from which
776
+	 * we need to rebuild the snapshot contexts _downward_ in
777
+	 * hierarchy.
778
+	 */
779
+	if (rebuild_snapcs)
780
+		realm_to_rebuild = realm;
781
+
782
+	/* rebuild_snapcs when we reach the _end_ (root) of the trace */
783
+	if (realm_to_rebuild && p >= e)
784
+		rebuild_snap_realms(realm_to_rebuild, &dirty_realms);
746
785
 
747
786
 	if (!first_realm)
748
787
 		first_realm = realm;
..
..
@@ -804,7 +843,9 @@
804
843
 		ihold(inode);
805
844
 		spin_unlock(&mdsc->snap_flush_lock);
806
845
 		ceph_flush_snaps(ci, &session);
807
-		iput(inode);
846
+		/* avoid calling iput_final() while holding
847
+		 * session->s_mutex or in mds dispatch threads */
848
+		ceph_async_iput(inode);
808
849
 		spin_lock(&mdsc->snap_flush_lock);
809
850
 	}
810
851
 	spin_unlock(&mdsc->snap_flush_lock);
..
..
@@ -862,7 +903,7 @@
862
903
 	     ceph_snap_op_name(op), split, trace_len);
863
904
 
864
905
 	mutex_lock(&session->s_mutex);
865
-	session->s_seq++;
906
+	inc_session_sequence(session);
866
907
 	mutex_unlock(&session->s_mutex);
867
908
 
868
909
 	down_write(&mdsc->snap_rwsem);
..
..
@@ -948,12 +989,14 @@
948
989
 			ceph_get_snap_realm(mdsc, realm);
949
990
 			ceph_put_snap_realm(mdsc, oldrealm);
950
991
 
951
-			iput(inode);
992
+			/* avoid calling iput_final() while holding
993
+			 * mdsc->snap_rwsem or mds in dispatch threads */
994
+			ceph_async_iput(inode);
952
995
 			continue;
953
996
 
954
997
 skip_inode:
955
998
 			spin_unlock(&ci->i_ceph_lock);
956
-			iput(inode);
999
+			ceph_async_iput(inode);
957
1000
 		}
958
1001
 
959
1002
 		/* we may have taken some of the old realm's children. */
..
..
@@ -993,3 +1036,155 @@
993
1036
 		up_write(&mdsc->snap_rwsem);
994
1037
 	return;
995
1038
 }
1039
+
1040
+struct ceph_snapid_map* ceph_get_snapid_map(struct ceph_mds_client *mdsc,
1041
+					    u64 snap)
1042
+{
1043
+	struct ceph_snapid_map *sm, *exist;
1044
+	struct rb_node **p, *parent;
1045
+	int ret;
1046
+
1047
+	exist = NULL;
1048
+	spin_lock(&mdsc->snapid_map_lock);
1049
+	p = &mdsc->snapid_map_tree.rb_node;
1050
+	while (*p) {
1051
+		exist = rb_entry(*p, struct ceph_snapid_map, node);
1052
+		if (snap > exist->snap) {
1053
+			p = &(*p)->rb_left;
1054
+		} else if (snap < exist->snap) {
1055
+			p = &(*p)->rb_right;
1056
+		} else {
1057
+			if (atomic_inc_return(&exist->ref) == 1)
1058
+				list_del_init(&exist->lru);
1059
+			break;
1060
+		}
1061
+		exist = NULL;
1062
+	}
1063
+	spin_unlock(&mdsc->snapid_map_lock);
1064
+	if (exist) {
1065
+		dout("found snapid map %llx -> %x\n", exist->snap, exist->dev);
1066
+		return exist;
1067
+	}
1068
+
1069
+	sm = kmalloc(sizeof(*sm), GFP_NOFS);
1070
+	if (!sm)
1071
+		return NULL;
1072
+
1073
+	ret = get_anon_bdev(&sm->dev);
1074
+	if (ret < 0) {
1075
+		kfree(sm);
1076
+		return NULL;
1077
+	}
1078
+
1079
+	INIT_LIST_HEAD(&sm->lru);
1080
+	atomic_set(&sm->ref, 1);
1081
+	sm->snap = snap;
1082
+
1083
+	exist = NULL;
1084
+	parent = NULL;
1085
+	p = &mdsc->snapid_map_tree.rb_node;
1086
+	spin_lock(&mdsc->snapid_map_lock);
1087
+	while (*p) {
1088
+		parent = *p;
1089
+		exist = rb_entry(*p, struct ceph_snapid_map, node);
1090
+		if (snap > exist->snap)
1091
+			p = &(*p)->rb_left;
1092
+		else if (snap < exist->snap)
1093
+			p = &(*p)->rb_right;
1094
+		else
1095
+			break;
1096
+		exist = NULL;
1097
+	}
1098
+	if (exist) {
1099
+		if (atomic_inc_return(&exist->ref) == 1)
1100
+			list_del_init(&exist->lru);
1101
+	} else {
1102
+		rb_link_node(&sm->node, parent, p);
1103
+		rb_insert_color(&sm->node, &mdsc->snapid_map_tree);
1104
+	}
1105
+	spin_unlock(&mdsc->snapid_map_lock);
1106
+	if (exist) {
1107
+		free_anon_bdev(sm->dev);
1108
+		kfree(sm);
1109
+		dout("found snapid map %llx -> %x\n", exist->snap, exist->dev);
1110
+		return exist;
1111
+	}
1112
+
1113
+	dout("create snapid map %llx -> %x\n", sm->snap, sm->dev);
1114
+	return sm;
1115
+}
1116
+
1117
+void ceph_put_snapid_map(struct ceph_mds_client* mdsc,
1118
+			 struct ceph_snapid_map *sm)
1119
+{
1120
+	if (!sm)
1121
+		return;
1122
+	if (atomic_dec_and_lock(&sm->ref, &mdsc->snapid_map_lock)) {
1123
+		if (!RB_EMPTY_NODE(&sm->node)) {
1124
+			sm->last_used = jiffies;
1125
+			list_add_tail(&sm->lru, &mdsc->snapid_map_lru);
1126
+			spin_unlock(&mdsc->snapid_map_lock);
1127
+		} else {
1128
+			/* already cleaned up by
1129
+			 * ceph_cleanup_snapid_map() */
1130
+			spin_unlock(&mdsc->snapid_map_lock);
1131
+			kfree(sm);
1132
+		}
1133
+	}
1134
+}
1135
+
1136
+void ceph_trim_snapid_map(struct ceph_mds_client *mdsc)
1137
+{
1138
+	struct ceph_snapid_map *sm;
1139
+	unsigned long now;
1140
+	LIST_HEAD(to_free);
1141
+
1142
+	spin_lock(&mdsc->snapid_map_lock);
1143
+	now = jiffies;
1144
+
1145
+	while (!list_empty(&mdsc->snapid_map_lru)) {
1146
+		sm = list_first_entry(&mdsc->snapid_map_lru,
1147
+				      struct ceph_snapid_map, lru);
1148
+		if (time_after(sm->last_used + CEPH_SNAPID_MAP_TIMEOUT, now))
1149
+			break;
1150
+
1151
+		rb_erase(&sm->node, &mdsc->snapid_map_tree);
1152
+		list_move(&sm->lru, &to_free);
1153
+	}
1154
+	spin_unlock(&mdsc->snapid_map_lock);
1155
+
1156
+	while (!list_empty(&to_free)) {
1157
+		sm = list_first_entry(&to_free, struct ceph_snapid_map, lru);
1158
+		list_del(&sm->lru);
1159
+		dout("trim snapid map %llx -> %x\n", sm->snap, sm->dev);
1160
+		free_anon_bdev(sm->dev);
1161
+		kfree(sm);
1162
+	}
1163
+}
1164
+
1165
+void ceph_cleanup_snapid_map(struct ceph_mds_client *mdsc)
1166
+{
1167
+	struct ceph_snapid_map *sm;
1168
+	struct rb_node *p;
1169
+	LIST_HEAD(to_free);
1170
+
1171
+	spin_lock(&mdsc->snapid_map_lock);
1172
+	while ((p = rb_first(&mdsc->snapid_map_tree))) {
1173
+		sm = rb_entry(p, struct ceph_snapid_map, node);
1174
+		rb_erase(p, &mdsc->snapid_map_tree);
1175
+		RB_CLEAR_NODE(p);
1176
+		list_move(&sm->lru, &to_free);
1177
+	}
1178
+	spin_unlock(&mdsc->snapid_map_lock);
1179
+
1180
+	while (!list_empty(&to_free)) {
1181
+		sm = list_first_entry(&to_free, struct ceph_snapid_map, lru);
1182
+		list_del(&sm->lru);
1183
+		free_anon_bdev(sm->dev);
1184
+		if (WARN_ON_ONCE(atomic_read(&sm->ref))) {
1185
+			pr_err("snapid map %llx -> %x still in use\n",
1186
+			       sm->snap, sm->dev);
1187
+		}
1188
+		kfree(sm);
1189
+	}
1190
+}