blob: d22e62623437aafb79d62f5492252e140f3a6cb7 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Nathan Scott7b718762005-11-02 14:58:39 +11002 * Copyright (c) 2000-2001,2005 Silicon Graphics, Inc.
3 * All Rights Reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
Nathan Scott7b718762005-11-02 14:58:39 +11005 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * published by the Free Software Foundation.
8 *
Nathan Scott7b718762005-11-02 14:58:39 +11009 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 *
Nathan Scott7b718762005-11-02 14:58:39 +110014 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include "xfs.h"
Nathan Scotta844f452005-11-02 14:38:42 +110019#include "xfs_fs.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include "xfs_types.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include "xfs_log.h"
Nathan Scotta844f452005-11-02 14:38:42 +110022#include "xfs_inum.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include "xfs_trans.h"
24#include "xfs_buf_item.h"
25#include "xfs_sb.h"
David Chinnerda353b02007-08-28 14:00:13 +100026#include "xfs_ag.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include "xfs_mount.h"
28#include "xfs_trans_priv.h"
29#include "xfs_extfree_item.h"
30
31
32kmem_zone_t *xfs_efi_zone;
33kmem_zone_t *xfs_efd_zone;
34
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +100035static inline struct xfs_efi_log_item *EFI_ITEM(struct xfs_log_item *lip)
36{
37 return container_of(lip, struct xfs_efi_log_item, efi_item);
38}
Linus Torvalds1da177e2005-04-16 15:20:36 -070039
Christoph Hellwig7d795ca2005-06-21 15:41:19 +100040void
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +100041xfs_efi_item_free(
42 struct xfs_efi_log_item *efip)
Christoph Hellwig7d795ca2005-06-21 15:41:19 +100043{
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +100044 if (efip->efi_format.efi_nextents > XFS_EFI_MAX_FAST_EXTENTS)
Denys Vlasenkof0e2d932008-05-19 16:31:57 +100045 kmem_free(efip);
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +100046 else
Christoph Hellwig7d795ca2005-06-21 15:41:19 +100047 kmem_zone_free(xfs_efi_zone, efip);
Christoph Hellwig7d795ca2005-06-21 15:41:19 +100048}
Linus Torvalds1da177e2005-04-16 15:20:36 -070049
50/*
Dave Chinnerb199c8a2010-12-20 11:59:49 +110051 * Freeing the efi requires that we remove it from the AIL if it has already
52 * been placed there. However, the EFI may not yet have been placed in the AIL
53 * when called by xfs_efi_release() from EFD processing due to the ordering of
54 * committed vs unpin operations in bulk insert operations. Hence the
55 * test_and_clear_bit(XFS_EFI_COMMITTED) to ensure only the last caller frees
56 * the EFI.
57 */
58STATIC void
59__xfs_efi_release(
60 struct xfs_efi_log_item *efip)
61{
62 struct xfs_ail *ailp = efip->efi_item.li_ailp;
63
64 if (!test_and_clear_bit(XFS_EFI_COMMITTED, &efip->efi_flags)) {
65 spin_lock(&ailp->xa_lock);
66 /* xfs_trans_ail_delete() drops the AIL lock. */
67 xfs_trans_ail_delete(ailp, &efip->efi_item);
68 xfs_efi_item_free(efip);
69 }
70}
71
72/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070073 * This returns the number of iovecs needed to log the given efi item.
74 * We only need 1 iovec for an efi item. It just logs the efi_log_format
75 * structure.
76 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070077STATIC uint
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +100078xfs_efi_item_size(
79 struct xfs_log_item *lip)
Linus Torvalds1da177e2005-04-16 15:20:36 -070080{
81 return 1;
82}
83
84/*
85 * This is called to fill in the vector of log iovecs for the
86 * given efi log item. We use only 1 iovec, and we point that
87 * at the efi_log_format structure embedded in the efi item.
88 * It is at this point that we assert that all of the extent
89 * slots in the efi item have been filled.
90 */
91STATIC void
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +100092xfs_efi_item_format(
93 struct xfs_log_item *lip,
94 struct xfs_log_iovec *log_vector)
Linus Torvalds1da177e2005-04-16 15:20:36 -070095{
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +100096 struct xfs_efi_log_item *efip = EFI_ITEM(lip);
97 uint size;
Linus Torvalds1da177e2005-04-16 15:20:36 -070098
Dave Chinnerb199c8a2010-12-20 11:59:49 +110099 ASSERT(atomic_read(&efip->efi_next_extent) ==
100 efip->efi_format.efi_nextents);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101
102 efip->efi_format.efi_type = XFS_LI_EFI;
103
104 size = sizeof(xfs_efi_log_format_t);
105 size += (efip->efi_format.efi_nextents - 1) * sizeof(xfs_extent_t);
106 efip->efi_format.efi_size = 1;
107
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +1000108 log_vector->i_addr = &efip->efi_format;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 log_vector->i_len = size;
Christoph Hellwig4139b3b2010-01-19 09:56:45 +0000110 log_vector->i_type = XLOG_REG_TYPE_EFI_FORMAT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 ASSERT(size >= sizeof(xfs_efi_log_format_t));
112}
113
114
115/*
116 * Pinning has no meaning for an efi item, so just return.
117 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118STATIC void
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000119xfs_efi_item_pin(
120 struct xfs_log_item *lip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122}
123
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124/*
Dave Chinner9c5f8412010-12-20 11:57:24 +1100125 * While EFIs cannot really be pinned, the unpin operation is the last place at
126 * which the EFI is manipulated during a transaction. If we are being asked to
127 * remove the EFI it's because the transaction has been cancelled and by
128 * definition that means the EFI cannot be in the AIL so remove it from the
Dave Chinnerb199c8a2010-12-20 11:59:49 +1100129 * transaction and free it. Otherwise coordinate with xfs_efi_release() (via
130 * XFS_EFI_COMMITTED) to determine who gets to free the EFI.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132STATIC void
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000133xfs_efi_item_unpin(
134 struct xfs_log_item *lip,
135 int remove)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136{
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000137 struct xfs_efi_log_item *efip = EFI_ITEM(lip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138
Dave Chinner9c5f8412010-12-20 11:57:24 +1100139 if (remove) {
140 ASSERT(!(lip->li_flags & XFS_LI_IN_AIL));
Dave Chinnere34a3142011-01-27 12:13:35 +1100141 if (lip->li_desc)
142 xfs_trans_del_item(lip);
Christoph Hellwig7d795ca2005-06-21 15:41:19 +1000143 xfs_efi_item_free(efip);
Dave Chinnerb199c8a2010-12-20 11:59:49 +1100144 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 }
Dave Chinnerb199c8a2010-12-20 11:59:49 +1100146 __xfs_efi_release(efip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147}
148
149/*
150 * Efi items have no locking or pushing. However, since EFIs are
151 * pulled from the AIL when their corresponding EFDs are committed
152 * to disk, their situation is very similar to being pinned. Return
153 * XFS_ITEM_PINNED so that the caller will eventually flush the log.
154 * This should help in getting the EFI out of the AIL.
155 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156STATIC uint
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000157xfs_efi_item_trylock(
158 struct xfs_log_item *lip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159{
160 return XFS_ITEM_PINNED;
161}
162
163/*
164 * Efi items have no locking, so just return.
165 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166STATIC void
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000167xfs_efi_item_unlock(
168 struct xfs_log_item *lip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169{
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000170 if (lip->li_flags & XFS_LI_ABORTED)
171 xfs_efi_item_free(EFI_ITEM(lip));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172}
173
174/*
Dave Chinnerb199c8a2010-12-20 11:59:49 +1100175 * The EFI is logged only once and cannot be moved in the log, so simply return
176 * the lsn at which it's been logged. For bulk transaction committed
177 * processing, the EFI may be processed but not yet unpinned prior to the EFD
178 * being processed. Set the XFS_EFI_COMMITTED flag so this case can be detected
179 * when processing the EFD.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181STATIC xfs_lsn_t
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000182xfs_efi_item_committed(
183 struct xfs_log_item *lip,
184 xfs_lsn_t lsn)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185{
Dave Chinnerb199c8a2010-12-20 11:59:49 +1100186 struct xfs_efi_log_item *efip = EFI_ITEM(lip);
187
188 set_bit(XFS_EFI_COMMITTED, &efip->efi_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 return lsn;
190}
191
192/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 * There isn't much you can do to push on an efi item. It is simply
194 * stuck waiting for all of its corresponding efd items to be
195 * committed to disk.
196 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197STATIC void
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000198xfs_efi_item_push(
199 struct xfs_log_item *lip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201}
202
203/*
204 * The EFI dependency tracking op doesn't do squat. It can't because
205 * it doesn't know where the free extent is coming from. The dependency
206 * tracking has to be handled by the "enclosing" metadata object. For
207 * example, for inodes, the inode is locked throughout the extent freeing
208 * so the dependency should be recorded there.
209 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210STATIC void
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000211xfs_efi_item_committing(
212 struct xfs_log_item *lip,
213 xfs_lsn_t lsn)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215}
216
217/*
218 * This is the ops vector shared by all efi log items.
219 */
David Chinner7989cb82007-02-10 18:34:56 +1100220static struct xfs_item_ops xfs_efi_item_ops = {
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000221 .iop_size = xfs_efi_item_size,
222 .iop_format = xfs_efi_item_format,
223 .iop_pin = xfs_efi_item_pin,
224 .iop_unpin = xfs_efi_item_unpin,
225 .iop_trylock = xfs_efi_item_trylock,
226 .iop_unlock = xfs_efi_item_unlock,
227 .iop_committed = xfs_efi_item_committed,
228 .iop_push = xfs_efi_item_push,
229 .iop_committing = xfs_efi_item_committing
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230};
231
232
233/*
234 * Allocate and initialize an efi item with the given number of extents.
235 */
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000236struct xfs_efi_log_item *
237xfs_efi_init(
238 struct xfs_mount *mp,
239 uint nextents)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240
241{
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000242 struct xfs_efi_log_item *efip;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 uint size;
244
245 ASSERT(nextents > 0);
246 if (nextents > XFS_EFI_MAX_FAST_EXTENTS) {
247 size = (uint)(sizeof(xfs_efi_log_item_t) +
248 ((nextents - 1) * sizeof(xfs_extent_t)));
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000249 efip = kmem_zalloc(size, KM_SLEEP);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 } else {
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000251 efip = kmem_zone_zalloc(xfs_efi_zone, KM_SLEEP);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 }
253
Dave Chinner43f5efc2010-03-23 10:10:00 +1100254 xfs_log_item_init(mp, &efip->efi_item, XFS_LI_EFI, &xfs_efi_item_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 efip->efi_format.efi_nextents = nextents;
256 efip->efi_format.efi_id = (__psint_t)(void*)efip;
Dave Chinnerb199c8a2010-12-20 11:59:49 +1100257 atomic_set(&efip->efi_next_extent, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000259 return efip;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260}
261
262/*
Tim Shimmin6d192a92006-06-09 14:55:38 +1000263 * Copy an EFI format buffer from the given buf, and into the destination
264 * EFI format structure.
265 * The given buffer can be in 32 bit or 64 bit form (which has different padding),
266 * one of which will be the native format for this kernel.
267 * It will handle the conversion of formats if necessary.
268 */
269int
270xfs_efi_copy_format(xfs_log_iovec_t *buf, xfs_efi_log_format_t *dst_efi_fmt)
271{
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +1000272 xfs_efi_log_format_t *src_efi_fmt = buf->i_addr;
Tim Shimmin6d192a92006-06-09 14:55:38 +1000273 uint i;
274 uint len = sizeof(xfs_efi_log_format_t) +
275 (src_efi_fmt->efi_nextents - 1) * sizeof(xfs_extent_t);
276 uint len32 = sizeof(xfs_efi_log_format_32_t) +
277 (src_efi_fmt->efi_nextents - 1) * sizeof(xfs_extent_32_t);
278 uint len64 = sizeof(xfs_efi_log_format_64_t) +
279 (src_efi_fmt->efi_nextents - 1) * sizeof(xfs_extent_64_t);
280
281 if (buf->i_len == len) {
282 memcpy((char *)dst_efi_fmt, (char*)src_efi_fmt, len);
283 return 0;
284 } else if (buf->i_len == len32) {
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +1000285 xfs_efi_log_format_32_t *src_efi_fmt_32 = buf->i_addr;
Tim Shimmin6d192a92006-06-09 14:55:38 +1000286
287 dst_efi_fmt->efi_type = src_efi_fmt_32->efi_type;
288 dst_efi_fmt->efi_size = src_efi_fmt_32->efi_size;
289 dst_efi_fmt->efi_nextents = src_efi_fmt_32->efi_nextents;
290 dst_efi_fmt->efi_id = src_efi_fmt_32->efi_id;
291 for (i = 0; i < dst_efi_fmt->efi_nextents; i++) {
292 dst_efi_fmt->efi_extents[i].ext_start =
293 src_efi_fmt_32->efi_extents[i].ext_start;
294 dst_efi_fmt->efi_extents[i].ext_len =
295 src_efi_fmt_32->efi_extents[i].ext_len;
296 }
297 return 0;
298 } else if (buf->i_len == len64) {
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +1000299 xfs_efi_log_format_64_t *src_efi_fmt_64 = buf->i_addr;
Tim Shimmin6d192a92006-06-09 14:55:38 +1000300
301 dst_efi_fmt->efi_type = src_efi_fmt_64->efi_type;
302 dst_efi_fmt->efi_size = src_efi_fmt_64->efi_size;
303 dst_efi_fmt->efi_nextents = src_efi_fmt_64->efi_nextents;
304 dst_efi_fmt->efi_id = src_efi_fmt_64->efi_id;
305 for (i = 0; i < dst_efi_fmt->efi_nextents; i++) {
306 dst_efi_fmt->efi_extents[i].ext_start =
307 src_efi_fmt_64->efi_extents[i].ext_start;
308 dst_efi_fmt->efi_extents[i].ext_len =
309 src_efi_fmt_64->efi_extents[i].ext_len;
310 }
311 return 0;
312 }
313 return EFSCORRUPTED;
314}
315
316/*
Dave Chinnerb199c8a2010-12-20 11:59:49 +1100317 * This is called by the efd item code below to release references to the given
318 * efi item. Each efd calls this with the number of extents that it has
319 * logged, and when the sum of these reaches the total number of extents logged
320 * by this efi item we can free the efi item.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 */
322void
323xfs_efi_release(xfs_efi_log_item_t *efip,
324 uint nextents)
325{
Dave Chinnerb199c8a2010-12-20 11:59:49 +1100326 ASSERT(atomic_read(&efip->efi_next_extent) >= nextents);
327 if (atomic_sub_and_test(nextents, &efip->efi_next_extent))
328 __xfs_efi_release(efip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329}
330
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000331static inline struct xfs_efd_log_item *EFD_ITEM(struct xfs_log_item *lip)
Christoph Hellwig7d795ca2005-06-21 15:41:19 +1000332{
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000333 return container_of(lip, struct xfs_efd_log_item, efd_item);
334}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000336STATIC void
337xfs_efd_item_free(struct xfs_efd_log_item *efdp)
338{
339 if (efdp->efd_format.efd_nextents > XFS_EFD_MAX_FAST_EXTENTS)
Denys Vlasenkof0e2d932008-05-19 16:31:57 +1000340 kmem_free(efdp);
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000341 else
Christoph Hellwig7d795ca2005-06-21 15:41:19 +1000342 kmem_zone_free(xfs_efd_zone, efdp);
Christoph Hellwig7d795ca2005-06-21 15:41:19 +1000343}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344
345/*
346 * This returns the number of iovecs needed to log the given efd item.
347 * We only need 1 iovec for an efd item. It just logs the efd_log_format
348 * structure.
349 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350STATIC uint
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000351xfs_efd_item_size(
352 struct xfs_log_item *lip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353{
354 return 1;
355}
356
357/*
358 * This is called to fill in the vector of log iovecs for the
359 * given efd log item. We use only 1 iovec, and we point that
360 * at the efd_log_format structure embedded in the efd item.
361 * It is at this point that we assert that all of the extent
362 * slots in the efd item have been filled.
363 */
364STATIC void
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000365xfs_efd_item_format(
366 struct xfs_log_item *lip,
367 struct xfs_log_iovec *log_vector)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368{
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000369 struct xfs_efd_log_item *efdp = EFD_ITEM(lip);
370 uint size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371
372 ASSERT(efdp->efd_next_extent == efdp->efd_format.efd_nextents);
373
374 efdp->efd_format.efd_type = XFS_LI_EFD;
375
376 size = sizeof(xfs_efd_log_format_t);
377 size += (efdp->efd_format.efd_nextents - 1) * sizeof(xfs_extent_t);
378 efdp->efd_format.efd_size = 1;
379
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +1000380 log_vector->i_addr = &efdp->efd_format;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 log_vector->i_len = size;
Christoph Hellwig4139b3b2010-01-19 09:56:45 +0000382 log_vector->i_type = XLOG_REG_TYPE_EFD_FORMAT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 ASSERT(size >= sizeof(xfs_efd_log_format_t));
384}
385
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386/*
387 * Pinning has no meaning for an efd item, so just return.
388 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389STATIC void
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000390xfs_efd_item_pin(
391 struct xfs_log_item *lip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393}
394
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395/*
396 * Since pinning has no meaning for an efd item, unpinning does
397 * not either.
398 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399STATIC void
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000400xfs_efd_item_unpin(
401 struct xfs_log_item *lip,
402 int remove)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404}
405
406/*
407 * Efd items have no locking, so just return success.
408 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409STATIC uint
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000410xfs_efd_item_trylock(
411 struct xfs_log_item *lip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412{
413 return XFS_ITEM_LOCKED;
414}
415
416/*
417 * Efd items have no locking or pushing, so return failure
418 * so that the caller doesn't bother with us.
419 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420STATIC void
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000421xfs_efd_item_unlock(
422 struct xfs_log_item *lip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423{
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000424 if (lip->li_flags & XFS_LI_ABORTED)
425 xfs_efd_item_free(EFD_ITEM(lip));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426}
427
428/*
429 * When the efd item is committed to disk, all we need to do
430 * is delete our reference to our partner efi item and then
431 * free ourselves. Since we're freeing ourselves we must
432 * return -1 to keep the transaction code from further referencing
433 * this item.
434 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435STATIC xfs_lsn_t
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000436xfs_efd_item_committed(
437 struct xfs_log_item *lip,
438 xfs_lsn_t lsn)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439{
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000440 struct xfs_efd_log_item *efdp = EFD_ITEM(lip);
441
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 /*
443 * If we got a log I/O error, it's always the case that the LR with the
444 * EFI got unpinned and freed before the EFD got aborted.
445 */
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000446 if (!(lip->li_flags & XFS_LI_ABORTED))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 xfs_efi_release(efdp->efd_efip, efdp->efd_format.efd_nextents);
448
Christoph Hellwig7d795ca2005-06-21 15:41:19 +1000449 xfs_efd_item_free(efdp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 return (xfs_lsn_t)-1;
451}
452
453/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 * There isn't much you can do to push on an efd item. It is simply
455 * stuck waiting for the log to be flushed to disk.
456 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457STATIC void
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000458xfs_efd_item_push(
459 struct xfs_log_item *lip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461}
462
463/*
464 * The EFD dependency tracking op doesn't do squat. It can't because
465 * it doesn't know where the free extent is coming from. The dependency
466 * tracking has to be handled by the "enclosing" metadata object. For
467 * example, for inodes, the inode is locked throughout the extent freeing
468 * so the dependency should be recorded there.
469 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470STATIC void
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000471xfs_efd_item_committing(
472 struct xfs_log_item *lip,
473 xfs_lsn_t lsn)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475}
476
477/*
478 * This is the ops vector shared by all efd log items.
479 */
David Chinner7989cb82007-02-10 18:34:56 +1100480static struct xfs_item_ops xfs_efd_item_ops = {
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000481 .iop_size = xfs_efd_item_size,
482 .iop_format = xfs_efd_item_format,
483 .iop_pin = xfs_efd_item_pin,
484 .iop_unpin = xfs_efd_item_unpin,
485 .iop_trylock = xfs_efd_item_trylock,
486 .iop_unlock = xfs_efd_item_unlock,
487 .iop_committed = xfs_efd_item_committed,
488 .iop_push = xfs_efd_item_push,
489 .iop_committing = xfs_efd_item_committing
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490};
491
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492/*
493 * Allocate and initialize an efd item with the given number of extents.
494 */
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000495struct xfs_efd_log_item *
496xfs_efd_init(
497 struct xfs_mount *mp,
498 struct xfs_efi_log_item *efip,
499 uint nextents)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500
501{
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000502 struct xfs_efd_log_item *efdp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 uint size;
504
505 ASSERT(nextents > 0);
506 if (nextents > XFS_EFD_MAX_FAST_EXTENTS) {
507 size = (uint)(sizeof(xfs_efd_log_item_t) +
508 ((nextents - 1) * sizeof(xfs_extent_t)));
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000509 efdp = kmem_zalloc(size, KM_SLEEP);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 } else {
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000511 efdp = kmem_zone_zalloc(xfs_efd_zone, KM_SLEEP);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 }
513
Dave Chinner43f5efc2010-03-23 10:10:00 +1100514 xfs_log_item_init(mp, &efdp->efd_item, XFS_LI_EFD, &xfs_efd_item_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 efdp->efd_efip = efip;
516 efdp->efd_format.efd_nextents = nextents;
517 efdp->efd_format.efd_efi_id = efip->efi_format.efi_id;
518
Christoph Hellwig7bfa31d2010-06-23 18:11:15 +1000519 return efdp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520}