Line data Source code
1 : // SPDX-License-Identifier: GPL-2.0
2 : /*
3 : * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
4 : * Copyright (C) 2010 Red Hat, Inc.
5 : * All Rights Reserved.
6 : */
7 : #include "xfs.h"
8 : #include "xfs_fs.h"
9 : #include "xfs_shared.h"
10 : #include "xfs_format.h"
11 : #include "xfs_log_format.h"
12 : #include "xfs_trans_resv.h"
13 : #include "xfs_mount.h"
14 : #include "xfs_extent_busy.h"
15 : #include "xfs_quota.h"
16 : #include "xfs_trans.h"
17 : #include "xfs_trans_priv.h"
18 : #include "xfs_log.h"
19 : #include "xfs_log_priv.h"
20 : #include "xfs_trace.h"
21 : #include "xfs_error.h"
22 : #include "xfs_defer.h"
23 : #include "xfs_inode.h"
24 : #include "xfs_dquot_item.h"
25 : #include "xfs_dquot.h"
26 : #include "xfs_icache.h"
27 :
28 : struct kmem_cache *xfs_trans_cache;
29 :
30 : #if defined(CONFIG_TRACEPOINTS)
31 : static void
32 22491 : xfs_trans_trace_reservations(
33 : struct xfs_mount *mp)
34 : {
35 22491 : struct xfs_trans_res *res;
36 22491 : struct xfs_trans_res *end_res;
37 22491 : int i;
38 :
39 22491 : res = (struct xfs_trans_res *)M_RES(mp);
40 22491 : end_res = (struct xfs_trans_res *)(M_RES(mp) + 1);
41 607257 : for (i = 0; res < end_res; i++, res++)
42 584766 : trace_xfs_trans_resv_calc(mp, i, res);
43 22491 : }
44 : #else
45 : # define xfs_trans_trace_reservations(mp)
46 : #endif
47 :
48 : /*
49 : * Initialize the precomputed transaction reservation values
50 : * in the mount structure.
51 : */
52 : void
53 22491 : xfs_trans_init(
54 : struct xfs_mount *mp)
55 : {
56 22491 : xfs_trans_resv_calc(mp, M_RES(mp));
57 22491 : xfs_trans_trace_reservations(mp);
58 22491 : }
59 :
60 : /*
61 : * Free the transaction structure. If there is more clean up
62 : * to do when the structure is freed, add it here.
63 : */
64 : STATIC void
65 3223250342 : xfs_trans_free(
66 : struct xfs_trans *tp)
67 : {
68 3223250342 : xfs_extent_busy_sort(&tp->t_busy);
69 3224439024 : xfs_extent_busy_clear(tp->t_mountp, &tp->t_busy, false);
70 :
71 3224136841 : trace_xfs_trans_free(tp, _RET_IP_);
72 3224304224 : xfs_trans_clear_context(tp);
73 3224303956 : if (!(tp->t_flags & XFS_TRANS_NO_WRITECOUNT))
74 852758516 : sb_end_intwrite(tp->t_mountp->m_super);
75 3224459217 : xfs_trans_free_dqinfo(tp);
76 3224247436 : kmem_cache_free(xfs_trans_cache, tp);
77 3225153916 : }
78 :
79 : /*
80 : * This is called to create a new transaction which will share the
81 : * permanent log reservation of the given transaction. The remaining
82 : * unused block and rt extent reservations are also inherited. This
83 : * implies that the original transaction is no longer allowed to allocate
84 : * blocks. Locks and log items, however, are no inherited. They must
85 : * be added to the new transaction explicitly.
86 : */
87 : STATIC struct xfs_trans *
88 454099070 : xfs_trans_dup(
89 : struct xfs_trans *tp)
90 : {
91 454099070 : struct xfs_trans *ntp;
92 :
93 454099070 : trace_xfs_trans_dup(tp, _RET_IP_);
94 :
95 454100458 : ntp = kmem_cache_zalloc(xfs_trans_cache, GFP_KERNEL | __GFP_NOFAIL);
96 :
97 : /*
98 : * Initialize the new transaction structure.
99 : */
100 454205081 : ntp->t_magic = XFS_TRANS_HEADER_MAGIC;
101 454205081 : ntp->t_mountp = tp->t_mountp;
102 454205081 : INIT_LIST_HEAD(&ntp->t_items);
103 454205081 : INIT_LIST_HEAD(&ntp->t_busy);
104 454205081 : INIT_LIST_HEAD(&ntp->t_dfops);
105 454205081 : ntp->t_highest_agno = NULLAGNUMBER;
106 :
107 454205081 : ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
108 454205081 : ASSERT(tp->t_ticket != NULL);
109 :
110 454205081 : ntp->t_flags = XFS_TRANS_PERM_LOG_RES |
111 454205081 : (tp->t_flags & XFS_TRANS_RESERVE) |
112 454205081 : (tp->t_flags & XFS_TRANS_NO_WRITECOUNT) |
113 : (tp->t_flags & XFS_TRANS_RES_FDBLKS);
114 : /* We gave our writer reference to the new transaction */
115 454205081 : tp->t_flags |= XFS_TRANS_NO_WRITECOUNT;
116 454205081 : ntp->t_ticket = xfs_log_ticket_get(tp->t_ticket);
117 :
118 454161817 : ASSERT(tp->t_blk_res >= tp->t_blk_res_used);
119 454161817 : ntp->t_blk_res = tp->t_blk_res - tp->t_blk_res_used;
120 454161817 : tp->t_blk_res = tp->t_blk_res_used;
121 :
122 454161817 : ntp->t_rtx_res = tp->t_rtx_res - tp->t_rtx_res_used;
123 454161817 : tp->t_rtx_res = tp->t_rtx_res_used;
124 :
125 454161817 : xfs_trans_switch_context(tp, ntp);
126 :
127 : /* move deferred ops over to the new tp */
128 454132776 : xfs_defer_move(ntp, tp);
129 :
130 454128652 : xfs_trans_dup_dqinfo(tp, ntp);
131 454174423 : return ntp;
132 : }
133 :
134 : /*
135 : * This is called to reserve free disk blocks and log space for the
136 : * given transaction. This must be done before allocating any resources
137 : * within the transaction.
138 : *
139 : * This will return ENOSPC if there are not enough blocks available.
140 : * It will sleep waiting for available log space.
141 : * The only valid value for the flags parameter is XFS_RES_LOG_PERM, which
142 : * is used by long running transactions. If any one of the reservations
143 : * fails then they will all be backed out.
144 : *
145 : * This does not do quota reservations. That typically is done by the
146 : * caller afterwards.
147 : */
148 : static int
149 3224689345 : xfs_trans_reserve(
150 : struct xfs_trans *tp,
151 : struct xfs_trans_res *resp,
152 : uint blocks,
153 : uint rtextents)
154 : {
155 3224689345 : struct xfs_mount *mp = tp->t_mountp;
156 3224689345 : int error = 0;
157 3224689345 : bool rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0;
158 :
159 : /*
160 : * Attempt to reserve the needed disk blocks by decrementing
161 : * the number needed from the number available. This will
162 : * fail if the count would go below zero.
163 : */
164 3224689345 : if (blocks > 0) {
165 414470393 : error = xfs_mod_fdblocks(mp, -((int64_t)blocks), rsvd);
166 414480541 : if (error != 0)
167 : return -ENOSPC;
168 406272298 : tp->t_blk_res += blocks;
169 : }
170 :
171 : /*
172 : * Reserve the log space needed for this transaction.
173 : */
174 3216491250 : if (resp->tr_logres > 0) {
175 1298888498 : bool permanent = false;
176 :
177 1298888498 : ASSERT(tp->t_log_res == 0 ||
178 : tp->t_log_res == resp->tr_logres);
179 1298888498 : ASSERT(tp->t_log_count == 0 ||
180 : tp->t_log_count == resp->tr_logcount);
181 :
182 1298888498 : if (resp->tr_logflags & XFS_TRANS_PERM_LOG_RES) {
183 1215797204 : tp->t_flags |= XFS_TRANS_PERM_LOG_RES;
184 1215797204 : permanent = true;
185 : } else {
186 83091294 : ASSERT(tp->t_ticket == NULL);
187 83091294 : ASSERT(!(tp->t_flags & XFS_TRANS_PERM_LOG_RES));
188 : }
189 :
190 1298888498 : if (tp->t_ticket != NULL) {
191 454219100 : ASSERT(resp->tr_logflags & XFS_TRANS_PERM_LOG_RES);
192 454219100 : error = xfs_log_regrant(mp, tp->t_ticket);
193 : } else {
194 844669398 : error = xfs_log_reserve(mp, resp->tr_logres,
195 : resp->tr_logcount,
196 : &tp->t_ticket, permanent);
197 : }
198 :
199 1298996062 : if (error)
200 1847 : goto undo_blocks;
201 :
202 1298994215 : tp->t_log_res = resp->tr_logres;
203 1298994215 : tp->t_log_count = resp->tr_logcount;
204 : }
205 :
206 : /*
207 : * Attempt to reserve the needed realtime extents by decrementing
208 : * the number needed from the number available. This will
209 : * fail if the count would go below zero.
210 : */
211 3216596967 : if (rtextents > 0) {
212 7420030 : error = xfs_mod_frextents(mp, -((int64_t)rtextents));
213 7420031 : if (error) {
214 0 : error = -ENOSPC;
215 0 : goto undo_log;
216 : }
217 7420031 : tp->t_rtx_res += rtextents;
218 : }
219 :
220 : return 0;
221 :
222 : /*
223 : * Error cases jump to one of these labels to undo any
224 : * reservations which have already been performed.
225 : */
226 : undo_log:
227 0 : if (resp->tr_logres > 0) {
228 0 : xfs_log_ticket_ungrant(mp->m_log, tp->t_ticket);
229 0 : tp->t_ticket = NULL;
230 0 : tp->t_log_res = 0;
231 0 : tp->t_flags &= ~XFS_TRANS_PERM_LOG_RES;
232 : }
233 :
234 0 : undo_blocks:
235 1847 : if (blocks > 0) {
236 288 : xfs_mod_fdblocks(mp, (int64_t)blocks, rsvd);
237 288 : tp->t_blk_res = 0;
238 : }
239 : return error;
240 : }
241 :
242 : int
243 2765170565 : xfs_trans_alloc(
244 : struct xfs_mount *mp,
245 : struct xfs_trans_res *resp,
246 : uint blocks,
247 : uint rtextents,
248 : uint flags,
249 : struct xfs_trans **tpp)
250 : {
251 2765170565 : struct xfs_trans *tp;
252 2765170565 : bool want_retry = true;
253 2769286071 : int error;
254 :
255 : /*
256 : * Allocate the handle before we do our freeze accounting and setting up
257 : * GFP_NOFS allocation context so that we avoid lockdep false positives
258 : * by doing GFP_KERNEL allocations inside sb_start_intwrite().
259 : */
260 2769286071 : retry:
261 2769286071 : tp = kmem_cache_zalloc(xfs_trans_cache, GFP_KERNEL | __GFP_NOFAIL);
262 2770626223 : if (!(flags & XFS_TRANS_NO_WRITECOUNT))
263 852846369 : sb_start_intwrite(mp->m_super);
264 2770594396 : xfs_trans_set_context(tp);
265 :
266 : /*
267 : * Zero-reservation ("empty") transactions can't modify anything, so
268 : * they're allowed to run while we're frozen.
269 : */
270 5539772040 : WARN_ON(resp->tr_logres > 0 &&
271 : mp->m_super->s_writers.frozen == SB_FREEZE_COMPLETE);
272 2769886020 : ASSERT(!(flags & XFS_TRANS_RES_FDBLKS) ||
273 : xfs_has_lazysbcount(mp));
274 :
275 2769886020 : tp->t_magic = XFS_TRANS_HEADER_MAGIC;
276 2769886020 : tp->t_flags = flags;
277 2769886020 : tp->t_mountp = mp;
278 2769886020 : INIT_LIST_HEAD(&tp->t_items);
279 2769886020 : INIT_LIST_HEAD(&tp->t_busy);
280 2769886020 : INIT_LIST_HEAD(&tp->t_dfops);
281 2769886020 : tp->t_highest_agno = NULLAGNUMBER;
282 :
283 2769886020 : error = xfs_trans_reserve(tp, resp, blocks, rtextents);
284 2769610389 : if (error == -ENOSPC && want_retry) {
285 4115529 : xfs_trans_cancel(tp);
286 :
287 : /*
288 : * We weren't able to reserve enough space for the transaction.
289 : * Flush the other speculative space allocations to free space.
290 : * Do not perform a synchronous scan because callers can hold
291 : * other locks.
292 : */
293 4115227 : error = xfs_blockgc_flush_all(mp);
294 4115506 : if (error)
295 0 : return error;
296 4115506 : want_retry = false;
297 4115506 : goto retry;
298 : }
299 2765494860 : if (error) {
300 4094404 : xfs_trans_cancel(tp);
301 4094404 : return error;
302 : }
303 :
304 2761400456 : trace_xfs_trans_alloc(tp, _RET_IP_);
305 :
306 2761799497 : *tpp = tp;
307 2761799497 : return 0;
308 : }
309 :
310 : /*
311 : * Create an empty transaction with no reservation. This is a defensive
312 : * mechanism for routines that query metadata without actually modifying them --
313 : * if the metadata being queried is somehow cross-linked (think a btree block
314 : * pointer that points higher in the tree), we risk deadlock. However, blocks
315 : * grabbed as part of a transaction can be re-grabbed. The verifiers will
316 : * notice the corrupt block and the operation will fail back to userspace
317 : * without deadlocking.
318 : *
319 : * Note the zero-length reservation; this transaction MUST be cancelled without
320 : * any dirty data.
321 : *
322 : * Callers should obtain freeze protection to avoid a conflict with fs freezing
323 : * where we can be grabbing buffers at the same time that freeze is trying to
324 : * drain the buffer LRU list.
325 : */
326 : int
327 1917016718 : xfs_trans_alloc_empty(
328 : struct xfs_mount *mp,
329 : struct xfs_trans **tpp)
330 : {
331 1917016718 : struct xfs_trans_res resv = {0};
332 :
333 1917016718 : return xfs_trans_alloc(mp, &resv, 0, 0, XFS_TRANS_NO_WRITECOUNT, tpp);
334 : }
335 :
336 : /*
337 : * Record the indicated change to the given field for application
338 : * to the file system's superblock when the transaction commits.
339 : * For now, just store the change in the transaction structure.
340 : *
341 : * Mark the transaction structure to indicate that the superblock
342 : * needs to be updated before committing.
343 : *
344 : * Because we may not be keeping track of allocated/free inodes and
345 : * used filesystem blocks in the superblock, we do not mark the
346 : * superblock dirty in this transaction if we modify these fields.
347 : * We still need to update the transaction deltas so that they get
348 : * applied to the incore superblock, but we don't want them to
349 : * cause the superblock to get locked and logged if these are the
350 : * only fields in the superblock that the transaction modifies.
351 : */
352 : void
353 177355377 : xfs_trans_mod_sb(
354 : xfs_trans_t *tp,
355 : uint field,
356 : int64_t delta)
357 : {
358 177355377 : uint32_t flags = (XFS_TRANS_DIRTY|XFS_TRANS_SB_DIRTY);
359 177355377 : xfs_mount_t *mp = tp->t_mountp;
360 :
361 177355377 : switch (field) {
362 418128 : case XFS_TRANS_SB_ICOUNT:
363 418128 : tp->t_icount_delta += delta;
364 418128 : if (xfs_has_lazysbcount(mp))
365 418126 : flags &= ~XFS_TRANS_SB_DIRTY;
366 : break;
367 82005312 : case XFS_TRANS_SB_IFREE:
368 82005312 : tp->t_ifree_delta += delta;
369 82005312 : if (xfs_has_lazysbcount(mp))
370 82008164 : flags &= ~XFS_TRANS_SB_DIRTY;
371 : break;
372 71963413 : case XFS_TRANS_SB_FDBLOCKS:
373 : /*
374 : * Track the number of blocks allocated in the transaction.
375 : * Make sure it does not exceed the number reserved. If so,
376 : * shutdown as this can lead to accounting inconsistency.
377 : */
378 71963413 : if (delta < 0) {
379 31205673 : tp->t_blk_res_used += (uint)-delta;
380 31205673 : if (tp->t_blk_res_used > tp->t_blk_res)
381 0 : xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
382 40757740 : } else if (delta > 0 && (tp->t_flags & XFS_TRANS_RES_FDBLKS)) {
383 1417 : int64_t blkres_delta;
384 :
385 : /*
386 : * Return freed blocks directly to the reservation
387 : * instead of the global pool, being careful not to
388 : * overflow the trans counter. This is used to preserve
389 : * reservation across chains of transaction rolls that
390 : * repeatedly free and allocate blocks.
391 : */
392 1417 : blkres_delta = min_t(int64_t, delta,
393 : UINT_MAX - tp->t_blk_res);
394 1417 : tp->t_blk_res += blkres_delta;
395 1417 : delta -= blkres_delta;
396 : }
397 71963413 : tp->t_fdblocks_delta += delta;
398 71963413 : if (xfs_has_lazysbcount(mp))
399 71959826 : flags &= ~XFS_TRANS_SB_DIRTY;
400 : break;
401 13426724 : case XFS_TRANS_SB_RES_FDBLOCKS:
402 : /*
403 : * The allocation has already been applied to the
404 : * in-core superblock's counter. This should only
405 : * be applied to the on-disk superblock.
406 : */
407 13426724 : tp->t_res_fdblocks_delta += delta;
408 13426724 : if (xfs_has_lazysbcount(mp))
409 13426728 : flags &= ~XFS_TRANS_SB_DIRTY;
410 : break;
411 9541577 : case XFS_TRANS_SB_FREXTENTS:
412 : /*
413 : * Track the number of blocks allocated in the
414 : * transaction. Make sure it does not exceed the
415 : * number reserved.
416 : */
417 9541577 : if (delta < 0) {
418 6825236 : tp->t_rtx_res_used += (uint)-delta;
419 6825236 : ASSERT(tp->t_rtx_res_used <= tp->t_rtx_res);
420 : }
421 9541577 : tp->t_frextents_delta += delta;
422 9541577 : break;
423 0 : case XFS_TRANS_SB_RES_FREXTENTS:
424 : /*
425 : * The allocation has already been applied to the
426 : * in-core superblock's counter. This should only
427 : * be applied to the on-disk superblock.
428 : */
429 0 : ASSERT(delta < 0);
430 0 : tp->t_res_frextents_delta += delta;
431 0 : break;
432 121 : case XFS_TRANS_SB_DBLOCKS:
433 121 : tp->t_dblocks_delta += delta;
434 121 : break;
435 86 : case XFS_TRANS_SB_AGCOUNT:
436 86 : ASSERT(delta > 0);
437 86 : tp->t_agcount_delta += delta;
438 86 : break;
439 0 : case XFS_TRANS_SB_IMAXPCT:
440 0 : tp->t_imaxpct_delta += delta;
441 0 : break;
442 0 : case XFS_TRANS_SB_REXTSIZE:
443 0 : tp->t_rextsize_delta += delta;
444 0 : break;
445 3 : case XFS_TRANS_SB_RBMBLOCKS:
446 3 : tp->t_rbmblocks_delta += delta;
447 3 : break;
448 5 : case XFS_TRANS_SB_RBLOCKS:
449 5 : tp->t_rblocks_delta += delta;
450 5 : break;
451 5 : case XFS_TRANS_SB_REXTENTS:
452 5 : tp->t_rextents_delta += delta;
453 5 : break;
454 3 : case XFS_TRANS_SB_REXTSLOG:
455 3 : tp->t_rextslog_delta += delta;
456 3 : break;
457 0 : default:
458 0 : ASSERT(0);
459 0 : return;
460 : }
461 :
462 177355377 : tp->t_flags |= flags;
463 : }
464 :
465 : /*
466 : * xfs_trans_apply_sb_deltas() is called from the commit code
467 : * to bring the superblock buffer into the current transaction
468 : * and modify it as requested by earlier calls to xfs_trans_mod_sb().
469 : *
470 : * For now we just look at each field allowed to change and change
471 : * it if necessary.
472 : */
473 : STATIC void
474 8449526 : xfs_trans_apply_sb_deltas(
475 : xfs_trans_t *tp)
476 : {
477 8449526 : struct xfs_dsb *sbp;
478 8449526 : struct xfs_buf *bp;
479 8449526 : int whole = 0;
480 :
481 8449526 : bp = xfs_trans_getsb(tp);
482 8449526 : sbp = bp->b_addr;
483 :
484 : /*
485 : * Only update the superblock counters if we are logging them
486 : */
487 8449526 : if (!xfs_has_lazysbcount((tp->t_mountp))) {
488 210 : if (tp->t_icount_delta)
489 2 : be64_add_cpu(&sbp->sb_icount, tp->t_icount_delta);
490 210 : if (tp->t_ifree_delta)
491 206 : be64_add_cpu(&sbp->sb_ifree, tp->t_ifree_delta);
492 210 : if (tp->t_fdblocks_delta)
493 8 : be64_add_cpu(&sbp->sb_fdblocks, tp->t_fdblocks_delta);
494 210 : if (tp->t_res_fdblocks_delta)
495 0 : be64_add_cpu(&sbp->sb_fdblocks, tp->t_res_fdblocks_delta);
496 : }
497 :
498 : /*
499 : * Updating frextents requires careful handling because it does not
500 : * behave like the lazysb counters because we cannot rely on log
501 : * recovery in older kenels to recompute the value from the rtbitmap.
502 : * This means that the ondisk frextents must be consistent with the
503 : * rtbitmap.
504 : *
505 : * Therefore, log the frextents change to the ondisk superblock and
506 : * update the incore superblock so that future calls to xfs_log_sb
507 : * write the correct value ondisk.
508 : *
509 : * Don't touch m_frextents because it includes incore reservations,
510 : * and those are handled by the unreserve function.
511 : */
512 8449526 : if (tp->t_frextents_delta || tp->t_res_frextents_delta) {
513 8449195 : struct xfs_mount *mp = tp->t_mountp;
514 8449195 : int64_t rtxdelta;
515 :
516 8449195 : rtxdelta = tp->t_frextents_delta + tp->t_res_frextents_delta;
517 :
518 8449195 : spin_lock(&mp->m_sb_lock);
519 8449195 : be64_add_cpu(&sbp->sb_frextents, rtxdelta);
520 8449195 : mp->m_sb.sb_frextents += rtxdelta;
521 8449195 : spin_unlock(&mp->m_sb_lock);
522 : }
523 :
524 8449526 : if (tp->t_dblocks_delta) {
525 121 : be64_add_cpu(&sbp->sb_dblocks, tp->t_dblocks_delta);
526 121 : whole = 1;
527 : }
528 8449526 : if (tp->t_agcount_delta) {
529 86 : be32_add_cpu(&sbp->sb_agcount, tp->t_agcount_delta);
530 86 : whole = 1;
531 : }
532 8449526 : if (tp->t_imaxpct_delta) {
533 0 : sbp->sb_imax_pct += tp->t_imaxpct_delta;
534 0 : whole = 1;
535 : }
536 8449526 : if (tp->t_rextsize_delta) {
537 0 : be32_add_cpu(&sbp->sb_rextsize, tp->t_rextsize_delta);
538 0 : whole = 1;
539 : }
540 8449526 : if (tp->t_rbmblocks_delta) {
541 3 : be32_add_cpu(&sbp->sb_rbmblocks, tp->t_rbmblocks_delta);
542 3 : whole = 1;
543 : }
544 8449526 : if (tp->t_rblocks_delta) {
545 5 : be64_add_cpu(&sbp->sb_rblocks, tp->t_rblocks_delta);
546 5 : whole = 1;
547 : }
548 8449526 : if (tp->t_rextents_delta) {
549 5 : be64_add_cpu(&sbp->sb_rextents, tp->t_rextents_delta);
550 5 : whole = 1;
551 : }
552 8449526 : if (tp->t_rextslog_delta) {
553 3 : sbp->sb_rextslog += tp->t_rextslog_delta;
554 3 : whole = 1;
555 : }
556 :
557 8449526 : xfs_trans_buf_set_type(tp, bp, XFS_BLFT_SB_BUF);
558 8449526 : if (whole)
559 : /*
560 : * Log the whole thing, the fields are noncontiguous.
561 : */
562 126 : xfs_trans_log_buf(tp, bp, 0, sizeof(struct xfs_dsb) - 1);
563 : else
564 : /*
565 : * Since all the modifiable fields are contiguous, we
566 : * can get away with this.
567 : */
568 8449400 : xfs_trans_log_buf(tp, bp, offsetof(struct xfs_dsb, sb_icount),
569 : offsetof(struct xfs_dsb, sb_frextents) +
570 : sizeof(sbp->sb_frextents) - 1);
571 8449526 : }
572 :
573 : /*
574 : * xfs_trans_unreserve_and_mod_sb() is called to release unused reservations and
575 : * apply superblock counter changes to the in-core superblock. The
576 : * t_res_fdblocks_delta and t_res_frextents_delta fields are explicitly NOT
577 : * applied to the in-core superblock. The idea is that that has already been
578 : * done.
579 : *
580 : * If we are not logging superblock counters, then the inode allocated/free and
581 : * used block counts are not updated in the on disk superblock. In this case,
582 : * XFS_TRANS_SB_DIRTY will not be set when the transaction is updated but we
583 : * still need to update the incore superblock with the changes.
584 : *
585 : * Deltas for the inode count are +/-64, hence we use a large batch size of 128
586 : * so we don't need to take the counter lock on every update.
587 : */
588 : #define XFS_ICOUNT_BATCH 128
589 :
590 : void
591 3223326626 : xfs_trans_unreserve_and_mod_sb(
592 : struct xfs_trans *tp)
593 : {
594 3223326626 : struct xfs_mount *mp = tp->t_mountp;
595 3223326626 : bool rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0;
596 3223326626 : int64_t blkdelta = 0;
597 3223326626 : int64_t rtxdelta = 0;
598 3223326626 : int64_t idelta = 0;
599 3223326626 : int64_t ifreedelta = 0;
600 3223326626 : int error;
601 :
602 : /* calculate deltas */
603 3223326626 : if (tp->t_blk_res > 0)
604 : blkdelta = tp->t_blk_res;
605 3223326626 : if ((tp->t_fdblocks_delta != 0) &&
606 8 : (xfs_has_lazysbcount(mp) ||
607 8 : (tp->t_flags & XFS_TRANS_SB_DIRTY)))
608 69902388 : blkdelta += tp->t_fdblocks_delta;
609 :
610 3223326626 : if (tp->t_rtx_res > 0)
611 : rtxdelta = tp->t_rtx_res;
612 3223326626 : if ((tp->t_frextents_delta != 0) &&
613 8449195 : (tp->t_flags & XFS_TRANS_SB_DIRTY))
614 8449195 : rtxdelta += tp->t_frextents_delta;
615 :
616 3223326626 : if (xfs_has_lazysbcount(mp) ||
617 450 : (tp->t_flags & XFS_TRANS_SB_DIRTY)) {
618 3223326386 : idelta = tp->t_icount_delta;
619 3223326386 : ifreedelta = tp->t_ifree_delta;
620 : }
621 :
622 : /* apply the per-cpu counters */
623 3223326626 : if (blkdelta) {
624 437116097 : error = xfs_mod_fdblocks(mp, blkdelta, rsvd);
625 437123659 : ASSERT(!error);
626 : }
627 :
628 3223334188 : if (idelta)
629 418128 : percpu_counter_add_batch(&mp->m_icount, idelta,
630 : XFS_ICOUNT_BATCH);
631 :
632 3223334188 : if (ifreedelta)
633 82007781 : percpu_counter_add(&mp->m_ifree, ifreedelta);
634 :
635 3223336223 : if (rtxdelta) {
636 4058825 : error = xfs_mod_frextents(mp, rtxdelta);
637 4058825 : ASSERT(!error);
638 : }
639 :
640 3223336223 : if (!(tp->t_flags & XFS_TRANS_SB_DIRTY))
641 : return;
642 :
643 : /* apply remaining deltas */
644 8449526 : spin_lock(&mp->m_sb_lock);
645 8449526 : mp->m_sb.sb_fdblocks += tp->t_fdblocks_delta + tp->t_res_fdblocks_delta;
646 8449526 : mp->m_sb.sb_icount += idelta;
647 8449526 : mp->m_sb.sb_ifree += ifreedelta;
648 : /*
649 : * Do not touch sb_frextents here because we are dealing with incore
650 : * reservation. sb_frextents is not part of the lazy sb counters so it
651 : * must be consistent with the ondisk rtbitmap and must never include
652 : * incore reservations.
653 : */
654 8449526 : mp->m_sb.sb_dblocks += tp->t_dblocks_delta;
655 8449526 : mp->m_sb.sb_agcount += tp->t_agcount_delta;
656 8449526 : mp->m_sb.sb_imax_pct += tp->t_imaxpct_delta;
657 8449526 : mp->m_sb.sb_rextsize += tp->t_rextsize_delta;
658 8449526 : mp->m_sb.sb_rbmblocks += tp->t_rbmblocks_delta;
659 8449526 : mp->m_sb.sb_rblocks += tp->t_rblocks_delta;
660 8449526 : mp->m_sb.sb_rextents += tp->t_rextents_delta;
661 8449526 : mp->m_sb.sb_rextslog += tp->t_rextslog_delta;
662 8449526 : spin_unlock(&mp->m_sb_lock);
663 :
664 : /*
665 : * Debug checks outside of the spinlock so they don't lock up the
666 : * machine if they fail.
667 : */
668 : ASSERT(mp->m_sb.sb_imax_pct >= 0);
669 : ASSERT(mp->m_sb.sb_rextslog >= 0);
670 : return;
671 : }
672 :
673 : /* Add the given log item to the transaction's list of log items. */
674 : void
675 15305622342 : xfs_trans_add_item(
676 : struct xfs_trans *tp,
677 : struct xfs_log_item *lip)
678 : {
679 15305622342 : ASSERT(lip->li_log == tp->t_mountp->m_log);
680 15305622342 : ASSERT(lip->li_ailp == tp->t_mountp->m_ail);
681 15305622342 : ASSERT(list_empty(&lip->li_trans));
682 15305622342 : ASSERT(!test_bit(XFS_LI_DIRTY, &lip->li_flags));
683 :
684 15305622342 : list_add_tail(&lip->li_trans, &tp->t_items);
685 15311865794 : trace_xfs_trans_add_item(tp, _RET_IP_);
686 15315242665 : }
687 :
688 : /*
689 : * Unlink the log item from the transaction. the log item is no longer
690 : * considered dirty in this transaction, as the linked transaction has
691 : * finished, either by abort or commit completion.
692 : */
693 : void
694 15309533897 : xfs_trans_del_item(
695 : struct xfs_log_item *lip)
696 : {
697 15309533897 : clear_bit(XFS_LI_DIRTY, &lip->li_flags);
698 15310691795 : list_del_init(&lip->li_trans);
699 15312669932 : }
700 :
701 : /* Detach and unlock all of the items in a transaction */
702 : static void
703 2322197040 : xfs_trans_free_items(
704 : struct xfs_trans *tp,
705 : bool abort)
706 : {
707 2322197040 : struct xfs_log_item *lip, *next;
708 :
709 2322197040 : trace_xfs_trans_free_items(tp, _RET_IP_);
710 :
711 2438789107 : list_for_each_entry_safe(lip, next, &tp->t_items, li_trans) {
712 116182574 : xfs_trans_del_item(lip);
713 116151564 : if (abort)
714 20267 : set_bit(XFS_LI_ABORTED, &lip->li_flags);
715 116151564 : if (lip->li_ops->iop_release)
716 116151564 : lip->li_ops->iop_release(lip);
717 : }
718 2322606533 : }
719 :
720 : static inline void
721 14429945 : xfs_log_item_batch_insert(
722 : struct xfs_ail *ailp,
723 : struct xfs_ail_cursor *cur,
724 : struct xfs_log_item **log_items,
725 : int nr_items,
726 : xfs_lsn_t commit_lsn)
727 : {
728 14429945 : int i;
729 :
730 14429945 : spin_lock(&ailp->ail_lock);
731 : /* xfs_trans_ail_update_bulk drops ailp->ail_lock */
732 14429945 : xfs_trans_ail_update_bulk(ailp, cur, log_items, nr_items, commit_lsn);
733 :
734 439782891 : for (i = 0; i < nr_items; i++) {
735 410923001 : struct xfs_log_item *lip = log_items[i];
736 :
737 410923001 : if (lip->li_ops->iop_unpin)
738 410923001 : lip->li_ops->iop_unpin(lip, 0);
739 : }
740 14429945 : }
741 :
742 : /*
743 : * Bulk operation version of xfs_trans_committed that takes a log vector of
744 : * items to insert into the AIL. This uses bulk AIL insertion techniques to
745 : * minimise lock traffic.
746 : *
747 : * If we are called with the aborted flag set, it is because a log write during
748 : * a CIL checkpoint commit has failed. In this case, all the items in the
749 : * checkpoint have already gone through iop_committed and iop_committing, which
750 : * means that checkpoint commit abort handling is treated exactly the same
751 : * as an iclog write error even though we haven't started any IO yet. Hence in
752 : * this case all we need to do is iop_committed processing, followed by an
753 : * iop_unpin(aborted) call.
754 : *
755 : * The AIL cursor is used to optimise the insert process. If commit_lsn is not
756 : * at the end of the AIL, the insert cursor avoids the need to walk
757 : * the AIL to find the insertion point on every xfs_log_item_batch_insert()
758 : * call. This saves a lot of needless list walking and is a net win, even
759 : * though it slightly increases that amount of AIL lock traffic to set it up
760 : * and tear it down.
761 : */
762 : void
763 2550712 : xfs_trans_committed_bulk(
764 : struct xfs_ail *ailp,
765 : struct list_head *lv_chain,
766 : xfs_lsn_t commit_lsn,
767 : bool aborted)
768 : {
769 : #define LOG_ITEM_BATCH_SIZE 32
770 2550712 : struct xfs_log_item *log_items[LOG_ITEM_BATCH_SIZE];
771 2550712 : struct xfs_log_vec *lv;
772 2550712 : struct xfs_ail_cursor cur;
773 2550712 : int i = 0;
774 :
775 2550712 : spin_lock(&ailp->ail_lock);
776 2550712 : xfs_trans_ail_cursor_last(ailp, &cur, commit_lsn);
777 2550712 : spin_unlock(&ailp->ail_lock);
778 :
779 : /* unpin all the log items */
780 418107314 : list_for_each_entry(lv, lv_chain, lv_list) {
781 415556602 : struct xfs_log_item *lip = lv->lv_item;
782 415556602 : xfs_lsn_t item_lsn;
783 :
784 415556602 : if (aborted)
785 1078536 : set_bit(XFS_LI_ABORTED, &lip->li_flags);
786 :
787 415556590 : if (lip->li_ops->flags & XFS_ITEM_RELEASE_WHEN_COMMITTED) {
788 904939 : lip->li_ops->iop_release(lip);
789 904939 : continue;
790 : }
791 :
792 414651651 : if (lip->li_ops->iop_committed)
793 391516560 : item_lsn = lip->li_ops->iop_committed(lip, commit_lsn);
794 : else
795 : item_lsn = commit_lsn;
796 :
797 : /* item_lsn of -1 means the item needs no further processing */
798 414651653 : if (XFS_LSN_CMP(item_lsn, (xfs_lsn_t)-1) == 0)
799 2637598 : continue;
800 :
801 : /*
802 : * if we are aborting the operation, no point in inserting the
803 : * object into the AIL as we are in a shutdown situation.
804 : */
805 412014055 : if (aborted) {
806 2115274 : ASSERT(xlog_is_shutdown(ailp->ail_log));
807 1057637 : if (lip->li_ops->iop_unpin)
808 1057637 : lip->li_ops->iop_unpin(lip, 1);
809 1057647 : continue;
810 : }
811 :
812 410956418 : if (item_lsn != commit_lsn) {
813 :
814 : /*
815 : * Not a bulk update option due to unusual item_lsn.
816 : * Push into AIL immediately, rechecking the lsn once
817 : * we have the ail lock. Then unpin the item. This does
818 : * not affect the AIL cursor the bulk insert path is
819 : * using.
820 : */
821 33417 : spin_lock(&ailp->ail_lock);
822 33417 : if (XFS_LSN_CMP(item_lsn, lip->li_lsn) > 0)
823 0 : xfs_trans_ail_update(ailp, lip, item_lsn);
824 : else
825 33417 : spin_unlock(&ailp->ail_lock);
826 33417 : if (lip->li_ops->iop_unpin)
827 33417 : lip->li_ops->iop_unpin(lip, 0);
828 33417 : continue;
829 : }
830 :
831 : /* Item is a candidate for bulk AIL insert. */
832 410923001 : log_items[i++] = lv->lv_item;
833 410923001 : if (i >= LOG_ITEM_BATCH_SIZE) {
834 11928835 : xfs_log_item_batch_insert(ailp, &cur, log_items,
835 : LOG_ITEM_BATCH_SIZE, commit_lsn);
836 11928835 : i = 0;
837 : }
838 : }
839 :
840 : /* make sure we insert the remainder! */
841 2550712 : if (i)
842 2501110 : xfs_log_item_batch_insert(ailp, &cur, log_items, i, commit_lsn);
843 :
844 2550712 : spin_lock(&ailp->ail_lock);
845 2550712 : xfs_trans_ail_cursor_done(&cur);
846 2550712 : spin_unlock(&ailp->ail_lock);
847 2550712 : }
848 :
849 : /*
850 : * Sort transaction items prior to running precommit operations. This will
851 : * attempt to order the items such that they will always be locked in the same
852 : * order. Items that have no sort function are moved to the end of the list
853 : * and so are locked last.
854 : *
855 : * This may need refinement as different types of objects add sort functions.
856 : *
857 : * Function is more complex than it needs to be because we are comparing 64 bit
858 : * values and the function only returns 32 bit values.
859 : */
860 : static int
861 5815934370 : xfs_trans_precommit_sort(
862 : void *unused_arg,
863 : const struct list_head *a,
864 : const struct list_head *b)
865 : {
866 5815934370 : struct xfs_log_item *lia = container_of(a,
867 : struct xfs_log_item, li_trans);
868 5815934370 : struct xfs_log_item *lib = container_of(b,
869 : struct xfs_log_item, li_trans);
870 5815934370 : int64_t diff;
871 :
872 : /*
873 : * If both items are non-sortable, leave them alone. If only one is
874 : * sortable, move the non-sortable item towards the end of the list.
875 : */
876 5815934370 : if (!lia->li_ops->iop_sort && !lib->li_ops->iop_sort)
877 : return 0;
878 2609106064 : if (!lia->li_ops->iop_sort)
879 : return 1;
880 2475660675 : if (!lib->li_ops->iop_sort)
881 : return -1;
882 :
883 393361186 : diff = lia->li_ops->iop_sort(lia) - lib->li_ops->iop_sort(lib);
884 393416661 : if (diff < 0)
885 : return -1;
886 114626822 : if (diff > 0)
887 98950581 : return 1;
888 : return 0;
889 : }
890 :
891 : /*
892 : * Run transaction precommit functions.
893 : *
894 : * If there is an error in any of the callouts, then stop immediately and
895 : * trigger a shutdown to abort the transaction. There is no recovery possible
896 : * from errors at this point as the transaction is dirty....
897 : */
898 : static int
899 1283930826 : xfs_trans_run_precommits(
900 : struct xfs_trans *tp)
901 : {
902 1283930826 : struct xfs_mount *mp = tp->t_mountp;
903 1283930826 : struct xfs_log_item *lip, *n;
904 1283930826 : int error = 0;
905 :
906 : /*
907 : * Sort the item list to avoid ABBA deadlocks with other transactions
908 : * running precommit operations that lock multiple shared items such as
909 : * inode cluster buffers.
910 : */
911 1283930826 : list_sort(NULL, &tp->t_items, xfs_trans_precommit_sort);
912 :
913 : /*
914 : * Precommit operations can remove the log item from the transaction
915 : * if the log item exists purely to delay modifications until they
916 : * can be ordered against other operations. Hence we have to use
917 : * list_for_each_entry_safe() here.
918 : */
919 6149515866 : list_for_each_entry_safe(lip, n, &tp->t_items, li_trans) {
920 4865365571 : if (!test_bit(XFS_LI_DIRTY, &lip->li_flags))
921 632191500 : continue;
922 4233174071 : if (lip->li_ops->iop_precommit) {
923 1396640016 : error = lip->li_ops->iop_precommit(tp, lip);
924 1396713579 : if (error)
925 : break;
926 : }
927 : }
928 1284150555 : if (error)
929 260 : xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
930 1284150555 : return error;
931 : }
932 :
933 : /*
934 : * Commit the given transaction to the log.
935 : *
936 : * XFS disk error handling mechanism is not based on a typical
937 : * transaction abort mechanism. Logically after the filesystem
938 : * gets marked 'SHUTDOWN', we can't let any new transactions
939 : * be durable - ie. committed to disk - because some metadata might
940 : * be inconsistent. In such cases, this returns an error, and the
941 : * caller may assume that all locked objects joined to the transaction
942 : * have already been unlocked as if the commit had succeeded.
943 : * Do not reference the transaction structure after this call.
944 : */
945 : static int
946 907233130 : __xfs_trans_commit(
947 : struct xfs_trans *tp,
948 : bool regrant)
949 : {
950 907233130 : struct xfs_mount *mp = tp->t_mountp;
951 907233130 : struct xlog *log = mp->m_log;
952 907233130 : xfs_csn_t commit_seq = 0;
953 907233130 : int error = 0;
954 907233130 : int sync = tp->t_flags & XFS_TRANS_SYNC;
955 :
956 907233130 : trace_xfs_trans_commit(tp, _RET_IP_);
957 :
958 907246918 : error = xfs_trans_run_precommits(tp);
959 907172898 : if (error) {
960 260 : if (tp->t_flags & XFS_TRANS_PERM_LOG_RES)
961 244 : xfs_defer_cancel(tp);
962 260 : goto out_unreserve;
963 : }
964 :
965 : /*
966 : * Finish deferred items on final commit. Only permanent transactions
967 : * should ever have deferred ops.
968 : */
969 1814453018 : WARN_ON_ONCE(!list_empty(&tp->t_dfops) &&
970 : !(tp->t_flags & XFS_TRANS_PERM_LOG_RES));
971 907172638 : if (!regrant && (tp->t_flags & XFS_TRANS_PERM_LOG_RES)) {
972 377147551 : error = xfs_defer_finish_noroll(&tp);
973 377139544 : if (error)
974 1677 : goto out_unreserve;
975 :
976 : /* Run precommits from final tx in defer chain. */
977 377137867 : error = xfs_trans_run_precommits(tp);
978 377148746 : if (error)
979 0 : goto out_unreserve;
980 : }
981 :
982 : /*
983 : * If there is nothing to be logged by the transaction,
984 : * then unlock all of the items associated with the
985 : * transaction and free the transaction structure.
986 : * Also make sure to return any reserved blocks to
987 : * the free pool.
988 : */
989 907173833 : if (!(tp->t_flags & XFS_TRANS_DIRTY))
990 5576109 : goto out_unreserve;
991 :
992 : /*
993 : * We must check against log shutdown here because we cannot abort log
994 : * items and leave them dirty, inconsistent and unpinned in memory while
995 : * the log is active. This leaves them open to being written back to
996 : * disk, and that will lead to on-disk corruption.
997 : */
998 1803195448 : if (xlog_is_shutdown(log)) {
999 422 : error = -EIO;
1000 422 : goto out_unreserve;
1001 : }
1002 :
1003 901597302 : ASSERT(tp->t_ticket != NULL);
1004 :
1005 : /*
1006 : * If we need to update the superblock, then do it now.
1007 : */
1008 901597302 : if (tp->t_flags & XFS_TRANS_SB_DIRTY)
1009 8449526 : xfs_trans_apply_sb_deltas(tp);
1010 901597302 : xfs_trans_apply_dquot_deltas(tp);
1011 :
1012 901758063 : xlog_cil_commit(log, tp, &commit_seq, regrant);
1013 :
1014 901797270 : xfs_trans_free(tp);
1015 :
1016 : /*
1017 : * If the transaction needs to be synchronous, then force the
1018 : * log out now and wait for it.
1019 : */
1020 901789778 : if (sync) {
1021 115982 : error = xfs_log_force_seq(mp, commit_seq, XFS_LOG_SYNC, NULL);
1022 115982 : XFS_STATS_INC(mp, xs_trans_sync);
1023 : } else {
1024 901673796 : XFS_STATS_INC(mp, xs_trans_async);
1025 : }
1026 :
1027 : return error;
1028 :
1029 5578468 : out_unreserve:
1030 5578468 : xfs_trans_unreserve_and_mod_sb(tp);
1031 :
1032 : /*
1033 : * It is indeed possible for the transaction to be not dirty but
1034 : * the dqinfo portion to be. All that means is that we have some
1035 : * (non-persistent) quota reservations that need to be unreserved.
1036 : */
1037 5578472 : xfs_trans_unreserve_and_mod_dquots(tp);
1038 5578488 : if (tp->t_ticket) {
1039 5568337 : if (regrant && !xlog_is_shutdown(log))
1040 341 : xfs_log_ticket_regrant(log, tp->t_ticket);
1041 : else
1042 5567471 : xfs_log_ticket_ungrant(log, tp->t_ticket);
1043 5567816 : tp->t_ticket = NULL;
1044 : }
1045 5578492 : xfs_trans_free_items(tp, !!error);
1046 5578471 : xfs_trans_free(tp);
1047 :
1048 5578478 : XFS_STATS_INC(mp, xs_trans_empty);
1049 5578477 : return error;
1050 : }
1051 :
1052 : int
1053 453116581 : xfs_trans_commit(
1054 : struct xfs_trans *tp)
1055 : {
1056 453116581 : return __xfs_trans_commit(tp, false);
1057 : }
1058 :
1059 : /*
1060 : * Unlock all of the transaction's items and free the transaction. If the
1061 : * transaction is dirty, we must shut down the filesystem because there is no
1062 : * way to restore them to their previous state.
1063 : *
1064 : * If the transaction has made a log reservation, make sure to release it as
1065 : * well.
1066 : *
1067 : * This is a high level function (equivalent to xfs_trans_commit()) and so can
1068 : * be called after the transaction has effectively been aborted due to the mount
1069 : * being shut down. However, if the mount has not been shut down and the
1070 : * transaction is dirty we will shut the mount down and, in doing so, that
1071 : * guarantees that the log is shut down, too. Hence we don't need to be as
1072 : * careful with shutdown state and dirty items here as we need to be in
1073 : * xfs_trans_commit().
1074 : */
1075 : void
1076 2314958560 : xfs_trans_cancel(
1077 : struct xfs_trans *tp)
1078 : {
1079 2314958560 : struct xfs_mount *mp = tp->t_mountp;
1080 2314958560 : struct xlog *log = mp->m_log;
1081 2314958560 : bool dirty = (tp->t_flags & XFS_TRANS_DIRTY);
1082 :
1083 2314958560 : trace_xfs_trans_cancel(tp, _RET_IP_);
1084 :
1085 : /*
1086 : * It's never valid to cancel a transaction with deferred ops attached,
1087 : * because the transaction is effectively dirty. Complain about this
1088 : * loudly before freeing the in-memory defer items and shutting down the
1089 : * filesystem.
1090 : */
1091 2315919423 : if (!list_empty(&tp->t_dfops)) {
1092 27 : ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
1093 27 : dirty = true;
1094 27 : xfs_defer_cancel(tp);
1095 : }
1096 :
1097 : /*
1098 : * See if the caller is relying on us to shut down the filesystem. We
1099 : * only want an error report if there isn't already a shutdown in
1100 : * progress, so we only need to check against the mount shutdown state
1101 : * here.
1102 : */
1103 2315922763 : if (dirty && !xfs_is_shutdown(mp)) {
1104 5 : XFS_ERROR_REPORT("xfs_trans_cancel", XFS_ERRLEVEL_LOW, mp);
1105 5 : xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
1106 : }
1107 : #ifdef DEBUG
1108 : /* Log items need to be consistent until the log is shut down. */
1109 4631698759 : if (!dirty && !xlog_is_shutdown(log)) {
1110 2315864309 : struct xfs_log_item *lip;
1111 :
1112 2426291623 : list_for_each_entry(lip, &tp->t_items, li_trans)
1113 110427314 : ASSERT(!xlog_item_is_intent_done(lip));
1114 : }
1115 : #endif
1116 2315919423 : xfs_trans_unreserve_and_mod_sb(tp);
1117 2316648894 : xfs_trans_unreserve_and_mod_dquots(tp);
1118 :
1119 2316808804 : if (tp->t_ticket) {
1120 391691465 : xfs_log_ticket_ungrant(log, tp->t_ticket);
1121 391703812 : tp->t_ticket = NULL;
1122 : }
1123 :
1124 2316821151 : xfs_trans_free_items(tp, dirty);
1125 2317533814 : xfs_trans_free(tp);
1126 2317620350 : }
1127 :
1128 : /*
1129 : * Roll from one trans in the sequence of PERMANENT transactions to
1130 : * the next: permanent transactions are only flushed out when
1131 : * committed with xfs_trans_commit(), but we still want as soon
1132 : * as possible to let chunks of it go to the log. So we commit the
1133 : * chunk we've been working on and get a new transaction to continue.
1134 : */
1135 : int
1136 454087558 : xfs_trans_roll(
1137 : struct xfs_trans **tpp)
1138 : {
1139 454087558 : struct xfs_trans *trans = *tpp;
1140 454087558 : struct xfs_trans_res tres;
1141 454087558 : int error;
1142 :
1143 454087558 : trace_xfs_trans_roll(trans, _RET_IP_);
1144 :
1145 : /*
1146 : * Copy the critical parameters from one trans to the next.
1147 : */
1148 454112343 : tres.tr_logres = trans->t_log_res;
1149 454112343 : tres.tr_logcount = trans->t_log_count;
1150 :
1151 454112343 : *tpp = xfs_trans_dup(trans);
1152 :
1153 : /*
1154 : * Commit the current transaction.
1155 : * If this commit failed, then it'd just unlock those items that
1156 : * are not marked ihold. That also means that a filesystem shutdown
1157 : * is in progress. The caller takes the responsibility to cancel
1158 : * the duplicate transaction that gets returned.
1159 : */
1160 454178241 : error = __xfs_trans_commit(trans, true);
1161 454215102 : if (error)
1162 : return error;
1163 :
1164 : /*
1165 : * Reserve space in the log for the next transaction.
1166 : * This also pushes items in the "AIL", the list of logged items,
1167 : * out to disk if they are taking up space at the tail of the log
1168 : * that we want to use. This requires that either nothing be locked
1169 : * across this call, or that anything that is locked be logged in
1170 : * the prior and the next transactions.
1171 : */
1172 454215058 : tres.tr_logflags = XFS_TRANS_PERM_LOG_RES;
1173 454215058 : return xfs_trans_reserve(*tpp, &tres, 0, 0);
1174 : }
1175 :
1176 : /*
1177 : * Allocate an transaction, lock and join the inode to it, and reserve quota.
1178 : *
1179 : * The caller must ensure that the on-disk dquots attached to this inode have
1180 : * already been allocated and initialized. The caller is responsible for
1181 : * releasing ILOCK_EXCL if a new transaction is returned.
1182 : */
1183 : int
1184 293453401 : xfs_trans_alloc_inode(
1185 : struct xfs_inode *ip,
1186 : struct xfs_trans_res *resv,
1187 : unsigned int dblocks,
1188 : unsigned int rblocks,
1189 : bool force,
1190 : struct xfs_trans **tpp)
1191 : {
1192 293453401 : struct xfs_trans *tp;
1193 293453401 : struct xfs_mount *mp = ip->i_mount;
1194 293453401 : bool retried = false;
1195 293453839 : int error;
1196 :
1197 293453839 : retry:
1198 293453839 : error = xfs_trans_alloc(mp, resv, dblocks,
1199 293453839 : rblocks / mp->m_sb.sb_rextsize,
1200 : force ? XFS_TRANS_RESERVE : 0, &tp);
1201 293477751 : if (error)
1202 3158942 : return error;
1203 :
1204 290318809 : xfs_ilock(ip, XFS_ILOCK_EXCL);
1205 290320943 : xfs_trans_ijoin(tp, ip, 0);
1206 :
1207 290294438 : error = xfs_qm_dqattach_locked(ip, false);
1208 290315275 : if (error) {
1209 : /* Caller should have allocated the dquots! */
1210 0 : ASSERT(error != -ENOENT);
1211 0 : goto out_cancel;
1212 : }
1213 :
1214 290315275 : error = xfs_trans_reserve_quota_nblks(tp, ip, dblocks, rblocks, force);
1215 290315221 : if ((error == -EDQUOT || error == -ENOSPC) && !retried) {
1216 438 : xfs_trans_cancel(tp);
1217 438 : xfs_iunlock(ip, XFS_ILOCK_EXCL);
1218 438 : xfs_blockgc_free_quota(ip, 0);
1219 438 : retried = true;
1220 438 : goto retry;
1221 : }
1222 290314783 : if (error)
1223 402 : goto out_cancel;
1224 :
1225 290314381 : *tpp = tp;
1226 290314381 : return 0;
1227 :
1228 402 : out_cancel:
1229 402 : xfs_trans_cancel(tp);
1230 402 : xfs_iunlock(ip, XFS_ILOCK_EXCL);
1231 402 : return error;
1232 : }
1233 :
1234 : /*
1235 : * Allocate an transaction in preparation for inode creation by reserving quota
1236 : * against the given dquots. Callers are not required to hold any inode locks.
1237 : */
1238 : int
1239 48100842 : xfs_trans_alloc_icreate(
1240 : struct xfs_mount *mp,
1241 : struct xfs_trans_res *resv,
1242 : struct xfs_dquot *udqp,
1243 : struct xfs_dquot *gdqp,
1244 : struct xfs_dquot *pdqp,
1245 : unsigned int dblocks,
1246 : struct xfs_trans **tpp)
1247 : {
1248 48100842 : struct xfs_trans *tp;
1249 48100842 : bool retried = false;
1250 48103179 : int error;
1251 :
1252 48103179 : retry:
1253 48103179 : error = xfs_trans_alloc(mp, resv, dblocks, 0, 0, &tp);
1254 48107295 : if (error)
1255 619759 : return error;
1256 :
1257 47487536 : error = xfs_trans_reserve_quota_icreate(tp, udqp, gdqp, pdqp, dblocks);
1258 47486806 : if ((error == -EDQUOT || error == -ENOSPC) && !retried) {
1259 2337 : xfs_trans_cancel(tp);
1260 2337 : xfs_blockgc_free_dquots(mp, udqp, gdqp, pdqp, 0);
1261 2337 : retried = true;
1262 2337 : goto retry;
1263 : }
1264 47484469 : if (error) {
1265 1838 : xfs_trans_cancel(tp);
1266 1838 : return error;
1267 : }
1268 :
1269 47482631 : *tpp = tp;
1270 47482631 : return 0;
1271 : }
1272 :
1273 : /*
1274 : * Allocate an transaction, lock and join the inode to it, and reserve quota
1275 : * in preparation for inode attribute changes that include uid, gid, or prid
1276 : * changes.
1277 : *
1278 : * The caller must ensure that the on-disk dquots attached to this inode have
1279 : * already been allocated and initialized. The ILOCK will be dropped when the
1280 : * transaction is committed or cancelled.
1281 : */
1282 : int
1283 7584012 : xfs_trans_alloc_ichange(
1284 : struct xfs_inode *ip,
1285 : struct xfs_dquot *new_udqp,
1286 : struct xfs_dquot *new_gdqp,
1287 : struct xfs_dquot *new_pdqp,
1288 : bool force,
1289 : struct xfs_trans **tpp)
1290 : {
1291 7584012 : struct xfs_trans *tp;
1292 7584012 : struct xfs_mount *mp = ip->i_mount;
1293 7584012 : struct xfs_dquot *udqp;
1294 7584012 : struct xfs_dquot *gdqp;
1295 7584012 : struct xfs_dquot *pdqp;
1296 7584012 : bool retried = false;
1297 7584014 : int error;
1298 :
1299 7584014 : retry:
1300 7584014 : error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ichange, 0, 0, 0, &tp);
1301 7584146 : if (error)
1302 1 : return error;
1303 :
1304 7584145 : xfs_ilock(ip, XFS_ILOCK_EXCL);
1305 7584038 : xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
1306 :
1307 7584130 : error = xfs_qm_dqattach_locked(ip, false);
1308 7584182 : if (error) {
1309 : /* Caller should have allocated the dquots! */
1310 253 : ASSERT(error != -ENOENT);
1311 253 : goto out_cancel;
1312 : }
1313 :
1314 : /*
1315 : * For each quota type, skip quota reservations if the inode's dquots
1316 : * now match the ones that came from the caller, or the caller didn't
1317 : * pass one in. The inode's dquots can change if we drop the ILOCK to
1318 : * perform a blockgc scan, so we must preserve the caller's arguments.
1319 : */
1320 7583929 : udqp = (new_udqp != ip->i_udquot) ? new_udqp : NULL;
1321 7583929 : gdqp = (new_gdqp != ip->i_gdquot) ? new_gdqp : NULL;
1322 7583929 : pdqp = (new_pdqp != ip->i_pdquot) ? new_pdqp : NULL;
1323 7583929 : if (udqp || gdqp || pdqp) {
1324 3974060 : unsigned int qflags = XFS_QMOPT_RES_REGBLKS;
1325 :
1326 3974060 : if (force)
1327 3839690 : qflags |= XFS_QMOPT_FORCE_RES;
1328 :
1329 : /*
1330 : * Reserve enough quota to handle blocks on disk and reserved
1331 : * for a delayed allocation. We'll actually transfer the
1332 : * delalloc reservation between dquots at chown time, even
1333 : * though that part is only semi-transactional.
1334 : */
1335 3974060 : error = xfs_trans_reserve_quota_bydquots(tp, mp, udqp, gdqp,
1336 3974060 : pdqp, ip->i_nblocks + ip->i_delayed_blks,
1337 : 1, qflags);
1338 3974038 : if ((error == -EDQUOT || error == -ENOSPC) && !retried) {
1339 2 : xfs_trans_cancel(tp);
1340 2 : xfs_blockgc_free_dquots(mp, udqp, gdqp, pdqp, 0);
1341 2 : retried = true;
1342 2 : goto retry;
1343 : }
1344 3974036 : if (error)
1345 2 : goto out_cancel;
1346 : }
1347 :
1348 7583900 : *tpp = tp;
1349 7583900 : return 0;
1350 :
1351 255 : out_cancel:
1352 255 : xfs_trans_cancel(tp);
1353 255 : return error;
1354 : }
1355 :
1356 : /*
1357 : * Allocate an transaction, lock and join the directory and child inodes to it,
1358 : * and reserve quota for a directory update. If there isn't sufficient space,
1359 : * @dblocks will be set to zero for a reservationless directory update and
1360 : * @nospace_error will be set to a negative errno describing the space
1361 : * constraint we hit.
1362 : *
1363 : * The caller must ensure that the on-disk dquots attached to this inode have
1364 : * already been allocated and initialized. The ILOCKs will be dropped when the
1365 : * transaction is committed or cancelled.
1366 : */
1367 : int
1368 38844797 : xfs_trans_alloc_dir(
1369 : struct xfs_inode *dp,
1370 : struct xfs_trans_res *resv,
1371 : struct xfs_inode *ip,
1372 : unsigned int *dblocks,
1373 : struct xfs_trans **tpp,
1374 : int *nospace_error)
1375 : {
1376 38844797 : struct xfs_trans *tp;
1377 38844797 : struct xfs_mount *mp = ip->i_mount;
1378 38844797 : unsigned int resblks;
1379 38844797 : bool retried = false;
1380 38847396 : int error;
1381 :
1382 38847396 : retry:
1383 38847396 : *nospace_error = 0;
1384 38847396 : resblks = *dblocks;
1385 38847396 : error = xfs_trans_alloc(mp, resv, resblks, 0, 0, &tp);
1386 38848435 : if (error == -ENOSPC) {
1387 84969 : *nospace_error = error;
1388 84969 : resblks = 0;
1389 84969 : error = xfs_trans_alloc(mp, resv, resblks, 0, 0, &tp);
1390 : }
1391 38848435 : if (error)
1392 0 : return error;
1393 :
1394 38848435 : xfs_lock_two_inodes(dp, XFS_ILOCK_EXCL, ip, XFS_ILOCK_EXCL);
1395 :
1396 38847823 : xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
1397 38847662 : xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
1398 :
1399 38846530 : error = xfs_qm_dqattach_locked(dp, false);
1400 38848466 : if (error) {
1401 : /* Caller should have allocated the dquots! */
1402 0 : ASSERT(error != -ENOENT);
1403 0 : goto out_cancel;
1404 : }
1405 :
1406 38848466 : error = xfs_qm_dqattach_locked(ip, false);
1407 38846135 : if (error) {
1408 : /* Caller should have allocated the dquots! */
1409 0 : ASSERT(error != -ENOENT);
1410 0 : goto out_cancel;
1411 : }
1412 :
1413 38846135 : if (resblks == 0)
1414 84968 : goto done;
1415 :
1416 38761167 : error = xfs_trans_reserve_quota_nblks(tp, dp, resblks, 0, false);
1417 38762920 : if (error == -EDQUOT || error == -ENOSPC) {
1418 4990 : if (!retried) {
1419 2599 : xfs_trans_cancel(tp);
1420 2599 : xfs_blockgc_free_quota(dp, 0);
1421 2599 : retried = true;
1422 2599 : goto retry;
1423 : }
1424 :
1425 2391 : *nospace_error = error;
1426 2391 : resblks = 0;
1427 2391 : error = 0;
1428 : }
1429 38760321 : if (error)
1430 0 : goto out_cancel;
1431 :
1432 38757930 : done:
1433 38845289 : *tpp = tp;
1434 38845289 : *dblocks = resblks;
1435 38845289 : return 0;
1436 :
1437 0 : out_cancel:
1438 0 : xfs_trans_cancel(tp);
1439 0 : return error;
1440 : }
|
