[XFS] consolidate extent item freeing

SGI-PV: 938062 SGI-Modid: xfs-linux:xfs-kern:194415a Signed-off-by: Christoph Hellwig <hch@sgi.com> Signed-off-by: Nathan Scott <nathans@sgi.com>

[XFS] consolidate extent item freeing
SGI-PV: 938062 SGI-Modid: xfs-linux:xfs-kern:194415a Signed-off-by: Christoph Hellwig <hch@sgi.com> Signed-off-by: Nathan Scott <nathans@sgi.com>
Christoph Hellwig · Nathan Scott
1 parent f898d6c09c
Showing 3 changed files with 35 additions and 103 deletions Side-by-side Diff
fs/xfs/xfs_extfree_item.c
fs/xfs/xfs_extfree_item.h
fs/xfs/xfs_log_recover.c
@@ -59,7 +59,19 @@
 STATIC void	xfs_efd_item_abort(xfs_efd_log_item_t *);
  
  
+void
+xfs_efi_item_free(xfs_efi_log_item_t *efip)
+{
+	int nexts = efip->efi_format.efi_nextents;
  
+	if (nexts > XFS_EFI_MAX_FAST_EXTENTS) {
+		kmem_free(efip, sizeof(xfs_efi_log_item_t) +
+				(nexts - 1) * sizeof(xfs_extent_t));
+	} else {
+		kmem_zone_free(xfs_efi_zone, efip);
+	}
+}
+
 /*
  * This returns the number of iovecs needed to log the given efi item.
  * We only need 1 iovec for an efi item.  It just logs the efi_log_format
@@ -120,8 +132,6 @@
 STATIC void
 xfs_efi_item_unpin(xfs_efi_log_item_t *efip, int stale)
 {
-	int		nexts;
-	int		size;
 	xfs_mount_t	*mp;
 	SPLDECL(s);
  
  
@@ -132,21 +142,11 @@
 		 * xfs_trans_delete_ail() drops the AIL lock.
 		 */
 		xfs_trans_delete_ail(mp, (xfs_log_item_t *)efip, s);
-
-		nexts = efip->efi_format.efi_nextents;
-		if (nexts > XFS_EFI_MAX_FAST_EXTENTS) {
-			size = sizeof(xfs_efi_log_item_t);
-			size += (nexts - 1) * sizeof(xfs_extent_t);
-			kmem_free(efip, size);
-		} else {
-			kmem_zone_free(xfs_efi_zone, efip);
-		}
+		xfs_efi_item_free(efip);
 	} else {
 		efip->efi_flags |= XFS_EFI_COMMITTED;
 		AIL_UNLOCK(mp, s);
 	}
-
-	return;
 }
  
 /*
@@ -159,8 +159,6 @@
 STATIC void
 xfs_efi_item_unpin_remove(xfs_efi_log_item_t *efip, xfs_trans_t *tp)
 {
-	int		nexts;
-	int		size;
 	xfs_mount_t	*mp;
 	xfs_log_item_desc_t	*lidp;
 	SPLDECL(s);
  
@@ -178,23 +176,11 @@
 		 * xfs_trans_delete_ail() drops the AIL lock.
 		 */
 		xfs_trans_delete_ail(mp, (xfs_log_item_t *)efip, s);
-		/*
-		 * now free the item itself
-		 */
-		nexts = efip->efi_format.efi_nextents;
-		if (nexts > XFS_EFI_MAX_FAST_EXTENTS) {
-			size = sizeof(xfs_efi_log_item_t);
-			size += (nexts - 1) * sizeof(xfs_extent_t);
-			kmem_free(efip, size);
-		} else {
-			kmem_zone_free(xfs_efi_zone, efip);
-		}
+		xfs_efi_item_free(efip);
 	} else {
 		efip->efi_flags |= XFS_EFI_COMMITTED;
 		AIL_UNLOCK(mp, s);
 	}
-
-	return;
 }
  
 /*
@@ -245,18 +231,7 @@
 STATIC void
 xfs_efi_item_abort(xfs_efi_log_item_t *efip)
 {
-	int	nexts;
-	int	size;
-
-	nexts = efip->efi_format.efi_nextents;
-	if (nexts > XFS_EFI_MAX_FAST_EXTENTS) {
-		size = sizeof(xfs_efi_log_item_t);
-		size += (nexts - 1) * sizeof(xfs_extent_t);
-		kmem_free(efip, size);
-	} else {
-		kmem_zone_free(xfs_efi_zone, efip);
-	}
-	return;
+	xfs_efi_item_free(efip);
 }
  
 /*
@@ -355,8 +330,6 @@
 {
 	xfs_mount_t	*mp;
 	int		extents_left;
-	uint		size;
-	int		nexts;
 	SPLDECL(s);
  
 	mp = efip->efi_item.li_mountp;
  
@@ -372,20 +345,10 @@
 		 * xfs_trans_delete_ail() drops the AIL lock.
 		 */
 		xfs_trans_delete_ail(mp, (xfs_log_item_t *)efip, s);
+		xfs_efi_item_free(efip);
 	} else {
 		AIL_UNLOCK(mp, s);
 	}
-
-	if (extents_left == 0) {
-		nexts = efip->efi_format.efi_nextents;
-		if (nexts > XFS_EFI_MAX_FAST_EXTENTS) {
-			size = sizeof(xfs_efi_log_item_t);
-			size += (nexts - 1) * sizeof(xfs_extent_t);
-			kmem_free(efip, size);
-		} else {
-			kmem_zone_free(xfs_efi_zone, efip);
-		}
-	}
 }
  
 /*
@@ -398,8 +361,6 @@
 xfs_efi_cancel(
 	xfs_efi_log_item_t	*efip)
 {
-	int		nexts;
-	int		size;
 	xfs_mount_t	*mp;
 	SPLDECL(s);
  
  
  
  
  
@@ -410,27 +371,26 @@
 		 * xfs_trans_delete_ail() drops the AIL lock.
 		 */
 		xfs_trans_delete_ail(mp, (xfs_log_item_t *)efip, s);
-
-		nexts = efip->efi_format.efi_nextents;
-		if (nexts > XFS_EFI_MAX_FAST_EXTENTS) {
-			size = sizeof(xfs_efi_log_item_t);
-			size += (nexts - 1) * sizeof(xfs_extent_t);
-			kmem_free(efip, size);
-		} else {
-			kmem_zone_free(xfs_efi_zone, efip);
-		}
+		xfs_efi_item_free(efip);
 	} else {
 		efip->efi_flags |= XFS_EFI_CANCELED;
 		AIL_UNLOCK(mp, s);
 	}
-
-	return;
 }
  
+STATIC void
+xfs_efd_item_free(xfs_efd_log_item_t *efdp)
+{
+	int nexts = efdp->efd_format.efd_nextents;
  
+	if (nexts > XFS_EFD_MAX_FAST_EXTENTS) {
+		kmem_free(efdp, sizeof(xfs_efd_log_item_t) +
+				(nexts - 1) * sizeof(xfs_extent_t));
+	} else {
+		kmem_zone_free(xfs_efd_zone, efdp);
+	}
+}
  
-
-
 /*
  * This returns the number of iovecs needed to log the given efd item.
  * We only need 1 iovec for an efd item.  It just logs the efd_log_format
@@ -533,9 +493,6 @@
 STATIC xfs_lsn_t
 xfs_efd_item_committed(xfs_efd_log_item_t *efdp, xfs_lsn_t lsn)
 {
-	uint	size;
-	int	nexts;
-
 	/*
 	 * If we got a log I/O error, it's always the case that the LR with the
 	 * EFI got unpinned and freed before the EFD got aborted.
@@ -543,15 +500,7 @@
 	if ((efdp->efd_item.li_flags & XFS_LI_ABORTED) == 0)
 		xfs_efi_release(efdp->efd_efip, efdp->efd_format.efd_nextents);
  
-	nexts = efdp->efd_format.efd_nextents;
-	if (nexts > XFS_EFD_MAX_FAST_EXTENTS) {
-		size = sizeof(xfs_efd_log_item_t);
-		size += (nexts - 1) * sizeof(xfs_extent_t);
-		kmem_free(efdp, size);
-	} else {
-		kmem_zone_free(xfs_efd_zone, efdp);
-	}
-
+	xfs_efd_item_free(efdp);
 	return (xfs_lsn_t)-1;
 }
  
@@ -565,9 +514,6 @@
 STATIC void
 xfs_efd_item_abort(xfs_efd_log_item_t *efdp)
 {
-	int	nexts;
-	int	size;
-
 	/*
 	 * If we got a log I/O error, it's always the case that the LR with the
 	 * EFI got unpinned and freed before the EFD got aborted. So don't
@@ -576,15 +522,7 @@
 	if ((efdp->efd_item.li_flags & XFS_LI_ABORTED) == 0)
 		xfs_efi_cancel(efdp->efd_efip);
  
-	nexts = efdp->efd_format.efd_nextents;
-	if (nexts > XFS_EFD_MAX_FAST_EXTENTS) {
-		size = sizeof(xfs_efd_log_item_t);
-		size += (nexts - 1) * sizeof(xfs_extent_t);
-		kmem_free(efdp, size);
-	} else {
-		kmem_zone_free(xfs_efd_zone, efdp);
-	}
-	return;
+	xfs_efd_item_free(efdp);
 }
  
 /*
@@ -118,6 +118,8 @@
 xfs_efd_log_item_t	*xfs_efd_init(struct xfs_mount *, xfs_efi_log_item_t *,
 				      uint);
  
+void			xfs_efi_item_free(xfs_efi_log_item_t *);
+
 #endif	/* __KERNEL__ */
  
 #endif	/* __XFS_EXTFREE_ITEM_H__ */
@@ -2747,7 +2747,6 @@
 	xfs_efi_log_item_t	*efip = NULL;
 	xfs_log_item_t		*lip;
 	int			gen;
-	int			nexts;
 	__uint64_t		efi_id;
 	SPLDECL(s);
  
  
@@ -2782,22 +2781,15 @@
 		}
 		lip = xfs_trans_next_ail(mp, lip, &gen, NULL);
 	}
-	if (lip == NULL) {
-		AIL_UNLOCK(mp, s);
-	}
  
 	/*
 	 * If we found it, then free it up.  If it wasn't there, it
 	 * must have been overwritten in the log.  Oh well.
 	 */
 	if (lip != NULL) {
-		nexts = efip->efi_format.efi_nextents;
-		if (nexts > XFS_EFI_MAX_FAST_EXTENTS) {
-			kmem_free(lip, sizeof(xfs_efi_log_item_t) +
-				  ((nexts - 1) * sizeof(xfs_extent_t)));
-		} else {
-			kmem_zone_free(xfs_efi_zone, efip);
-		}
+		xfs_efi_item_free(efip);
+	} else {
+		AIL_UNLOCK(mp, s);
 	}
 }
...	...	@@ -59,7 +59,19 @@
59	59	STATIC void xfs_efd_item_abort(xfs_efd_log_item_t *);
60	60
61	61
	62	+void
	63	+xfs_efi_item_free(xfs_efi_log_item_t *efip)
	64	+{
	65	+ int nexts = efip->efi_format.efi_nextents;
62	66
	67	+ if (nexts > XFS_EFI_MAX_FAST_EXTENTS) {
	68	+ kmem_free(efip, sizeof(xfs_efi_log_item_t) +
	69	+ (nexts - 1) * sizeof(xfs_extent_t));
	70	+ } else {
	71	+ kmem_zone_free(xfs_efi_zone, efip);
	72	+ }
	73	+}
	74	+
63	75	/*
64	76	* This returns the number of iovecs needed to log the given efi item.
65	77	* We only need 1 iovec for an efi item. It just logs the efi_log_format
...	...	@@ -120,8 +132,6 @@
120	132	STATIC void
121	133	xfs_efi_item_unpin(xfs_efi_log_item_t *efip, int stale)
122	134	{
123		- int nexts;
124		- int size;
125	135	xfs_mount_t *mp;
126	136	SPLDECL(s);
127	137
128	138
...	...	@@ -132,21 +142,11 @@
132	142	* xfs_trans_delete_ail() drops the AIL lock.
133	143	*/
134	144	xfs_trans_delete_ail(mp, (xfs_log_item_t *)efip, s);
135		-
136		- nexts = efip->efi_format.efi_nextents;
137		- if (nexts > XFS_EFI_MAX_FAST_EXTENTS) {
138		- size = sizeof(xfs_efi_log_item_t);
139		- size += (nexts - 1) * sizeof(xfs_extent_t);
140		- kmem_free(efip, size);
141		- } else {
142		- kmem_zone_free(xfs_efi_zone, efip);
143		- }
	145	+ xfs_efi_item_free(efip);
144	146	} else {
145	147	efip->efi_flags \|= XFS_EFI_COMMITTED;
146	148	AIL_UNLOCK(mp, s);
147	149	}
148		-
149		- return;
150	150	}
151	151
152	152	/*
...	...	@@ -159,8 +159,6 @@
159	159	STATIC void
160	160	xfs_efi_item_unpin_remove(xfs_efi_log_item_t efip, xfs_trans_t tp)
161	161	{
162		- int nexts;
163		- int size;
164	162	xfs_mount_t *mp;
165	163	xfs_log_item_desc_t *lidp;
166	164	SPLDECL(s);
167	165
...	...	@@ -178,23 +176,11 @@
178	176	* xfs_trans_delete_ail() drops the AIL lock.
179	177	*/
180	178	xfs_trans_delete_ail(mp, (xfs_log_item_t *)efip, s);
181		- /*
182		- * now free the item itself
183		- */
184		- nexts = efip->efi_format.efi_nextents;
185		- if (nexts > XFS_EFI_MAX_FAST_EXTENTS) {
186		- size = sizeof(xfs_efi_log_item_t);
187		- size += (nexts - 1) * sizeof(xfs_extent_t);
188		- kmem_free(efip, size);
189		- } else {
190		- kmem_zone_free(xfs_efi_zone, efip);
191		- }
	179	+ xfs_efi_item_free(efip);
192	180	} else {
193	181	efip->efi_flags \|= XFS_EFI_COMMITTED;
194	182	AIL_UNLOCK(mp, s);
195	183	}
196		-
197		- return;
198	184	}
199	185
200	186	/*
...	...	@@ -245,18 +231,7 @@
245	231	STATIC void
246	232	xfs_efi_item_abort(xfs_efi_log_item_t *efip)
247	233	{
248		- int nexts;
249		- int size;
250		-
251		- nexts = efip->efi_format.efi_nextents;
252		- if (nexts > XFS_EFI_MAX_FAST_EXTENTS) {
253		- size = sizeof(xfs_efi_log_item_t);
254		- size += (nexts - 1) * sizeof(xfs_extent_t);
255		- kmem_free(efip, size);
256		- } else {
257		- kmem_zone_free(xfs_efi_zone, efip);
258		- }
259		- return;
	234	+ xfs_efi_item_free(efip);
260	235	}
261	236
262	237	/*
...	...	@@ -355,8 +330,6 @@
355	330	{
356	331	xfs_mount_t *mp;
357	332	int extents_left;
358		- uint size;
359		- int nexts;
360	333	SPLDECL(s);
361	334
362	335	mp = efip->efi_item.li_mountp;
363	336
...	...	@@ -372,20 +345,10 @@
372	345	* xfs_trans_delete_ail() drops the AIL lock.
373	346	*/
374	347	xfs_trans_delete_ail(mp, (xfs_log_item_t *)efip, s);
	348	+ xfs_efi_item_free(efip);
375	349	} else {
376	350	AIL_UNLOCK(mp, s);
377	351	}
378		-
379		- if (extents_left == 0) {
380		- nexts = efip->efi_format.efi_nextents;
381		- if (nexts > XFS_EFI_MAX_FAST_EXTENTS) {
382		- size = sizeof(xfs_efi_log_item_t);
383		- size += (nexts - 1) * sizeof(xfs_extent_t);
384		- kmem_free(efip, size);
385		- } else {
386		- kmem_zone_free(xfs_efi_zone, efip);
387		- }
388		- }
389	352	}
390	353
391	354	/*
...	...	@@ -398,8 +361,6 @@
398	361	xfs_efi_cancel(
399	362	xfs_efi_log_item_t *efip)
400	363	{
401		- int nexts;
402		- int size;
403	364	xfs_mount_t *mp;
404	365	SPLDECL(s);
405	366
406	367
407	368
408	369
409	370
...	...	@@ -410,27 +371,26 @@
410	371	* xfs_trans_delete_ail() drops the AIL lock.
411	372	*/
412	373	xfs_trans_delete_ail(mp, (xfs_log_item_t *)efip, s);
413		-
414		- nexts = efip->efi_format.efi_nextents;
415		- if (nexts > XFS_EFI_MAX_FAST_EXTENTS) {
416		- size = sizeof(xfs_efi_log_item_t);
417		- size += (nexts - 1) * sizeof(xfs_extent_t);
418		- kmem_free(efip, size);
419		- } else {
420		- kmem_zone_free(xfs_efi_zone, efip);
421		- }
	374	+ xfs_efi_item_free(efip);
422	375	} else {
423	376	efip->efi_flags \|= XFS_EFI_CANCELED;
424	377	AIL_UNLOCK(mp, s);
425	378	}
426		-
427		- return;
428	379	}
429	380
	381	+STATIC void
	382	+xfs_efd_item_free(xfs_efd_log_item_t *efdp)
	383	+{
	384	+ int nexts = efdp->efd_format.efd_nextents;
430	385
	386	+ if (nexts > XFS_EFD_MAX_FAST_EXTENTS) {
	387	+ kmem_free(efdp, sizeof(xfs_efd_log_item_t) +
	388	+ (nexts - 1) * sizeof(xfs_extent_t));
	389	+ } else {
	390	+ kmem_zone_free(xfs_efd_zone, efdp);
	391	+ }
	392	+}
431	393
432		-
433		-
434	394	/*
435	395	* This returns the number of iovecs needed to log the given efd item.
436	396	* We only need 1 iovec for an efd item. It just logs the efd_log_format
...	...	@@ -533,9 +493,6 @@
533	493	STATIC xfs_lsn_t
534	494	xfs_efd_item_committed(xfs_efd_log_item_t *efdp, xfs_lsn_t lsn)
535	495	{
536		- uint size;
537		- int nexts;
538		-
539	496	/*
540	497	* If we got a log I/O error, it's always the case that the LR with the
541	498	* EFI got unpinned and freed before the EFD got aborted.
...	...	@@ -543,15 +500,7 @@
543	500	if ((efdp->efd_item.li_flags & XFS_LI_ABORTED) == 0)
544	501	xfs_efi_release(efdp->efd_efip, efdp->efd_format.efd_nextents);
545	502
546		- nexts = efdp->efd_format.efd_nextents;
547		- if (nexts > XFS_EFD_MAX_FAST_EXTENTS) {
548		- size = sizeof(xfs_efd_log_item_t);
549		- size += (nexts - 1) * sizeof(xfs_extent_t);
550		- kmem_free(efdp, size);
551		- } else {
552		- kmem_zone_free(xfs_efd_zone, efdp);
553		- }
554		-
	503	+ xfs_efd_item_free(efdp);
555	504	return (xfs_lsn_t)-1;
556	505	}
557	506
...	...	@@ -565,9 +514,6 @@
565	514	STATIC void
566	515	xfs_efd_item_abort(xfs_efd_log_item_t *efdp)
567	516	{
568		- int nexts;
569		- int size;
570		-
571	517	/*
572	518	* If we got a log I/O error, it's always the case that the LR with the
573	519	* EFI got unpinned and freed before the EFD got aborted. So don't
...	...	@@ -576,15 +522,7 @@
576	522	if ((efdp->efd_item.li_flags & XFS_LI_ABORTED) == 0)
577	523	xfs_efi_cancel(efdp->efd_efip);
578	524
579		- nexts = efdp->efd_format.efd_nextents;
580		- if (nexts > XFS_EFD_MAX_FAST_EXTENTS) {
581		- size = sizeof(xfs_efd_log_item_t);
582		- size += (nexts - 1) * sizeof(xfs_extent_t);
583		- kmem_free(efdp, size);
584		- } else {
585		- kmem_zone_free(xfs_efd_zone, efdp);
586		- }
587		- return;
	525	+ xfs_efd_item_free(efdp);
588	526	}
589	527
590	528	/*
...	...	@@ -118,6 +118,8 @@
118	118	xfs_efd_log_item_t xfs_efd_init(struct xfs_mount , xfs_efi_log_item_t *,
119	119	uint);
120	120
	121	+void xfs_efi_item_free(xfs_efi_log_item_t *);
	122	+
121	123	#endif /* __KERNEL__ */
122	124
123	125	#endif /* __XFS_EXTFREE_ITEM_H__ */
...	...	@@ -2747,7 +2747,6 @@
2747	2747	xfs_efi_log_item_t *efip = NULL;
2748	2748	xfs_log_item_t *lip;
2749	2749	int gen;
2750		- int nexts;
2751	2750	__uint64_t efi_id;
2752	2751	SPLDECL(s);
2753	2752
2754	2753
...	...	@@ -2782,22 +2781,15 @@
2782	2781	}
2783	2782	lip = xfs_trans_next_ail(mp, lip, &gen, NULL);
2784	2783	}
2785		- if (lip == NULL) {
2786		- AIL_UNLOCK(mp, s);
2787		- }
2788	2784
2789	2785	/*
2790	2786	* If we found it, then free it up. If it wasn't there, it
2791	2787	* must have been overwritten in the log. Oh well.
2792	2788	*/
2793	2789	if (lip != NULL) {
2794		- nexts = efip->efi_format.efi_nextents;
2795		- if (nexts > XFS_EFI_MAX_FAST_EXTENTS) {
2796		- kmem_free(lip, sizeof(xfs_efi_log_item_t) +
2797		- ((nexts - 1) * sizeof(xfs_extent_t)));
2798		- } else {
2799		- kmem_zone_free(xfs_efi_zone, efip);
2800		- }
	2790	+ xfs_efi_item_free(efip);
	2791	+ } else {
	2792	+ AIL_UNLOCK(mp, s);
2801	2793	}
2802	2794	}
2803	2795