2 * Copyright (C) 2016 Oracle. All Rights Reserved.
4 * Author: Darrick J. Wong <darrick.wong@oracle.com>
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version 2
9 * of the License, or (at your option) any later version.
11 * This program is distributed in the hope that it would be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
22 #include "xfs_format.h"
23 #include "xfs_log_format.h"
24 #include "xfs_trans_resv.h"
26 #include "xfs_mount.h"
27 #include "xfs_defer.h"
28 #include "xfs_trans.h"
29 #include "xfs_trans_priv.h"
30 #include "xfs_buf_item.h"
31 #include "xfs_refcount_item.h"
33 #include "xfs_refcount.h"
36 kmem_zone_t
*xfs_cui_zone
;
37 kmem_zone_t
*xfs_cud_zone
;
39 static inline struct xfs_cui_log_item
*CUI_ITEM(struct xfs_log_item
*lip
)
41 return container_of(lip
, struct xfs_cui_log_item
, cui_item
);
46 struct xfs_cui_log_item
*cuip
)
48 if (cuip
->cui_format
.cui_nextents
> XFS_CUI_MAX_FAST_EXTENTS
)
51 kmem_zone_free(xfs_cui_zone
, cuip
);
56 struct xfs_log_item
*lip
,
60 struct xfs_cui_log_item
*cuip
= CUI_ITEM(lip
);
63 *nbytes
+= xfs_cui_log_format_sizeof(cuip
->cui_format
.cui_nextents
);
67 * This is called to fill in the vector of log iovecs for the
68 * given cui log item. We use only 1 iovec, and we point that
69 * at the cui_log_format structure embedded in the cui item.
70 * It is at this point that we assert that all of the extent
71 * slots in the cui item have been filled.
75 struct xfs_log_item
*lip
,
76 struct xfs_log_vec
*lv
)
78 struct xfs_cui_log_item
*cuip
= CUI_ITEM(lip
);
79 struct xfs_log_iovec
*vecp
= NULL
;
81 ASSERT(atomic_read(&cuip
->cui_next_extent
) ==
82 cuip
->cui_format
.cui_nextents
);
84 cuip
->cui_format
.cui_type
= XFS_LI_CUI
;
85 cuip
->cui_format
.cui_size
= 1;
87 xlog_copy_iovec(lv
, &vecp
, XLOG_REG_TYPE_CUI_FORMAT
, &cuip
->cui_format
,
88 xfs_cui_log_format_sizeof(cuip
->cui_format
.cui_nextents
));
92 * Pinning has no meaning for an cui item, so just return.
96 struct xfs_log_item
*lip
)
101 * The unpin operation is the last place an CUI is manipulated in the log. It is
102 * either inserted in the AIL or aborted in the event of a log I/O error. In
103 * either case, the CUI transaction has been successfully committed to make it
104 * this far. Therefore, we expect whoever committed the CUI to either construct
105 * and commit the CUD or drop the CUD's reference in the event of error. Simply
106 * drop the log's CUI reference now that the log is done with it.
110 struct xfs_log_item
*lip
,
113 struct xfs_cui_log_item
*cuip
= CUI_ITEM(lip
);
115 xfs_cui_release(cuip
);
119 * CUI items have no locking or pushing. However, since CUIs are pulled from
120 * the AIL when their corresponding CUDs are committed to disk, their situation
121 * is very similar to being pinned. Return XFS_ITEM_PINNED so that the caller
122 * will eventually flush the log. This should help in getting the CUI out of
127 struct xfs_log_item
*lip
,
128 struct list_head
*buffer_list
)
130 return XFS_ITEM_PINNED
;
134 * The CUI has been either committed or aborted if the transaction has been
135 * cancelled. If the transaction was cancelled, an CUD isn't going to be
136 * constructed and thus we free the CUI here directly.
140 struct xfs_log_item
*lip
)
142 if (lip
->li_flags
& XFS_LI_ABORTED
)
143 xfs_cui_item_free(CUI_ITEM(lip
));
147 * The CUI is logged only once and cannot be moved in the log, so simply return
148 * the lsn at which it's been logged.
151 xfs_cui_item_committed(
152 struct xfs_log_item
*lip
,
159 * The CUI dependency tracking op doesn't do squat. It can't because
160 * it doesn't know where the free extent is coming from. The dependency
161 * tracking has to be handled by the "enclosing" metadata object. For
162 * example, for inodes, the inode is locked throughout the extent freeing
163 * so the dependency should be recorded there.
166 xfs_cui_item_committing(
167 struct xfs_log_item
*lip
,
173 * This is the ops vector shared by all cui log items.
175 static const struct xfs_item_ops xfs_cui_item_ops
= {
176 .iop_size
= xfs_cui_item_size
,
177 .iop_format
= xfs_cui_item_format
,
178 .iop_pin
= xfs_cui_item_pin
,
179 .iop_unpin
= xfs_cui_item_unpin
,
180 .iop_unlock
= xfs_cui_item_unlock
,
181 .iop_committed
= xfs_cui_item_committed
,
182 .iop_push
= xfs_cui_item_push
,
183 .iop_committing
= xfs_cui_item_committing
,
187 * Allocate and initialize an cui item with the given number of extents.
189 struct xfs_cui_log_item
*
191 struct xfs_mount
*mp
,
195 struct xfs_cui_log_item
*cuip
;
197 ASSERT(nextents
> 0);
198 if (nextents
> XFS_CUI_MAX_FAST_EXTENTS
)
199 cuip
= kmem_zalloc(xfs_cui_log_item_sizeof(nextents
),
202 cuip
= kmem_zone_zalloc(xfs_cui_zone
, KM_SLEEP
);
204 xfs_log_item_init(mp
, &cuip
->cui_item
, XFS_LI_CUI
, &xfs_cui_item_ops
);
205 cuip
->cui_format
.cui_nextents
= nextents
;
206 cuip
->cui_format
.cui_id
= (uintptr_t)(void *)cuip
;
207 atomic_set(&cuip
->cui_next_extent
, 0);
208 atomic_set(&cuip
->cui_refcount
, 2);
214 * Freeing the CUI requires that we remove it from the AIL if it has already
215 * been placed there. However, the CUI may not yet have been placed in the AIL
216 * when called by xfs_cui_release() from CUD processing due to the ordering of
217 * committed vs unpin operations in bulk insert operations. Hence the reference
218 * count to ensure only the last caller frees the CUI.
222 struct xfs_cui_log_item
*cuip
)
224 ASSERT(atomic_read(&cuip
->cui_refcount
) > 0);
225 if (atomic_dec_and_test(&cuip
->cui_refcount
)) {
226 xfs_trans_ail_remove(&cuip
->cui_item
, SHUTDOWN_LOG_IO_ERROR
);
227 xfs_cui_item_free(cuip
);
231 static inline struct xfs_cud_log_item
*CUD_ITEM(struct xfs_log_item
*lip
)
233 return container_of(lip
, struct xfs_cud_log_item
, cud_item
);
238 struct xfs_log_item
*lip
,
243 *nbytes
+= sizeof(struct xfs_cud_log_format
);
247 * This is called to fill in the vector of log iovecs for the
248 * given cud log item. We use only 1 iovec, and we point that
249 * at the cud_log_format structure embedded in the cud item.
250 * It is at this point that we assert that all of the extent
251 * slots in the cud item have been filled.
255 struct xfs_log_item
*lip
,
256 struct xfs_log_vec
*lv
)
258 struct xfs_cud_log_item
*cudp
= CUD_ITEM(lip
);
259 struct xfs_log_iovec
*vecp
= NULL
;
261 cudp
->cud_format
.cud_type
= XFS_LI_CUD
;
262 cudp
->cud_format
.cud_size
= 1;
264 xlog_copy_iovec(lv
, &vecp
, XLOG_REG_TYPE_CUD_FORMAT
, &cudp
->cud_format
,
265 sizeof(struct xfs_cud_log_format
));
269 * Pinning has no meaning for an cud item, so just return.
273 struct xfs_log_item
*lip
)
278 * Since pinning has no meaning for an cud item, unpinning does
283 struct xfs_log_item
*lip
,
289 * There isn't much you can do to push on an cud item. It is simply stuck
290 * waiting for the log to be flushed to disk.
294 struct xfs_log_item
*lip
,
295 struct list_head
*buffer_list
)
297 return XFS_ITEM_PINNED
;
301 * The CUD is either committed or aborted if the transaction is cancelled. If
302 * the transaction is cancelled, drop our reference to the CUI and free the
307 struct xfs_log_item
*lip
)
309 struct xfs_cud_log_item
*cudp
= CUD_ITEM(lip
);
311 if (lip
->li_flags
& XFS_LI_ABORTED
) {
312 xfs_cui_release(cudp
->cud_cuip
);
313 kmem_zone_free(xfs_cud_zone
, cudp
);
318 * When the cud item is committed to disk, all we need to do is delete our
319 * reference to our partner cui item and then free ourselves. Since we're
320 * freeing ourselves we must return -1 to keep the transaction code from
321 * further referencing this item.
324 xfs_cud_item_committed(
325 struct xfs_log_item
*lip
,
328 struct xfs_cud_log_item
*cudp
= CUD_ITEM(lip
);
331 * Drop the CUI reference regardless of whether the CUD has been
332 * aborted. Once the CUD transaction is constructed, it is the sole
333 * responsibility of the CUD to release the CUI (even if the CUI is
334 * aborted due to log I/O error).
336 xfs_cui_release(cudp
->cud_cuip
);
337 kmem_zone_free(xfs_cud_zone
, cudp
);
339 return (xfs_lsn_t
)-1;
343 * The CUD dependency tracking op doesn't do squat. It can't because
344 * it doesn't know where the free extent is coming from. The dependency
345 * tracking has to be handled by the "enclosing" metadata object. For
346 * example, for inodes, the inode is locked throughout the extent freeing
347 * so the dependency should be recorded there.
350 xfs_cud_item_committing(
351 struct xfs_log_item
*lip
,
357 * This is the ops vector shared by all cud log items.
359 static const struct xfs_item_ops xfs_cud_item_ops
= {
360 .iop_size
= xfs_cud_item_size
,
361 .iop_format
= xfs_cud_item_format
,
362 .iop_pin
= xfs_cud_item_pin
,
363 .iop_unpin
= xfs_cud_item_unpin
,
364 .iop_unlock
= xfs_cud_item_unlock
,
365 .iop_committed
= xfs_cud_item_committed
,
366 .iop_push
= xfs_cud_item_push
,
367 .iop_committing
= xfs_cud_item_committing
,
371 * Allocate and initialize an cud item with the given number of extents.
373 struct xfs_cud_log_item
*
375 struct xfs_mount
*mp
,
376 struct xfs_cui_log_item
*cuip
)
379 struct xfs_cud_log_item
*cudp
;
381 cudp
= kmem_zone_zalloc(xfs_cud_zone
, KM_SLEEP
);
382 xfs_log_item_init(mp
, &cudp
->cud_item
, XFS_LI_CUD
, &xfs_cud_item_ops
);
383 cudp
->cud_cuip
= cuip
;
384 cudp
->cud_format
.cud_cui_id
= cuip
->cui_format
.cui_id
;
390 * Process a refcount update intent item that was recovered from the log.
391 * We need to update the refcountbt.
395 struct xfs_mount
*mp
,
396 struct xfs_cui_log_item
*cuip
,
397 struct xfs_defer_ops
*dfops
)
401 unsigned int refc_type
;
402 struct xfs_phys_extent
*refc
;
403 xfs_fsblock_t startblock_fsb
;
405 struct xfs_cud_log_item
*cudp
;
406 struct xfs_trans
*tp
;
407 struct xfs_btree_cur
*rcur
= NULL
;
408 enum xfs_refcount_intent_type type
;
409 xfs_fsblock_t new_fsb
;
410 xfs_extlen_t new_len
;
411 struct xfs_bmbt_irec irec
;
412 bool requeue_only
= false;
414 ASSERT(!test_bit(XFS_CUI_RECOVERED
, &cuip
->cui_flags
));
417 * First check the validity of the extents described by the
418 * CUI. If any are bad, then assume that all are bad and
421 for (i
= 0; i
< cuip
->cui_format
.cui_nextents
; i
++) {
422 refc
= &cuip
->cui_format
.cui_extents
[i
];
423 startblock_fsb
= XFS_BB_TO_FSB(mp
,
424 XFS_FSB_TO_DADDR(mp
, refc
->pe_startblock
));
425 switch (refc
->pe_flags
& XFS_REFCOUNT_EXTENT_TYPE_MASK
) {
426 case XFS_REFCOUNT_INCREASE
:
427 case XFS_REFCOUNT_DECREASE
:
428 case XFS_REFCOUNT_ALLOC_COW
:
429 case XFS_REFCOUNT_FREE_COW
:
436 if (!op_ok
|| startblock_fsb
== 0 ||
438 startblock_fsb
>= mp
->m_sb
.sb_dblocks
||
439 refc
->pe_len
>= mp
->m_sb
.sb_agblocks
||
440 (refc
->pe_flags
& ~XFS_REFCOUNT_EXTENT_FLAGS
)) {
442 * This will pull the CUI from the AIL and
443 * free the memory associated with it.
445 set_bit(XFS_CUI_RECOVERED
, &cuip
->cui_flags
);
446 xfs_cui_release(cuip
);
452 * Under normal operation, refcount updates are deferred, so we
453 * wouldn't be adding them directly to a transaction. All
454 * refcount updates manage reservation usage internally and
455 * dynamically by deferring work that won't fit in the
456 * transaction. Normally, any work that needs to be deferred
457 * gets attached to the same defer_ops that scheduled the
458 * refcount update. However, we're in log recovery here, so we
459 * we create our own defer_ops and use that to finish up any
460 * work that doesn't fit.
462 error
= xfs_trans_alloc(mp
, &M_RES(mp
)->tr_itruncate
, 0, 0, 0, &tp
);
465 cudp
= xfs_trans_get_cud(tp
, cuip
);
467 for (i
= 0; i
< cuip
->cui_format
.cui_nextents
; i
++) {
468 refc
= &cuip
->cui_format
.cui_extents
[i
];
469 refc_type
= refc
->pe_flags
& XFS_REFCOUNT_EXTENT_TYPE_MASK
;
471 case XFS_REFCOUNT_INCREASE
:
472 case XFS_REFCOUNT_DECREASE
:
473 case XFS_REFCOUNT_ALLOC_COW
:
474 case XFS_REFCOUNT_FREE_COW
:
478 error
= -EFSCORRUPTED
;
482 new_fsb
= refc
->pe_startblock
;
483 new_len
= refc
->pe_len
;
485 error
= xfs_trans_log_finish_refcount_update(tp
, cudp
,
486 dfops
, type
, refc
->pe_startblock
, refc
->pe_len
,
487 &new_fsb
, &new_len
, &rcur
);
491 /* Requeue what we didn't finish. */
493 irec
.br_startblock
= new_fsb
;
494 irec
.br_blockcount
= new_len
;
496 case XFS_REFCOUNT_INCREASE
:
497 error
= xfs_refcount_increase_extent(
498 tp
->t_mountp
, dfops
, &irec
);
500 case XFS_REFCOUNT_DECREASE
:
501 error
= xfs_refcount_decrease_extent(
502 tp
->t_mountp
, dfops
, &irec
);
504 case XFS_REFCOUNT_ALLOC_COW
:
505 error
= xfs_refcount_alloc_cow_extent(
510 case XFS_REFCOUNT_FREE_COW
:
511 error
= xfs_refcount_free_cow_extent(
525 xfs_refcount_finish_one_cleanup(tp
, rcur
, error
);
526 set_bit(XFS_CUI_RECOVERED
, &cuip
->cui_flags
);
527 error
= xfs_trans_commit(tp
);
531 xfs_refcount_finish_one_cleanup(tp
, rcur
, error
);
532 xfs_trans_cancel(tp
);