blob: 5f3d33d16e6706b9db55cb3919c35feea29408ca [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Nathan Scott7b718762005-11-02 14:58:39 +11002 * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
Christoph Hellwige98c4142010-06-23 18:11:15 +10003 * Copyright (C) 2010 Red Hat, Inc.
Nathan Scott7b718762005-11-02 14:58:39 +11004 * All Rights Reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 *
Nathan Scott7b718762005-11-02 14:58:39 +11006 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License as
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 * published by the Free Software Foundation.
9 *
Nathan Scott7b718762005-11-02 14:58:39 +110010 * This program is distributed in the hope that it would be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
Linus Torvalds1da177e2005-04-16 15:20:36 -070014 *
Nathan Scott7b718762005-11-02 14:58:39 +110015 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Linus Torvalds1da177e2005-04-16 15:20:36 -070018 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include "xfs.h"
Nathan Scotta844f452005-11-02 14:38:42 +110020#include "xfs_fs.h"
Dave Chinner70a9883c2013-10-23 10:36:05 +110021#include "xfs_shared.h"
Dave Chinner239880e2013-10-23 10:50:10 +110022#include "xfs_format.h"
23#include "xfs_log_format.h"
24#include "xfs_trans_resv.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include "xfs_mount.h"
Nathan Scotta844f452005-11-02 14:38:42 +110026#include "xfs_inode.h"
Dave Chinnerefc27b52012-04-29 10:39:43 +000027#include "xfs_extent_busy.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include "xfs_quota.h"
Dave Chinner239880e2013-10-23 10:50:10 +110029#include "xfs_trans.h"
Nathan Scotta844f452005-11-02 14:38:42 +110030#include "xfs_trans_priv.h"
Dave Chinner239880e2013-10-23 10:50:10 +110031#include "xfs_log.h"
Dave Chinnered3b4d62010-05-21 12:07:08 +100032#include "xfs_trace.h"
Dave Chinnera4fbe6a2013-10-23 10:51:50 +110033#include "xfs_error.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
Nathan Scott8f794052006-03-14 13:32:41 +110035kmem_zone_t *xfs_trans_zone;
Christoph Hellwige98c4142010-06-23 18:11:15 +100036kmem_zone_t *xfs_log_item_desc_zone;
Linus Torvalds1da177e2005-04-16 15:20:36 -070037
Jeff Liu4f3b5782013-01-28 21:25:35 +080038/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070039 * Initialize the precomputed transaction reservation values
40 * in the mount structure.
41 */
42void
43xfs_trans_init(
Christoph Hellwig025101d2010-05-04 13:53:48 +000044 struct xfs_mount *mp)
Linus Torvalds1da177e2005-04-16 15:20:36 -070045{
Jie Liu3d3c8b52013-08-12 20:49:59 +100046 xfs_trans_resv_calc(mp, M_RES(mp));
Linus Torvalds1da177e2005-04-16 15:20:36 -070047}
48
49/*
Dave Chinnerb1c1b5b2010-03-23 10:11:05 +110050 * Free the transaction structure. If there is more clean up
51 * to do when the structure is freed, add it here.
52 */
53STATIC void
54xfs_trans_free(
Dave Chinnered3b4d62010-05-21 12:07:08 +100055 struct xfs_trans *tp)
Dave Chinnerb1c1b5b2010-03-23 10:11:05 +110056{
Dave Chinner4ecbfe62012-04-29 10:41:10 +000057 xfs_extent_busy_sort(&tp->t_busy);
58 xfs_extent_busy_clear(tp->t_mountp, &tp->t_busy, false);
Dave Chinnered3b4d62010-05-21 12:07:08 +100059
Dave Chinnerb1c1b5b2010-03-23 10:11:05 +110060 atomic_dec(&tp->t_mountp->m_active_trans);
Christoph Hellwig253f4912016-04-06 09:19:55 +100061 if (!(tp->t_flags & XFS_TRANS_NO_WRITECOUNT))
Jan Karad9457dc2012-06-12 16:20:39 +020062 sb_end_intwrite(tp->t_mountp->m_super);
Dave Chinnerb1c1b5b2010-03-23 10:11:05 +110063 xfs_trans_free_dqinfo(tp);
64 kmem_zone_free(xfs_trans_zone, tp);
65}
66
67/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 * This is called to create a new transaction which will share the
69 * permanent log reservation of the given transaction. The remaining
70 * unused block and rt extent reservations are also inherited. This
71 * implies that the original transaction is no longer allowed to allocate
72 * blocks. Locks and log items, however, are no inherited. They must
73 * be added to the new transaction explicitly.
74 */
Christoph Hellwig2e6db6c2015-06-04 13:47:29 +100075STATIC xfs_trans_t *
Linus Torvalds1da177e2005-04-16 15:20:36 -070076xfs_trans_dup(
77 xfs_trans_t *tp)
78{
79 xfs_trans_t *ntp;
80
81 ntp = kmem_zone_zalloc(xfs_trans_zone, KM_SLEEP);
82
83 /*
84 * Initialize the new transaction structure.
85 */
Dave Chinner2a3c0ac2013-08-12 20:49:28 +100086 ntp->t_magic = XFS_TRANS_HEADER_MAGIC;
Linus Torvalds1da177e2005-04-16 15:20:36 -070087 ntp->t_mountp = tp->t_mountp;
Christoph Hellwige98c4142010-06-23 18:11:15 +100088 INIT_LIST_HEAD(&ntp->t_items);
Dave Chinnered3b4d62010-05-21 12:07:08 +100089 INIT_LIST_HEAD(&ntp->t_busy);
Linus Torvalds1da177e2005-04-16 15:20:36 -070090
91 ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
Linus Torvalds1da177e2005-04-16 15:20:36 -070092 ASSERT(tp->t_ticket != NULL);
Nathan Scottcfcbbbd2005-11-02 15:12:04 +110093
Jan Karad9457dc2012-06-12 16:20:39 +020094 ntp->t_flags = XFS_TRANS_PERM_LOG_RES |
95 (tp->t_flags & XFS_TRANS_RESERVE) |
Christoph Hellwig253f4912016-04-06 09:19:55 +100096 (tp->t_flags & XFS_TRANS_NO_WRITECOUNT);
Jan Karad9457dc2012-06-12 16:20:39 +020097 /* We gave our writer reference to the new transaction */
Christoph Hellwig253f4912016-04-06 09:19:55 +100098 tp->t_flags |= XFS_TRANS_NO_WRITECOUNT;
Dave Chinnercc09c0d2008-11-17 17:37:10 +110099 ntp->t_ticket = xfs_log_ticket_get(tp->t_ticket);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100 ntp->t_blk_res = tp->t_blk_res - tp->t_blk_res_used;
101 tp->t_blk_res = tp->t_blk_res_used;
102 ntp->t_rtx_res = tp->t_rtx_res - tp->t_rtx_res_used;
103 tp->t_rtx_res = tp->t_rtx_res_used;
Nathan Scott59c1b082006-06-09 14:59:13 +1000104 ntp->t_pflags = tp->t_pflags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105
Christoph Hellwig7d095252009-06-08 15:33:32 +0200106 xfs_trans_dup_dqinfo(tp, ntp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107
108 atomic_inc(&tp->t_mountp->m_active_trans);
109 return ntp;
110}
111
112/*
113 * This is called to reserve free disk blocks and log space for the
114 * given transaction. This must be done before allocating any resources
115 * within the transaction.
116 *
117 * This will return ENOSPC if there are not enough blocks available.
118 * It will sleep waiting for available log space.
119 * The only valid value for the flags parameter is XFS_RES_LOG_PERM, which
120 * is used by long running transactions. If any one of the reservations
121 * fails then they will all be backed out.
122 *
123 * This does not do quota reservations. That typically is done by the
124 * caller afterwards.
125 */
Christoph Hellwig253f4912016-04-06 09:19:55 +1000126static int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127xfs_trans_reserve(
Jie Liu3d3c8b52013-08-12 20:49:59 +1000128 struct xfs_trans *tp,
129 struct xfs_trans_res *resp,
130 uint blocks,
131 uint rtextents)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132{
Nathan Scott59c1b082006-06-09 14:59:13 +1000133 int error = 0;
Dave Chinner0d485ad2015-02-23 21:22:03 +1100134 bool rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135
136 /* Mark this thread as being in a transaction */
Nathan Scott59c1b082006-06-09 14:59:13 +1000137 current_set_flags_nested(&tp->t_pflags, PF_FSTRANS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138
139 /*
140 * Attempt to reserve the needed disk blocks by decrementing
141 * the number needed from the number available. This will
142 * fail if the count would go below zero.
143 */
144 if (blocks > 0) {
Dave Chinner0d485ad2015-02-23 21:22:03 +1100145 error = xfs_mod_fdblocks(tp->t_mountp, -((int64_t)blocks), rsvd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 if (error != 0) {
Nathan Scott59c1b082006-06-09 14:59:13 +1000147 current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
Dave Chinner24513372014-06-25 14:58:08 +1000148 return -ENOSPC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 }
150 tp->t_blk_res += blocks;
151 }
152
153 /*
154 * Reserve the log space needed for this transaction.
155 */
Jie Liu3d3c8b52013-08-12 20:49:59 +1000156 if (resp->tr_logres > 0) {
Christoph Hellwig9006fb92012-02-20 02:31:31 +0000157 bool permanent = false;
158
Jie Liu3d3c8b52013-08-12 20:49:59 +1000159 ASSERT(tp->t_log_res == 0 ||
160 tp->t_log_res == resp->tr_logres);
161 ASSERT(tp->t_log_count == 0 ||
162 tp->t_log_count == resp->tr_logcount);
Christoph Hellwig9006fb92012-02-20 02:31:31 +0000163
Jie Liu3d3c8b52013-08-12 20:49:59 +1000164 if (resp->tr_logflags & XFS_TRANS_PERM_LOG_RES) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 tp->t_flags |= XFS_TRANS_PERM_LOG_RES;
Christoph Hellwig9006fb92012-02-20 02:31:31 +0000166 permanent = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 } else {
168 ASSERT(tp->t_ticket == NULL);
169 ASSERT(!(tp->t_flags & XFS_TRANS_PERM_LOG_RES));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170 }
171
Christoph Hellwig9006fb92012-02-20 02:31:31 +0000172 if (tp->t_ticket != NULL) {
Jie Liu3d3c8b52013-08-12 20:49:59 +1000173 ASSERT(resp->tr_logflags & XFS_TRANS_PERM_LOG_RES);
Christoph Hellwig9006fb92012-02-20 02:31:31 +0000174 error = xfs_log_regrant(tp->t_mountp, tp->t_ticket);
175 } else {
Jie Liu3d3c8b52013-08-12 20:49:59 +1000176 error = xfs_log_reserve(tp->t_mountp,
177 resp->tr_logres,
178 resp->tr_logcount,
179 &tp->t_ticket, XFS_TRANSACTION,
Christoph Hellwig710b1e22016-04-06 09:20:36 +1000180 permanent);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 }
Christoph Hellwig9006fb92012-02-20 02:31:31 +0000182
183 if (error)
184 goto undo_blocks;
185
Jie Liu3d3c8b52013-08-12 20:49:59 +1000186 tp->t_log_res = resp->tr_logres;
187 tp->t_log_count = resp->tr_logcount;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 }
189
190 /*
191 * Attempt to reserve the needed realtime extents by decrementing
192 * the number needed from the number available. This will
193 * fail if the count would go below zero.
194 */
195 if (rtextents > 0) {
Dave Chinnerbab98bb2015-02-23 21:22:54 +1100196 error = xfs_mod_frextents(tp->t_mountp, -((int64_t)rtextents));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 if (error) {
Dave Chinner24513372014-06-25 14:58:08 +1000198 error = -ENOSPC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 goto undo_log;
200 }
201 tp->t_rtx_res += rtextents;
202 }
203
204 return 0;
205
206 /*
207 * Error cases jump to one of these labels to undo any
208 * reservations which have already been performed.
209 */
210undo_log:
Jie Liu3d3c8b52013-08-12 20:49:59 +1000211 if (resp->tr_logres > 0) {
Christoph Hellwigf78c3902015-06-04 13:48:20 +1000212 xfs_log_done(tp->t_mountp, tp->t_ticket, NULL, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 tp->t_ticket = NULL;
214 tp->t_log_res = 0;
215 tp->t_flags &= ~XFS_TRANS_PERM_LOG_RES;
216 }
217
218undo_blocks:
219 if (blocks > 0) {
Dave Chinner0d485ad2015-02-23 21:22:03 +1100220 xfs_mod_fdblocks(tp->t_mountp, -((int64_t)blocks), rsvd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 tp->t_blk_res = 0;
222 }
223
Nathan Scott59c1b082006-06-09 14:59:13 +1000224 current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225
Nathan Scott59c1b082006-06-09 14:59:13 +1000226 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227}
228
Christoph Hellwig253f4912016-04-06 09:19:55 +1000229int
230xfs_trans_alloc(
231 struct xfs_mount *mp,
232 struct xfs_trans_res *resp,
233 uint blocks,
234 uint rtextents,
235 uint flags,
236 struct xfs_trans **tpp)
237{
238 struct xfs_trans *tp;
239 int error;
240
241 if (!(flags & XFS_TRANS_NO_WRITECOUNT))
242 sb_start_intwrite(mp->m_super);
243
244 WARN_ON(mp->m_super->s_writers.frozen == SB_FREEZE_COMPLETE);
245 atomic_inc(&mp->m_active_trans);
246
247 tp = kmem_zone_zalloc(xfs_trans_zone,
248 (flags & XFS_TRANS_NOFS) ? KM_NOFS : KM_SLEEP);
249 tp->t_magic = XFS_TRANS_HEADER_MAGIC;
250 tp->t_flags = flags;
251 tp->t_mountp = mp;
252 INIT_LIST_HEAD(&tp->t_items);
253 INIT_LIST_HEAD(&tp->t_busy);
254
255 error = xfs_trans_reserve(tp, resp, blocks, rtextents);
256 if (error) {
257 xfs_trans_cancel(tp);
258 return error;
259 }
260
261 *tpp = tp;
262 return 0;
263}
264
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 * Record the indicated change to the given field for application
267 * to the file system's superblock when the transaction commits.
268 * For now, just store the change in the transaction structure.
269 *
270 * Mark the transaction structure to indicate that the superblock
271 * needs to be updated before committing.
David Chinner92821e22007-05-24 15:26:31 +1000272 *
273 * Because we may not be keeping track of allocated/free inodes and
274 * used filesystem blocks in the superblock, we do not mark the
275 * superblock dirty in this transaction if we modify these fields.
276 * We still need to update the transaction deltas so that they get
277 * applied to the incore superblock, but we don't want them to
278 * cause the superblock to get locked and logged if these are the
279 * only fields in the superblock that the transaction modifies.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 */
281void
282xfs_trans_mod_sb(
283 xfs_trans_t *tp,
284 uint field,
David Chinner20f4ebf2007-02-10 18:36:10 +1100285 int64_t delta)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286{
David Chinner92821e22007-05-24 15:26:31 +1000287 uint32_t flags = (XFS_TRANS_DIRTY|XFS_TRANS_SB_DIRTY);
288 xfs_mount_t *mp = tp->t_mountp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289
290 switch (field) {
291 case XFS_TRANS_SB_ICOUNT:
292 tp->t_icount_delta += delta;
David Chinner92821e22007-05-24 15:26:31 +1000293 if (xfs_sb_version_haslazysbcount(&mp->m_sb))
294 flags &= ~XFS_TRANS_SB_DIRTY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 break;
296 case XFS_TRANS_SB_IFREE:
297 tp->t_ifree_delta += delta;
David Chinner92821e22007-05-24 15:26:31 +1000298 if (xfs_sb_version_haslazysbcount(&mp->m_sb))
299 flags &= ~XFS_TRANS_SB_DIRTY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 break;
301 case XFS_TRANS_SB_FDBLOCKS:
302 /*
303 * Track the number of blocks allocated in the
304 * transaction. Make sure it does not exceed the
305 * number reserved.
306 */
307 if (delta < 0) {
308 tp->t_blk_res_used += (uint)-delta;
309 ASSERT(tp->t_blk_res_used <= tp->t_blk_res);
310 }
311 tp->t_fdblocks_delta += delta;
David Chinner92821e22007-05-24 15:26:31 +1000312 if (xfs_sb_version_haslazysbcount(&mp->m_sb))
313 flags &= ~XFS_TRANS_SB_DIRTY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 break;
315 case XFS_TRANS_SB_RES_FDBLOCKS:
316 /*
317 * The allocation has already been applied to the
318 * in-core superblock's counter. This should only
319 * be applied to the on-disk superblock.
320 */
321 ASSERT(delta < 0);
322 tp->t_res_fdblocks_delta += delta;
David Chinner92821e22007-05-24 15:26:31 +1000323 if (xfs_sb_version_haslazysbcount(&mp->m_sb))
324 flags &= ~XFS_TRANS_SB_DIRTY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 break;
326 case XFS_TRANS_SB_FREXTENTS:
327 /*
328 * Track the number of blocks allocated in the
329 * transaction. Make sure it does not exceed the
330 * number reserved.
331 */
332 if (delta < 0) {
333 tp->t_rtx_res_used += (uint)-delta;
334 ASSERT(tp->t_rtx_res_used <= tp->t_rtx_res);
335 }
336 tp->t_frextents_delta += delta;
337 break;
338 case XFS_TRANS_SB_RES_FREXTENTS:
339 /*
340 * The allocation has already been applied to the
Nathan Scottc41564b2006-03-29 08:55:14 +1000341 * in-core superblock's counter. This should only
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 * be applied to the on-disk superblock.
343 */
344 ASSERT(delta < 0);
345 tp->t_res_frextents_delta += delta;
346 break;
347 case XFS_TRANS_SB_DBLOCKS:
348 ASSERT(delta > 0);
349 tp->t_dblocks_delta += delta;
350 break;
351 case XFS_TRANS_SB_AGCOUNT:
352 ASSERT(delta > 0);
353 tp->t_agcount_delta += delta;
354 break;
355 case XFS_TRANS_SB_IMAXPCT:
356 tp->t_imaxpct_delta += delta;
357 break;
358 case XFS_TRANS_SB_REXTSIZE:
359 tp->t_rextsize_delta += delta;
360 break;
361 case XFS_TRANS_SB_RBMBLOCKS:
362 tp->t_rbmblocks_delta += delta;
363 break;
364 case XFS_TRANS_SB_RBLOCKS:
365 tp->t_rblocks_delta += delta;
366 break;
367 case XFS_TRANS_SB_REXTENTS:
368 tp->t_rextents_delta += delta;
369 break;
370 case XFS_TRANS_SB_REXTSLOG:
371 tp->t_rextslog_delta += delta;
372 break;
373 default:
374 ASSERT(0);
375 return;
376 }
377
David Chinner210c6f12007-05-24 15:26:51 +1000378 tp->t_flags |= flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379}
380
381/*
382 * xfs_trans_apply_sb_deltas() is called from the commit code
383 * to bring the superblock buffer into the current transaction
384 * and modify it as requested by earlier calls to xfs_trans_mod_sb().
385 *
386 * For now we just look at each field allowed to change and change
387 * it if necessary.
388 */
389STATIC void
390xfs_trans_apply_sb_deltas(
391 xfs_trans_t *tp)
392{
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000393 xfs_dsb_t *sbp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 xfs_buf_t *bp;
395 int whole = 0;
396
397 bp = xfs_trans_getsb(tp, tp->t_mountp, 0);
398 sbp = XFS_BUF_TO_SBP(bp);
399
400 /*
401 * Check that superblock mods match the mods made to AGF counters.
402 */
403 ASSERT((tp->t_fdblocks_delta + tp->t_res_fdblocks_delta) ==
404 (tp->t_ag_freeblks_delta + tp->t_ag_flist_delta +
405 tp->t_ag_btree_delta));
406
David Chinner92821e22007-05-24 15:26:31 +1000407 /*
408 * Only update the superblock counters if we are logging them
409 */
410 if (!xfs_sb_version_haslazysbcount(&(tp->t_mountp->m_sb))) {
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000411 if (tp->t_icount_delta)
Marcin Slusarz413d57c2008-02-13 15:03:29 -0800412 be64_add_cpu(&sbp->sb_icount, tp->t_icount_delta);
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000413 if (tp->t_ifree_delta)
Marcin Slusarz413d57c2008-02-13 15:03:29 -0800414 be64_add_cpu(&sbp->sb_ifree, tp->t_ifree_delta);
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000415 if (tp->t_fdblocks_delta)
Marcin Slusarz413d57c2008-02-13 15:03:29 -0800416 be64_add_cpu(&sbp->sb_fdblocks, tp->t_fdblocks_delta);
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000417 if (tp->t_res_fdblocks_delta)
Marcin Slusarz413d57c2008-02-13 15:03:29 -0800418 be64_add_cpu(&sbp->sb_fdblocks, tp->t_res_fdblocks_delta);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 }
420
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000421 if (tp->t_frextents_delta)
Marcin Slusarz413d57c2008-02-13 15:03:29 -0800422 be64_add_cpu(&sbp->sb_frextents, tp->t_frextents_delta);
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000423 if (tp->t_res_frextents_delta)
Marcin Slusarz413d57c2008-02-13 15:03:29 -0800424 be64_add_cpu(&sbp->sb_frextents, tp->t_res_frextents_delta);
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000425
426 if (tp->t_dblocks_delta) {
Marcin Slusarz413d57c2008-02-13 15:03:29 -0800427 be64_add_cpu(&sbp->sb_dblocks, tp->t_dblocks_delta);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 whole = 1;
429 }
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000430 if (tp->t_agcount_delta) {
Marcin Slusarz413d57c2008-02-13 15:03:29 -0800431 be32_add_cpu(&sbp->sb_agcount, tp->t_agcount_delta);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 whole = 1;
433 }
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000434 if (tp->t_imaxpct_delta) {
435 sbp->sb_imax_pct += tp->t_imaxpct_delta;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 whole = 1;
437 }
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000438 if (tp->t_rextsize_delta) {
Marcin Slusarz413d57c2008-02-13 15:03:29 -0800439 be32_add_cpu(&sbp->sb_rextsize, tp->t_rextsize_delta);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 whole = 1;
441 }
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000442 if (tp->t_rbmblocks_delta) {
Marcin Slusarz413d57c2008-02-13 15:03:29 -0800443 be32_add_cpu(&sbp->sb_rbmblocks, tp->t_rbmblocks_delta);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 whole = 1;
445 }
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000446 if (tp->t_rblocks_delta) {
Marcin Slusarz413d57c2008-02-13 15:03:29 -0800447 be64_add_cpu(&sbp->sb_rblocks, tp->t_rblocks_delta);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 whole = 1;
449 }
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000450 if (tp->t_rextents_delta) {
Marcin Slusarz413d57c2008-02-13 15:03:29 -0800451 be64_add_cpu(&sbp->sb_rextents, tp->t_rextents_delta);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 whole = 1;
453 }
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000454 if (tp->t_rextslog_delta) {
455 sbp->sb_rextslog += tp->t_rextslog_delta;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 whole = 1;
457 }
458
Dave Chinner3443a3b2015-01-22 09:30:23 +1100459 xfs_trans_buf_set_type(tp, bp, XFS_BLFT_SB_BUF);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 if (whole)
461 /*
Nathan Scottc41564b2006-03-29 08:55:14 +1000462 * Log the whole thing, the fields are noncontiguous.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 */
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000464 xfs_trans_log_buf(tp, bp, 0, sizeof(xfs_dsb_t) - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 else
466 /*
467 * Since all the modifiable fields are contiguous, we
468 * can get away with this.
469 */
Christoph Hellwig2bdf7cd2007-08-28 13:58:06 +1000470 xfs_trans_log_buf(tp, bp, offsetof(xfs_dsb_t, sb_icount),
471 offsetof(xfs_dsb_t, sb_frextents) +
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 sizeof(sbp->sb_frextents) - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473}
474
Dave Chinner0bd5dded2015-02-23 21:24:11 +1100475STATIC int
476xfs_sb_mod8(
477 uint8_t *field,
478 int8_t delta)
479{
480 int8_t counter = *field;
481
482 counter += delta;
483 if (counter < 0) {
484 ASSERT(0);
485 return -EINVAL;
486 }
487 *field = counter;
488 return 0;
489}
490
491STATIC int
492xfs_sb_mod32(
493 uint32_t *field,
494 int32_t delta)
495{
496 int32_t counter = *field;
497
498 counter += delta;
499 if (counter < 0) {
500 ASSERT(0);
501 return -EINVAL;
502 }
503 *field = counter;
504 return 0;
505}
506
507STATIC int
508xfs_sb_mod64(
509 uint64_t *field,
510 int64_t delta)
511{
512 int64_t counter = *field;
513
514 counter += delta;
515 if (counter < 0) {
516 ASSERT(0);
517 return -EINVAL;
518 }
519 *field = counter;
520 return 0;
521}
522
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523/*
David Chinner45c34142007-06-18 16:49:44 +1000524 * xfs_trans_unreserve_and_mod_sb() is called to release unused reservations
525 * and apply superblock counter changes to the in-core superblock. The
526 * t_res_fdblocks_delta and t_res_frextents_delta fields are explicitly NOT
527 * applied to the in-core superblock. The idea is that that has already been
528 * done.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 *
David Chinner45c34142007-06-18 16:49:44 +1000530 * If we are not logging superblock counters, then the inode allocated/free and
531 * used block counts are not updated in the on disk superblock. In this case,
532 * XFS_TRANS_SB_DIRTY will not be set when the transaction is updated but we
533 * still need to update the incore superblock with the changes.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 */
Dave Chinner71e330b2010-05-21 14:37:18 +1000535void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536xfs_trans_unreserve_and_mod_sb(
Dave Chinner0bd5dded2015-02-23 21:24:11 +1100537 struct xfs_trans *tp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538{
Dave Chinner0bd5dded2015-02-23 21:24:11 +1100539 struct xfs_mount *mp = tp->t_mountp;
540 bool rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0;
541 int64_t blkdelta = 0;
542 int64_t rtxdelta = 0;
543 int64_t idelta = 0;
544 int64_t ifreedelta = 0;
545 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546
Christoph Hellwig1b040712010-09-30 02:25:56 +0000547 /* calculate deltas */
David Chinner45c34142007-06-18 16:49:44 +1000548 if (tp->t_blk_res > 0)
549 blkdelta = tp->t_blk_res;
David Chinner45c34142007-06-18 16:49:44 +1000550 if ((tp->t_fdblocks_delta != 0) &&
551 (xfs_sb_version_haslazysbcount(&mp->m_sb) ||
552 (tp->t_flags & XFS_TRANS_SB_DIRTY)))
553 blkdelta += tp->t_fdblocks_delta;
554
David Chinner45c34142007-06-18 16:49:44 +1000555 if (tp->t_rtx_res > 0)
556 rtxdelta = tp->t_rtx_res;
David Chinner45c34142007-06-18 16:49:44 +1000557 if ((tp->t_frextents_delta != 0) &&
558 (tp->t_flags & XFS_TRANS_SB_DIRTY))
559 rtxdelta += tp->t_frextents_delta;
560
Christoph Hellwig1b040712010-09-30 02:25:56 +0000561 if (xfs_sb_version_haslazysbcount(&mp->m_sb) ||
562 (tp->t_flags & XFS_TRANS_SB_DIRTY)) {
563 idelta = tp->t_icount_delta;
564 ifreedelta = tp->t_ifree_delta;
565 }
566
567 /* apply the per-cpu counters */
568 if (blkdelta) {
Dave Chinner0d485ad2015-02-23 21:22:03 +1100569 error = xfs_mod_fdblocks(mp, blkdelta, rsvd);
Christoph Hellwig1b040712010-09-30 02:25:56 +0000570 if (error)
571 goto out;
572 }
573
574 if (idelta) {
Dave Chinner501ab322015-02-23 21:19:28 +1100575 error = xfs_mod_icount(mp, idelta);
Christoph Hellwig1b040712010-09-30 02:25:56 +0000576 if (error)
577 goto out_undo_fdblocks;
578 }
579
580 if (ifreedelta) {
Dave Chinnere88b64e2015-02-23 21:19:53 +1100581 error = xfs_mod_ifree(mp, ifreedelta);
Christoph Hellwig1b040712010-09-30 02:25:56 +0000582 if (error)
583 goto out_undo_icount;
584 }
585
Dave Chinner0bd5dded2015-02-23 21:24:11 +1100586 if (rtxdelta == 0 && !(tp->t_flags & XFS_TRANS_SB_DIRTY))
587 return;
588
Christoph Hellwig1b040712010-09-30 02:25:56 +0000589 /* apply remaining deltas */
Dave Chinner0bd5dded2015-02-23 21:24:11 +1100590 spin_lock(&mp->m_sb_lock);
Dave Chinnerbab98bb2015-02-23 21:22:54 +1100591 if (rtxdelta) {
Dave Chinner0bd5dded2015-02-23 21:24:11 +1100592 error = xfs_sb_mod64(&mp->m_sb.sb_frextents, rtxdelta);
Dave Chinnerbab98bb2015-02-23 21:22:54 +1100593 if (error)
594 goto out_undo_ifree;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 }
596
Dave Chinner0bd5dded2015-02-23 21:24:11 +1100597 if (tp->t_dblocks_delta != 0) {
598 error = xfs_sb_mod64(&mp->m_sb.sb_dblocks, tp->t_dblocks_delta);
Christoph Hellwig1b040712010-09-30 02:25:56 +0000599 if (error)
Dave Chinnerbab98bb2015-02-23 21:22:54 +1100600 goto out_undo_frextents;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 }
Dave Chinner0bd5dded2015-02-23 21:24:11 +1100602 if (tp->t_agcount_delta != 0) {
603 error = xfs_sb_mod32(&mp->m_sb.sb_agcount, tp->t_agcount_delta);
604 if (error)
605 goto out_undo_dblocks;
606 }
607 if (tp->t_imaxpct_delta != 0) {
608 error = xfs_sb_mod8(&mp->m_sb.sb_imax_pct, tp->t_imaxpct_delta);
609 if (error)
610 goto out_undo_agcount;
611 }
612 if (tp->t_rextsize_delta != 0) {
613 error = xfs_sb_mod32(&mp->m_sb.sb_rextsize,
614 tp->t_rextsize_delta);
615 if (error)
616 goto out_undo_imaxpct;
617 }
618 if (tp->t_rbmblocks_delta != 0) {
619 error = xfs_sb_mod32(&mp->m_sb.sb_rbmblocks,
620 tp->t_rbmblocks_delta);
621 if (error)
622 goto out_undo_rextsize;
623 }
624 if (tp->t_rblocks_delta != 0) {
625 error = xfs_sb_mod64(&mp->m_sb.sb_rblocks, tp->t_rblocks_delta);
626 if (error)
627 goto out_undo_rbmblocks;
628 }
629 if (tp->t_rextents_delta != 0) {
630 error = xfs_sb_mod64(&mp->m_sb.sb_rextents,
631 tp->t_rextents_delta);
632 if (error)
633 goto out_undo_rblocks;
634 }
635 if (tp->t_rextslog_delta != 0) {
636 error = xfs_sb_mod8(&mp->m_sb.sb_rextslog,
637 tp->t_rextslog_delta);
638 if (error)
639 goto out_undo_rextents;
640 }
641 spin_unlock(&mp->m_sb_lock);
Christoph Hellwig1b040712010-09-30 02:25:56 +0000642 return;
643
Dave Chinner0bd5dded2015-02-23 21:24:11 +1100644out_undo_rextents:
645 if (tp->t_rextents_delta)
646 xfs_sb_mod64(&mp->m_sb.sb_rextents, -tp->t_rextents_delta);
647out_undo_rblocks:
648 if (tp->t_rblocks_delta)
649 xfs_sb_mod64(&mp->m_sb.sb_rblocks, -tp->t_rblocks_delta);
650out_undo_rbmblocks:
651 if (tp->t_rbmblocks_delta)
652 xfs_sb_mod32(&mp->m_sb.sb_rbmblocks, -tp->t_rbmblocks_delta);
653out_undo_rextsize:
654 if (tp->t_rextsize_delta)
655 xfs_sb_mod32(&mp->m_sb.sb_rextsize, -tp->t_rextsize_delta);
656out_undo_imaxpct:
657 if (tp->t_rextsize_delta)
658 xfs_sb_mod8(&mp->m_sb.sb_imax_pct, -tp->t_imaxpct_delta);
659out_undo_agcount:
660 if (tp->t_agcount_delta)
661 xfs_sb_mod32(&mp->m_sb.sb_agcount, -tp->t_agcount_delta);
662out_undo_dblocks:
663 if (tp->t_dblocks_delta)
664 xfs_sb_mod64(&mp->m_sb.sb_dblocks, -tp->t_dblocks_delta);
Dave Chinnerbab98bb2015-02-23 21:22:54 +1100665out_undo_frextents:
666 if (rtxdelta)
Dave Chinner0bd5dded2015-02-23 21:24:11 +1100667 xfs_sb_mod64(&mp->m_sb.sb_frextents, -rtxdelta);
Dave Chinnerbab98bb2015-02-23 21:22:54 +1100668out_undo_ifree:
Dave Chinner0bd5dded2015-02-23 21:24:11 +1100669 spin_unlock(&mp->m_sb_lock);
Christoph Hellwig1b040712010-09-30 02:25:56 +0000670 if (ifreedelta)
Dave Chinnere88b64e2015-02-23 21:19:53 +1100671 xfs_mod_ifree(mp, -ifreedelta);
Christoph Hellwig1b040712010-09-30 02:25:56 +0000672out_undo_icount:
673 if (idelta)
Dave Chinner501ab322015-02-23 21:19:28 +1100674 xfs_mod_icount(mp, -idelta);
Christoph Hellwig1b040712010-09-30 02:25:56 +0000675out_undo_fdblocks:
676 if (blkdelta)
Dave Chinner0d485ad2015-02-23 21:22:03 +1100677 xfs_mod_fdblocks(mp, -blkdelta, rsvd);
Christoph Hellwig1b040712010-09-30 02:25:56 +0000678out:
Jesper Juhl1884bd82010-12-25 20:14:53 +0000679 ASSERT(error == 0);
Christoph Hellwig1b040712010-09-30 02:25:56 +0000680 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681}
682
Dave Chinner09243782010-03-08 11:28:28 +1100683/*
Christoph Hellwige98c4142010-06-23 18:11:15 +1000684 * Add the given log item to the transaction's list of log items.
685 *
686 * The log item will now point to its new descriptor with its li_desc field.
687 */
688void
689xfs_trans_add_item(
690 struct xfs_trans *tp,
691 struct xfs_log_item *lip)
692{
693 struct xfs_log_item_desc *lidp;
694
Jesper Juhlf65020a2012-02-13 20:51:05 +0000695 ASSERT(lip->li_mountp == tp->t_mountp);
696 ASSERT(lip->li_ailp == tp->t_mountp->m_ail);
Christoph Hellwige98c4142010-06-23 18:11:15 +1000697
Dave Chinner43869702010-07-20 17:53:44 +1000698 lidp = kmem_zone_zalloc(xfs_log_item_desc_zone, KM_SLEEP | KM_NOFS);
Christoph Hellwige98c4142010-06-23 18:11:15 +1000699
700 lidp->lid_item = lip;
701 lidp->lid_flags = 0;
Christoph Hellwige98c4142010-06-23 18:11:15 +1000702 list_add_tail(&lidp->lid_trans, &tp->t_items);
703
704 lip->li_desc = lidp;
705}
706
707STATIC void
708xfs_trans_free_item_desc(
709 struct xfs_log_item_desc *lidp)
710{
711 list_del_init(&lidp->lid_trans);
712 kmem_zone_free(xfs_log_item_desc_zone, lidp);
713}
714
715/*
716 * Unlink and free the given descriptor.
717 */
718void
719xfs_trans_del_item(
720 struct xfs_log_item *lip)
721{
722 xfs_trans_free_item_desc(lip->li_desc);
723 lip->li_desc = NULL;
724}
725
726/*
727 * Unlock all of the items of a transaction and free all the descriptors
728 * of that transaction.
729 */
Dave Chinnerd17c7012010-08-24 11:42:52 +1000730void
Christoph Hellwige98c4142010-06-23 18:11:15 +1000731xfs_trans_free_items(
732 struct xfs_trans *tp,
733 xfs_lsn_t commit_lsn,
Christoph Hellwigeacb24e2015-06-04 13:47:43 +1000734 bool abort)
Christoph Hellwige98c4142010-06-23 18:11:15 +1000735{
736 struct xfs_log_item_desc *lidp, *next;
737
738 list_for_each_entry_safe(lidp, next, &tp->t_items, lid_trans) {
739 struct xfs_log_item *lip = lidp->lid_item;
740
741 lip->li_desc = NULL;
742
743 if (commit_lsn != NULLCOMMITLSN)
Dave Chinner904c17e2013-08-28 21:12:03 +1000744 lip->li_ops->iop_committing(lip, commit_lsn);
Christoph Hellwigeacb24e2015-06-04 13:47:43 +1000745 if (abort)
Christoph Hellwige98c4142010-06-23 18:11:15 +1000746 lip->li_flags |= XFS_LI_ABORTED;
Dave Chinner904c17e2013-08-28 21:12:03 +1000747 lip->li_ops->iop_unlock(lip);
Christoph Hellwige98c4142010-06-23 18:11:15 +1000748
749 xfs_trans_free_item_desc(lidp);
750 }
751}
752
Dave Chinner0e57f6a2010-12-20 12:02:19 +1100753static inline void
754xfs_log_item_batch_insert(
755 struct xfs_ail *ailp,
Dave Chinner1d8c95a2011-07-18 03:40:16 +0000756 struct xfs_ail_cursor *cur,
Dave Chinner0e57f6a2010-12-20 12:02:19 +1100757 struct xfs_log_item **log_items,
758 int nr_items,
759 xfs_lsn_t commit_lsn)
760{
761 int i;
762
763 spin_lock(&ailp->xa_lock);
764 /* xfs_trans_ail_update_bulk drops ailp->xa_lock */
Dave Chinner1d8c95a2011-07-18 03:40:16 +0000765 xfs_trans_ail_update_bulk(ailp, cur, log_items, nr_items, commit_lsn);
Dave Chinner0e57f6a2010-12-20 12:02:19 +1100766
Dave Chinner904c17e2013-08-28 21:12:03 +1000767 for (i = 0; i < nr_items; i++) {
768 struct xfs_log_item *lip = log_items[i];
769
770 lip->li_ops->iop_unpin(lip, 0);
771 }
Dave Chinner0e57f6a2010-12-20 12:02:19 +1100772}
773
774/*
775 * Bulk operation version of xfs_trans_committed that takes a log vector of
776 * items to insert into the AIL. This uses bulk AIL insertion techniques to
777 * minimise lock traffic.
Dave Chinnere34a3142011-01-27 12:13:35 +1100778 *
779 * If we are called with the aborted flag set, it is because a log write during
780 * a CIL checkpoint commit has failed. In this case, all the items in the
Dave Chinner904c17e2013-08-28 21:12:03 +1000781 * checkpoint have already gone through iop_commited and iop_unlock, which
Dave Chinnere34a3142011-01-27 12:13:35 +1100782 * means that checkpoint commit abort handling is treated exactly the same
783 * as an iclog write error even though we haven't started any IO yet. Hence in
Dave Chinner904c17e2013-08-28 21:12:03 +1000784 * this case all we need to do is iop_committed processing, followed by an
785 * iop_unpin(aborted) call.
Dave Chinner1d8c95a2011-07-18 03:40:16 +0000786 *
787 * The AIL cursor is used to optimise the insert process. If commit_lsn is not
788 * at the end of the AIL, the insert cursor avoids the need to walk
789 * the AIL to find the insertion point on every xfs_log_item_batch_insert()
790 * call. This saves a lot of needless list walking and is a net win, even
791 * though it slightly increases that amount of AIL lock traffic to set it up
792 * and tear it down.
Dave Chinner0e57f6a2010-12-20 12:02:19 +1100793 */
794void
795xfs_trans_committed_bulk(
796 struct xfs_ail *ailp,
797 struct xfs_log_vec *log_vector,
798 xfs_lsn_t commit_lsn,
799 int aborted)
800{
801#define LOG_ITEM_BATCH_SIZE 32
802 struct xfs_log_item *log_items[LOG_ITEM_BATCH_SIZE];
803 struct xfs_log_vec *lv;
Dave Chinner1d8c95a2011-07-18 03:40:16 +0000804 struct xfs_ail_cursor cur;
Dave Chinner0e57f6a2010-12-20 12:02:19 +1100805 int i = 0;
806
Dave Chinner1d8c95a2011-07-18 03:40:16 +0000807 spin_lock(&ailp->xa_lock);
808 xfs_trans_ail_cursor_last(ailp, &cur, commit_lsn);
809 spin_unlock(&ailp->xa_lock);
810
Dave Chinner0e57f6a2010-12-20 12:02:19 +1100811 /* unpin all the log items */
812 for (lv = log_vector; lv; lv = lv->lv_next ) {
813 struct xfs_log_item *lip = lv->lv_item;
814 xfs_lsn_t item_lsn;
815
816 if (aborted)
817 lip->li_flags |= XFS_LI_ABORTED;
Dave Chinner904c17e2013-08-28 21:12:03 +1000818 item_lsn = lip->li_ops->iop_committed(lip, commit_lsn);
Dave Chinner0e57f6a2010-12-20 12:02:19 +1100819
Dave Chinner1316d4d2011-07-04 05:27:36 +0000820 /* item_lsn of -1 means the item needs no further processing */
Dave Chinner0e57f6a2010-12-20 12:02:19 +1100821 if (XFS_LSN_CMP(item_lsn, (xfs_lsn_t)-1) == 0)
822 continue;
823
Dave Chinnere34a3142011-01-27 12:13:35 +1100824 /*
825 * if we are aborting the operation, no point in inserting the
826 * object into the AIL as we are in a shutdown situation.
827 */
828 if (aborted) {
829 ASSERT(XFS_FORCED_SHUTDOWN(ailp->xa_mount));
Dave Chinner904c17e2013-08-28 21:12:03 +1000830 lip->li_ops->iop_unpin(lip, 1);
Dave Chinnere34a3142011-01-27 12:13:35 +1100831 continue;
832 }
833
Dave Chinner0e57f6a2010-12-20 12:02:19 +1100834 if (item_lsn != commit_lsn) {
835
836 /*
837 * Not a bulk update option due to unusual item_lsn.
838 * Push into AIL immediately, rechecking the lsn once
Dave Chinner1d8c95a2011-07-18 03:40:16 +0000839 * we have the ail lock. Then unpin the item. This does
840 * not affect the AIL cursor the bulk insert path is
841 * using.
Dave Chinner0e57f6a2010-12-20 12:02:19 +1100842 */
843 spin_lock(&ailp->xa_lock);
844 if (XFS_LSN_CMP(item_lsn, lip->li_lsn) > 0)
845 xfs_trans_ail_update(ailp, lip, item_lsn);
846 else
847 spin_unlock(&ailp->xa_lock);
Dave Chinner904c17e2013-08-28 21:12:03 +1000848 lip->li_ops->iop_unpin(lip, 0);
Dave Chinner0e57f6a2010-12-20 12:02:19 +1100849 continue;
850 }
851
852 /* Item is a candidate for bulk AIL insert. */
853 log_items[i++] = lv->lv_item;
854 if (i >= LOG_ITEM_BATCH_SIZE) {
Dave Chinner1d8c95a2011-07-18 03:40:16 +0000855 xfs_log_item_batch_insert(ailp, &cur, log_items,
Dave Chinner0e57f6a2010-12-20 12:02:19 +1100856 LOG_ITEM_BATCH_SIZE, commit_lsn);
857 i = 0;
858 }
859 }
860
861 /* make sure we insert the remainder! */
862 if (i)
Dave Chinner1d8c95a2011-07-18 03:40:16 +0000863 xfs_log_item_batch_insert(ailp, &cur, log_items, i, commit_lsn);
864
865 spin_lock(&ailp->xa_lock);
Eric Sandeene4a1e292014-04-14 19:06:05 +1000866 xfs_trans_ail_cursor_done(&cur);
Dave Chinner1d8c95a2011-07-18 03:40:16 +0000867 spin_unlock(&ailp->xa_lock);
Dave Chinner0e57f6a2010-12-20 12:02:19 +1100868}
869
Dave Chinnerb1c1b5b2010-03-23 10:11:05 +1100870/*
Christoph Hellwigb1037052011-09-19 14:55:51 +0000871 * Commit the given transaction to the log.
Dave Chinner09243782010-03-08 11:28:28 +1100872 *
873 * XFS disk error handling mechanism is not based on a typical
874 * transaction abort mechanism. Logically after the filesystem
875 * gets marked 'SHUTDOWN', we can't let any new transactions
876 * be durable - ie. committed to disk - because some metadata might
877 * be inconsistent. In such cases, this returns an error, and the
878 * caller may assume that all locked objects joined to the transaction
879 * have already been unlocked as if the commit had succeeded.
880 * Do not reference the transaction structure after this call.
881 */
Christoph Hellwig70393312015-06-04 13:48:08 +1000882static int
883__xfs_trans_commit(
Christoph Hellwiga3ccd2c2010-03-15 12:52:49 +1100884 struct xfs_trans *tp,
Christoph Hellwig70393312015-06-04 13:48:08 +1000885 bool regrant)
Dave Chinner09243782010-03-08 11:28:28 +1100886{
Christoph Hellwiga3ccd2c2010-03-15 12:52:49 +1100887 struct xfs_mount *mp = tp->t_mountp;
Dave Chinner09243782010-03-08 11:28:28 +1100888 xfs_lsn_t commit_lsn = -1;
Christoph Hellwiga3ccd2c2010-03-15 12:52:49 +1100889 int error = 0;
Dave Chinner09243782010-03-08 11:28:28 +1100890 int sync = tp->t_flags & XFS_TRANS_SYNC;
Dave Chinner09243782010-03-08 11:28:28 +1100891
892 /*
Dave Chinner09243782010-03-08 11:28:28 +1100893 * If there is nothing to be logged by the transaction,
894 * then unlock all of the items associated with the
895 * transaction and free the transaction structure.
896 * Also make sure to return any reserved blocks to
897 * the free pool.
898 */
Christoph Hellwiga3ccd2c2010-03-15 12:52:49 +1100899 if (!(tp->t_flags & XFS_TRANS_DIRTY))
900 goto out_unreserve;
901
902 if (XFS_FORCED_SHUTDOWN(mp)) {
Dave Chinner24513372014-06-25 14:58:08 +1000903 error = -EIO;
Christoph Hellwiga3ccd2c2010-03-15 12:52:49 +1100904 goto out_unreserve;
Dave Chinner09243782010-03-08 11:28:28 +1100905 }
Christoph Hellwiga3ccd2c2010-03-15 12:52:49 +1100906
Dave Chinner09243782010-03-08 11:28:28 +1100907 ASSERT(tp->t_ticket != NULL);
908
909 /*
910 * If we need to update the superblock, then do it now.
911 */
912 if (tp->t_flags & XFS_TRANS_SB_DIRTY)
913 xfs_trans_apply_sb_deltas(tp);
914 xfs_trans_apply_dquot_deltas(tp);
915
Christoph Hellwig70393312015-06-04 13:48:08 +1000916 xfs_log_commit_cil(mp, tp, &commit_lsn, regrant);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917
Christoph Hellwig0244b962011-12-06 21:58:08 +0000918 current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
919 xfs_trans_free(tp);
920
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921 /*
922 * If the transaction needs to be synchronous, then force the
923 * log out now and wait for it.
924 */
925 if (sync) {
Jie Liuc6f97262014-02-07 15:26:07 +1100926 error = _xfs_log_force_lsn(mp, commit_lsn, XFS_LOG_SYNC, NULL);
Bill O'Donnellff6d6af2015-10-12 18:21:22 +1100927 XFS_STATS_INC(mp, xs_trans_sync);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928 } else {
Bill O'Donnellff6d6af2015-10-12 18:21:22 +1100929 XFS_STATS_INC(mp, xs_trans_async);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930 }
931
Christoph Hellwiga3ccd2c2010-03-15 12:52:49 +1100932 return error;
933
934out_unreserve:
935 xfs_trans_unreserve_and_mod_sb(tp);
936
937 /*
938 * It is indeed possible for the transaction to be not dirty but
939 * the dqinfo portion to be. All that means is that we have some
940 * (non-persistent) quota reservations that need to be unreserved.
941 */
942 xfs_trans_unreserve_and_mod_dquots(tp);
943 if (tp->t_ticket) {
Christoph Hellwigf78c3902015-06-04 13:48:20 +1000944 commit_lsn = xfs_log_done(mp, tp->t_ticket, NULL, regrant);
Christoph Hellwiga3ccd2c2010-03-15 12:52:49 +1100945 if (commit_lsn == -1 && !error)
Dave Chinner24513372014-06-25 14:58:08 +1000946 error = -EIO;
Christoph Hellwiga3ccd2c2010-03-15 12:52:49 +1100947 }
948 current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
Christoph Hellwigeacb24e2015-06-04 13:47:43 +1000949 xfs_trans_free_items(tp, NULLCOMMITLSN, !!error);
Christoph Hellwiga3ccd2c2010-03-15 12:52:49 +1100950 xfs_trans_free(tp);
951
Bill O'Donnellff6d6af2015-10-12 18:21:22 +1100952 XFS_STATS_INC(mp, xs_trans_empty);
Christoph Hellwiga3ccd2c2010-03-15 12:52:49 +1100953 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954}
955
Christoph Hellwig70393312015-06-04 13:48:08 +1000956int
957xfs_trans_commit(
958 struct xfs_trans *tp)
959{
960 return __xfs_trans_commit(tp, false);
961}
962
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964 * Unlock all of the transaction's items and free the transaction.
965 * The transaction must not have modified any of its items, because
966 * there is no way to restore them to their previous state.
967 *
968 * If the transaction has made a log reservation, make sure to release
969 * it as well.
970 */
971void
972xfs_trans_cancel(
Christoph Hellwig4906e212015-06-04 13:47:56 +1000973 struct xfs_trans *tp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974{
Christoph Hellwig4906e212015-06-04 13:47:56 +1000975 struct xfs_mount *mp = tp->t_mountp;
976 bool dirty = (tp->t_flags & XFS_TRANS_DIRTY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977
978 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979 * See if the caller is relying on us to shut down the
980 * filesystem. This happens in paths where we detect
981 * corruption and decide to give up.
982 */
Christoph Hellwig4906e212015-06-04 13:47:56 +1000983 if (dirty && !XFS_FORCED_SHUTDOWN(mp)) {
Ryan Hankins0733af22006-01-11 15:36:44 +1100984 XFS_ERROR_REPORT("xfs_trans_cancel", XFS_ERRLEVEL_LOW, mp);
Nathan Scott7d04a332006-06-09 14:58:38 +1000985 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
Nathan Scott60a204f2006-01-11 15:37:00 +1100986 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987#ifdef DEBUG
Christoph Hellwig4906e212015-06-04 13:47:56 +1000988 if (!dirty && !XFS_FORCED_SHUTDOWN(mp)) {
Christoph Hellwige98c4142010-06-23 18:11:15 +1000989 struct xfs_log_item_desc *lidp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990
Christoph Hellwige98c4142010-06-23 18:11:15 +1000991 list_for_each_entry(lidp, &tp->t_items, lid_trans)
992 ASSERT(!(lidp->lid_item->li_type == XFS_LI_EFD));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993 }
994#endif
995 xfs_trans_unreserve_and_mod_sb(tp);
Christoph Hellwig7d095252009-06-08 15:33:32 +0200996 xfs_trans_unreserve_and_mod_dquots(tp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997
Christoph Hellwigf78c3902015-06-04 13:48:20 +1000998 if (tp->t_ticket)
999 xfs_log_done(mp, tp->t_ticket, NULL, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000
1001 /* mark this thread as no longer being in a transaction */
Nathan Scott59c1b082006-06-09 14:59:13 +10001002 current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003
Christoph Hellwig4906e212015-06-04 13:47:56 +10001004 xfs_trans_free_items(tp, NULLCOMMITLSN, dirty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005 xfs_trans_free(tp);
1006}
1007
Niv Sardi322ff6b2008-08-13 16:05:49 +10001008/*
1009 * Roll from one trans in the sequence of PERMANENT transactions to
1010 * the next: permanent transactions are only flushed out when
Christoph Hellwig70393312015-06-04 13:48:08 +10001011 * committed with xfs_trans_commit(), but we still want as soon
Niv Sardi322ff6b2008-08-13 16:05:49 +10001012 * as possible to let chunks of it go to the log. So we commit the
1013 * chunk we've been working on and get a new transaction to continue.
1014 */
1015int
Brian Fosterd43ac292015-08-19 09:50:13 +10001016__xfs_trans_roll(
Niv Sardi322ff6b2008-08-13 16:05:49 +10001017 struct xfs_trans **tpp,
Brian Fosterd43ac292015-08-19 09:50:13 +10001018 struct xfs_inode *dp,
1019 int *committed)
Niv Sardi322ff6b2008-08-13 16:05:49 +10001020{
1021 struct xfs_trans *trans;
Jie Liu3d3c8b52013-08-12 20:49:59 +10001022 struct xfs_trans_res tres;
Niv Sardi322ff6b2008-08-13 16:05:49 +10001023 int error;
1024
Eric Sandeencc07eed2016-03-15 11:42:47 +11001025 *committed = 0;
1026
Niv Sardi322ff6b2008-08-13 16:05:49 +10001027 /*
1028 * Ensure that the inode is always logged.
1029 */
1030 trans = *tpp;
Christoph Hellwig2e6db6c2015-06-04 13:47:29 +10001031 if (dp)
1032 xfs_trans_log_inode(trans, dp, XFS_ILOG_CORE);
Niv Sardi322ff6b2008-08-13 16:05:49 +10001033
1034 /*
1035 * Copy the critical parameters from one trans to the next.
1036 */
Jie Liu3d3c8b52013-08-12 20:49:59 +10001037 tres.tr_logres = trans->t_log_res;
1038 tres.tr_logcount = trans->t_log_count;
Niv Sardi322ff6b2008-08-13 16:05:49 +10001039 *tpp = xfs_trans_dup(trans);
1040
1041 /*
1042 * Commit the current transaction.
1043 * If this commit failed, then it'd just unlock those items that
1044 * are not marked ihold. That also means that a filesystem shutdown
1045 * is in progress. The caller takes the responsibility to cancel
1046 * the duplicate transaction that gets returned.
1047 */
Christoph Hellwig70393312015-06-04 13:48:08 +10001048 error = __xfs_trans_commit(trans, true);
Niv Sardi322ff6b2008-08-13 16:05:49 +10001049 if (error)
Eric Sandeend99831f2014-06-22 15:03:54 +10001050 return error;
Niv Sardi322ff6b2008-08-13 16:05:49 +10001051
Brian Fosterd43ac292015-08-19 09:50:13 +10001052 *committed = 1;
Niv Sardi322ff6b2008-08-13 16:05:49 +10001053 trans = *tpp;
1054
1055 /*
1056 * Reserve space in the log for th next transaction.
1057 * This also pushes items in the "AIL", the list of logged items,
1058 * out to disk if they are taking up space at the tail of the log
1059 * that we want to use. This requires that either nothing be locked
1060 * across this call, or that anything that is locked be logged in
1061 * the prior and the next transactions.
1062 */
Jie Liu3d3c8b52013-08-12 20:49:59 +10001063 tres.tr_logflags = XFS_TRANS_PERM_LOG_RES;
1064 error = xfs_trans_reserve(trans, &tres, 0, 0);
Niv Sardi322ff6b2008-08-13 16:05:49 +10001065 /*
1066 * Ensure that the inode is in the new transaction and locked.
1067 */
1068 if (error)
1069 return error;
1070
Christoph Hellwig2e6db6c2015-06-04 13:47:29 +10001071 if (dp)
1072 xfs_trans_ijoin(trans, dp, 0);
Niv Sardi322ff6b2008-08-13 16:05:49 +10001073 return 0;
1074}
Brian Fosterd43ac292015-08-19 09:50:13 +10001075
1076int
1077xfs_trans_roll(
1078 struct xfs_trans **tpp,
1079 struct xfs_inode *dp)
1080{
Eric Sandeencc07eed2016-03-15 11:42:47 +11001081 int committed;
Brian Fosterd43ac292015-08-19 09:50:13 +10001082 return __xfs_trans_roll(tpp, dp, &committed);
1083}