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_shared.h"
27 #include "xfs_mount.h"
28 #include "xfs_defer.h"
29 #include "xfs_trans.h"
30 #include "xfs_trans_priv.h"
31 #include "xfs_buf_item.h"
32 #include "xfs_rmap_item.h"
37 kmem_zone_t *xfs_rui_zone;
38 kmem_zone_t *xfs_rud_zone;
40 static inline struct xfs_rui_log_item *RUI_ITEM(struct xfs_log_item *lip)
42 return container_of(lip, struct xfs_rui_log_item, rui_item);
47 struct xfs_rui_log_item *ruip)
49 if (ruip->rui_format.rui_nextents > XFS_RUI_MAX_FAST_EXTENTS)
52 kmem_zone_free(xfs_rui_zone, ruip);
57 struct xfs_log_item *lip,
61 struct xfs_rui_log_item *ruip = RUI_ITEM(lip);
64 *nbytes += xfs_rui_log_format_sizeof(ruip->rui_format.rui_nextents);
68 * This is called to fill in the vector of log iovecs for the
69 * given rui log item. We use only 1 iovec, and we point that
70 * at the rui_log_format structure embedded in the rui item.
71 * It is at this point that we assert that all of the extent
72 * slots in the rui item have been filled.
76 struct xfs_log_item *lip,
77 struct xfs_log_vec *lv)
79 struct xfs_rui_log_item *ruip = RUI_ITEM(lip);
80 struct xfs_log_iovec *vecp = NULL;
82 ASSERT(atomic_read(&ruip->rui_next_extent) ==
83 ruip->rui_format.rui_nextents);
85 ruip->rui_format.rui_type = XFS_LI_RUI;
86 ruip->rui_format.rui_size = 1;
88 xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_RUI_FORMAT, &ruip->rui_format,
89 xfs_rui_log_format_sizeof(ruip->rui_format.rui_nextents));
93 * Pinning has no meaning for an rui item, so just return.
97 struct xfs_log_item *lip)
102 * The unpin operation is the last place an RUI is manipulated in the log. It is
103 * either inserted in the AIL or aborted in the event of a log I/O error. In
104 * either case, the RUI transaction has been successfully committed to make it
105 * this far. Therefore, we expect whoever committed the RUI to either construct
106 * and commit the RUD or drop the RUD's reference in the event of error. Simply
107 * drop the log's RUI reference now that the log is done with it.
111 struct xfs_log_item *lip,
114 struct xfs_rui_log_item *ruip = RUI_ITEM(lip);
116 xfs_rui_release(ruip);
120 * RUI items have no locking or pushing. However, since RUIs are pulled from
121 * the AIL when their corresponding RUDs are committed to disk, their situation
122 * is very similar to being pinned. Return XFS_ITEM_PINNED so that the caller
123 * will eventually flush the log. This should help in getting the RUI out of
128 struct xfs_log_item *lip,
129 struct list_head *buffer_list)
131 return XFS_ITEM_PINNED;
135 * The RUI has been either committed or aborted if the transaction has been
136 * cancelled. If the transaction was cancelled, an RUD isn't going to be
137 * constructed and thus we free the RUI here directly.
141 struct xfs_log_item *lip)
143 if (lip->li_flags & XFS_LI_ABORTED)
144 xfs_rui_item_free(RUI_ITEM(lip));
148 * The RUI is logged only once and cannot be moved in the log, so simply return
149 * the lsn at which it's been logged.
152 xfs_rui_item_committed(
153 struct xfs_log_item *lip,
160 * The RUI dependency tracking op doesn't do squat. It can't because
161 * it doesn't know where the free extent is coming from. The dependency
162 * tracking has to be handled by the "enclosing" metadata object. For
163 * example, for inodes, the inode is locked throughout the extent freeing
164 * so the dependency should be recorded there.
167 xfs_rui_item_committing(
168 struct xfs_log_item *lip,
174 * This is the ops vector shared by all rui log items.
176 static const struct xfs_item_ops xfs_rui_item_ops = {
177 .iop_size = xfs_rui_item_size,
178 .iop_format = xfs_rui_item_format,
179 .iop_pin = xfs_rui_item_pin,
180 .iop_unpin = xfs_rui_item_unpin,
181 .iop_unlock = xfs_rui_item_unlock,
182 .iop_committed = xfs_rui_item_committed,
183 .iop_push = xfs_rui_item_push,
184 .iop_committing = xfs_rui_item_committing,
188 * Allocate and initialize an rui item with the given number of extents.
190 struct xfs_rui_log_item *
192 struct xfs_mount *mp,
196 struct xfs_rui_log_item *ruip;
198 ASSERT(nextents > 0);
199 if (nextents > XFS_RUI_MAX_FAST_EXTENTS)
200 ruip = kmem_zalloc(xfs_rui_log_item_sizeof(nextents), KM_SLEEP);
202 ruip = kmem_zone_zalloc(xfs_rui_zone, KM_SLEEP);
204 xfs_log_item_init(mp, &ruip->rui_item, XFS_LI_RUI, &xfs_rui_item_ops);
205 ruip->rui_format.rui_nextents = nextents;
206 ruip->rui_format.rui_id = (uintptr_t)(void *)ruip;
207 atomic_set(&ruip->rui_next_extent, 0);
208 atomic_set(&ruip->rui_refcount, 2);
214 * Copy an RUI format buffer from the given buf, and into the destination
215 * RUI format structure. The RUI/RUD items were designed not to need any
216 * special alignment handling.
220 struct xfs_log_iovec *buf,
221 struct xfs_rui_log_format *dst_rui_fmt)
223 struct xfs_rui_log_format *src_rui_fmt;
226 src_rui_fmt = buf->i_addr;
227 len = xfs_rui_log_format_sizeof(src_rui_fmt->rui_nextents);
229 if (buf->i_len != len)
230 return -EFSCORRUPTED;
232 memcpy(dst_rui_fmt, src_rui_fmt, len);
237 * Freeing the RUI requires that we remove it from the AIL if it has already
238 * been placed there. However, the RUI may not yet have been placed in the AIL
239 * when called by xfs_rui_release() from RUD processing due to the ordering of
240 * committed vs unpin operations in bulk insert operations. Hence the reference
241 * count to ensure only the last caller frees the RUI.
245 struct xfs_rui_log_item *ruip)
247 ASSERT(atomic_read(&ruip->rui_refcount) > 0);
248 if (atomic_dec_and_test(&ruip->rui_refcount)) {
249 xfs_trans_ail_remove(&ruip->rui_item, SHUTDOWN_LOG_IO_ERROR);
250 xfs_rui_item_free(ruip);
254 static inline struct xfs_rud_log_item *RUD_ITEM(struct xfs_log_item *lip)
256 return container_of(lip, struct xfs_rud_log_item, rud_item);
261 struct xfs_log_item *lip,
266 *nbytes += sizeof(struct xfs_rud_log_format);
270 * This is called to fill in the vector of log iovecs for the
271 * given rud log item. We use only 1 iovec, and we point that
272 * at the rud_log_format structure embedded in the rud item.
273 * It is at this point that we assert that all of the extent
274 * slots in the rud item have been filled.
278 struct xfs_log_item *lip,
279 struct xfs_log_vec *lv)
281 struct xfs_rud_log_item *rudp = RUD_ITEM(lip);
282 struct xfs_log_iovec *vecp = NULL;
284 rudp->rud_format.rud_type = XFS_LI_RUD;
285 rudp->rud_format.rud_size = 1;
287 xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_RUD_FORMAT, &rudp->rud_format,
288 sizeof(struct xfs_rud_log_format));
292 * Pinning has no meaning for an rud item, so just return.
296 struct xfs_log_item *lip)
301 * Since pinning has no meaning for an rud item, unpinning does
306 struct xfs_log_item *lip,
312 * There isn't much you can do to push on an rud item. It is simply stuck
313 * waiting for the log to be flushed to disk.
317 struct xfs_log_item *lip,
318 struct list_head *buffer_list)
320 return XFS_ITEM_PINNED;
324 * The RUD is either committed or aborted if the transaction is cancelled. If
325 * the transaction is cancelled, drop our reference to the RUI and free the
330 struct xfs_log_item *lip)
332 struct xfs_rud_log_item *rudp = RUD_ITEM(lip);
334 if (lip->li_flags & XFS_LI_ABORTED) {
335 xfs_rui_release(rudp->rud_ruip);
336 kmem_zone_free(xfs_rud_zone, rudp);
341 * When the rud item is committed to disk, all we need to do is delete our
342 * reference to our partner rui item and then free ourselves. Since we're
343 * freeing ourselves we must return -1 to keep the transaction code from
344 * further referencing this item.
347 xfs_rud_item_committed(
348 struct xfs_log_item *lip,
351 struct xfs_rud_log_item *rudp = RUD_ITEM(lip);
354 * Drop the RUI reference regardless of whether the RUD has been
355 * aborted. Once the RUD transaction is constructed, it is the sole
356 * responsibility of the RUD to release the RUI (even if the RUI is
357 * aborted due to log I/O error).
359 xfs_rui_release(rudp->rud_ruip);
360 kmem_zone_free(xfs_rud_zone, rudp);
362 return (xfs_lsn_t)-1;
366 * The RUD dependency tracking op doesn't do squat. It can't because
367 * it doesn't know where the free extent is coming from. The dependency
368 * tracking has to be handled by the "enclosing" metadata object. For
369 * example, for inodes, the inode is locked throughout the extent freeing
370 * so the dependency should be recorded there.
373 xfs_rud_item_committing(
374 struct xfs_log_item *lip,
380 * This is the ops vector shared by all rud log items.
382 static const struct xfs_item_ops xfs_rud_item_ops = {
383 .iop_size = xfs_rud_item_size,
384 .iop_format = xfs_rud_item_format,
385 .iop_pin = xfs_rud_item_pin,
386 .iop_unpin = xfs_rud_item_unpin,
387 .iop_unlock = xfs_rud_item_unlock,
388 .iop_committed = xfs_rud_item_committed,
389 .iop_push = xfs_rud_item_push,
390 .iop_committing = xfs_rud_item_committing,
394 * Allocate and initialize an rud item with the given number of extents.
396 struct xfs_rud_log_item *
398 struct xfs_mount *mp,
399 struct xfs_rui_log_item *ruip)
402 struct xfs_rud_log_item *rudp;
404 rudp = kmem_zone_zalloc(xfs_rud_zone, KM_SLEEP);
405 xfs_log_item_init(mp, &rudp->rud_item, XFS_LI_RUD, &xfs_rud_item_ops);
406 rudp->rud_ruip = ruip;
407 rudp->rud_format.rud_rui_id = ruip->rui_format.rui_id;
413 * Process an rmap update intent item that was recovered from the log.
414 * We need to update the rmapbt.
418 struct xfs_mount *mp,
419 struct xfs_rui_log_item *ruip)
423 struct xfs_map_extent *rmap;
424 xfs_fsblock_t startblock_fsb;
426 struct xfs_rud_log_item *rudp;
427 enum xfs_rmap_intent_type type;
430 struct xfs_trans *tp;
431 struct xfs_btree_cur *rcur = NULL;
433 ASSERT(!test_bit(XFS_RUI_RECOVERED, &ruip->rui_flags));
436 * First check the validity of the extents described by the
437 * RUI. If any are bad, then assume that all are bad and
440 for (i = 0; i < ruip->rui_format.rui_nextents; i++) {
441 rmap = &ruip->rui_format.rui_extents[i];
442 startblock_fsb = XFS_BB_TO_FSB(mp,
443 XFS_FSB_TO_DADDR(mp, rmap->me_startblock));
444 switch (rmap->me_flags & XFS_RMAP_EXTENT_TYPE_MASK) {
445 case XFS_RMAP_EXTENT_MAP:
446 case XFS_RMAP_EXTENT_MAP_SHARED:
447 case XFS_RMAP_EXTENT_UNMAP:
448 case XFS_RMAP_EXTENT_UNMAP_SHARED:
449 case XFS_RMAP_EXTENT_CONVERT:
450 case XFS_RMAP_EXTENT_CONVERT_SHARED:
451 case XFS_RMAP_EXTENT_ALLOC:
452 case XFS_RMAP_EXTENT_FREE:
459 if (!op_ok || startblock_fsb == 0 ||
461 startblock_fsb >= mp->m_sb.sb_dblocks ||
462 rmap->me_len >= mp->m_sb.sb_agblocks ||
463 (rmap->me_flags & ~XFS_RMAP_EXTENT_FLAGS)) {
465 * This will pull the RUI from the AIL and
466 * free the memory associated with it.
468 set_bit(XFS_RUI_RECOVERED, &ruip->rui_flags);
469 xfs_rui_release(ruip);
474 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate,
475 mp->m_rmap_maxlevels, 0, XFS_TRANS_RESERVE, &tp);
478 rudp = xfs_trans_get_rud(tp, ruip);
480 for (i = 0; i < ruip->rui_format.rui_nextents; i++) {
481 rmap = &ruip->rui_format.rui_extents[i];
482 state = (rmap->me_flags & XFS_RMAP_EXTENT_UNWRITTEN) ?
483 XFS_EXT_UNWRITTEN : XFS_EXT_NORM;
484 whichfork = (rmap->me_flags & XFS_RMAP_EXTENT_ATTR_FORK) ?
485 XFS_ATTR_FORK : XFS_DATA_FORK;
486 switch (rmap->me_flags & XFS_RMAP_EXTENT_TYPE_MASK) {
487 case XFS_RMAP_EXTENT_MAP:
490 case XFS_RMAP_EXTENT_MAP_SHARED:
491 type = XFS_RMAP_MAP_SHARED;
493 case XFS_RMAP_EXTENT_UNMAP:
494 type = XFS_RMAP_UNMAP;
496 case XFS_RMAP_EXTENT_UNMAP_SHARED:
497 type = XFS_RMAP_UNMAP_SHARED;
499 case XFS_RMAP_EXTENT_CONVERT:
500 type = XFS_RMAP_CONVERT;
502 case XFS_RMAP_EXTENT_CONVERT_SHARED:
503 type = XFS_RMAP_CONVERT_SHARED;
505 case XFS_RMAP_EXTENT_ALLOC:
506 type = XFS_RMAP_ALLOC;
508 case XFS_RMAP_EXTENT_FREE:
509 type = XFS_RMAP_FREE;
512 error = -EFSCORRUPTED;
515 error = xfs_trans_log_finish_rmap_update(tp, rudp, type,
516 rmap->me_owner, whichfork,
517 rmap->me_startoff, rmap->me_startblock,
518 rmap->me_len, state, &rcur);
524 xfs_rmap_finish_one_cleanup(tp, rcur, error);
525 set_bit(XFS_RUI_RECOVERED, &ruip->rui_flags);
526 error = xfs_trans_commit(tp);
530 xfs_rmap_finish_one_cleanup(tp, rcur, error);
531 xfs_trans_cancel(tp);