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 59289 : xfs_trans_trace_reservations(
33 : struct xfs_mount *mp)
34 : {
35 59289 : struct xfs_trans_res *res;
36 59289 : struct xfs_trans_res *end_res;
37 59289 : int i;
38 :
39 59289 : res = (struct xfs_trans_res *)M_RES(mp);
40 59289 : end_res = (struct xfs_trans_res *)(M_RES(mp) + 1);
41 1600803 : for (i = 0; res < end_res; i++, res++)
42 1541514 : trace_xfs_trans_resv_calc(mp, i, res);
43 59289 : }
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 59289 : xfs_trans_init(
54 : struct xfs_mount *mp)
55 : {
56 59289 : xfs_trans_resv_calc(mp, M_RES(mp));
57 59289 : xfs_trans_trace_reservations(mp);
58 59289 : }
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 4483819298 : xfs_trans_free(
66 : struct xfs_trans *tp)
67 : {
68 4483819298 : xfs_extent_busy_sort(&tp->t_busy);
69 4482625351 : xfs_extent_busy_clear(tp->t_mountp, &tp->t_busy, false);
70 :
71 4482320345 : trace_xfs_trans_free(tp, _RET_IP_);
72 4482537993 : xfs_trans_clear_context(tp);
73 4479748402 : if (!(tp->t_flags & XFS_TRANS_NO_WRITECOUNT))
74 1347134002 : sb_end_intwrite(tp->t_mountp->m_super);
75 4480261377 : xfs_trans_free_dqinfo(tp);
76 4480164207 : kmem_cache_free(xfs_trans_cache, tp);
77 4485085747 : }
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 891383605 : xfs_trans_dup(
89 : struct xfs_trans *tp)
90 : {
91 891383605 : struct xfs_trans *ntp;
92 :
93 891383605 : trace_xfs_trans_dup(tp, _RET_IP_);
94 :
95 891336769 : ntp = kmem_cache_zalloc(xfs_trans_cache, GFP_KERNEL | __GFP_NOFAIL);
96 :
97 : /*
98 : * Initialize the new transaction structure.
99 : */
100 891485001 : ntp->t_magic = XFS_TRANS_HEADER_MAGIC;
101 891485001 : ntp->t_mountp = tp->t_mountp;
102 891485001 : INIT_LIST_HEAD(&ntp->t_items);
103 891485001 : INIT_LIST_HEAD(&ntp->t_busy);
104 891485001 : INIT_LIST_HEAD(&ntp->t_dfops);
105 891485001 : ntp->t_highest_agno = NULLAGNUMBER;
106 :
107 891485001 : ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
108 891485001 : ASSERT(tp->t_ticket != NULL);
109 :
110 891485001 : ntp->t_flags = XFS_TRANS_PERM_LOG_RES |
111 891485001 : (tp->t_flags & XFS_TRANS_RESERVE) |
112 891485001 : (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 891485001 : tp->t_flags |= XFS_TRANS_NO_WRITECOUNT;
116 891485001 : ntp->t_ticket = xfs_log_ticket_get(tp->t_ticket);
117 :
118 891582027 : ASSERT(tp->t_blk_res >= tp->t_blk_res_used);
119 891582027 : ntp->t_blk_res = tp->t_blk_res - tp->t_blk_res_used;
120 891582027 : tp->t_blk_res = tp->t_blk_res_used;
121 :
122 891582027 : ntp->t_rtx_res = tp->t_rtx_res - tp->t_rtx_res_used;
123 891582027 : tp->t_rtx_res = tp->t_rtx_res_used;
124 :
125 891582027 : xfs_trans_switch_context(tp, ntp);
126 :
127 : /* move deferred ops over to the new tp */
128 891497331 : xfs_defer_move(ntp, tp);
129 :
130 891452923 : xfs_trans_dup_dqinfo(tp, ntp);
131 891423460 : 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 4489329131 : xfs_trans_reserve(
150 : struct xfs_trans *tp,
151 : struct xfs_trans_res *resp,
152 : uint blocks,
153 : uint rtextents)
154 : {
155 4489329131 : struct xfs_mount *mp = tp->t_mountp;
156 4489329131 : int error = 0;
157 4489329131 : 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 4489329131 : if (blocks > 0) {
165 727195805 : error = xfs_mod_fdblocks(mp, -((int64_t)blocks), rsvd);
166 726078553 : if (error != 0)
167 : return -ENOSPC;
168 713941015 : tp->t_blk_res += blocks;
169 : }
170 :
171 : /*
172 : * Reserve the log space needed for this transaction.
173 : */
174 4476074341 : if (resp->tr_logres > 0) {
175 2226691902 : bool permanent = false;
176 :
177 2226691902 : ASSERT(tp->t_log_res == 0 ||
178 : tp->t_log_res == resp->tr_logres);
179 2226691902 : ASSERT(tp->t_log_count == 0 ||
180 : tp->t_log_count == resp->tr_logcount);
181 :
182 2226691902 : if (resp->tr_logflags & XFS_TRANS_PERM_LOG_RES) {
183 2065525204 : tp->t_flags |= XFS_TRANS_PERM_LOG_RES;
184 2065525204 : permanent = true;
185 : } else {
186 161166698 : ASSERT(tp->t_ticket == NULL);
187 161166698 : ASSERT(!(tp->t_flags & XFS_TRANS_PERM_LOG_RES));
188 : }
189 :
190 2226691902 : if (tp->t_ticket != NULL) {
191 892145384 : ASSERT(resp->tr_logflags & XFS_TRANS_PERM_LOG_RES);
192 892145384 : error = xfs_log_regrant(mp, tp->t_ticket);
193 : } else {
194 1334546518 : error = xfs_log_reserve(mp, resp->tr_logres,
195 : resp->tr_logcount,
196 : &tp->t_ticket, permanent);
197 : }
198 :
199 2227881997 : if (error)
200 2619 : goto undo_blocks;
201 :
202 2227879378 : tp->t_log_res = resp->tr_logres;
203 2227879378 : 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 4477261817 : if (rtextents > 0) {
212 70027526 : error = xfs_mod_frextents(mp, -((int64_t)rtextents));
213 70094687 : if (error) {
214 12620214 : error = -ENOSPC;
215 12620214 : goto undo_log;
216 : }
217 57474473 : 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 12620214 : if (resp->tr_logres > 0) {
228 12620214 : xfs_log_ticket_ungrant(mp->m_log, tp->t_ticket);
229 12613889 : tp->t_ticket = NULL;
230 12613889 : tp->t_log_res = 0;
231 12613889 : tp->t_flags &= ~XFS_TRANS_PERM_LOG_RES;
232 : }
233 :
234 0 : undo_blocks:
235 12616508 : if (blocks > 0) {
236 12613997 : xfs_mod_fdblocks(mp, (int64_t)blocks, rsvd);
237 12607620 : tp->t_blk_res = 0;
238 : }
239 : return error;
240 : }
241 :
242 : int
243 3576476670 : 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 3576476670 : struct xfs_trans *tp;
252 3576476670 : bool want_retry = true;
253 3588909111 : 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 3588909111 : retry:
261 3588909111 : tp = kmem_cache_zalloc(xfs_trans_cache, GFP_KERNEL | __GFP_NOFAIL);
262 3590829234 : if (!(flags & XFS_TRANS_NO_WRITECOUNT))
263 1347325267 : sb_start_intwrite(mp->m_super);
264 3589702487 : 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 7177176388 : WARN_ON(resp->tr_logres > 0 &&
271 : mp->m_super->s_writers.frozen == SB_FREEZE_COMPLETE);
272 3588588194 : ASSERT(!(flags & XFS_TRANS_RES_FDBLKS) ||
273 : xfs_has_lazysbcount(mp));
274 :
275 3588588194 : tp->t_magic = XFS_TRANS_HEADER_MAGIC;
276 3588588194 : tp->t_flags = flags;
277 3588588194 : tp->t_mountp = mp;
278 3588588194 : INIT_LIST_HEAD(&tp->t_items);
279 3588588194 : INIT_LIST_HEAD(&tp->t_busy);
280 3588588194 : INIT_LIST_HEAD(&tp->t_dfops);
281 3588588194 : tp->t_highest_agno = NULLAGNUMBER;
282 :
283 3588588194 : error = xfs_trans_reserve(tp, resp, blocks, rtextents);
284 3591372595 : if (error == -ENOSPC && want_retry) {
285 12413297 : 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 12276567 : error = xfs_blockgc_flush_all(mp);
294 12432441 : if (error)
295 0 : return error;
296 12432441 : want_retry = false;
297 12432441 : goto retry;
298 : }
299 3578959298 : if (error) {
300 12329828 : xfs_trans_cancel(tp);
301 12329828 : return error;
302 : }
303 :
304 3566629470 : trace_xfs_trans_alloc(tp, _RET_IP_);
305 :
306 3560674949 : *tpp = tp;
307 3560674949 : 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 2243502842 : xfs_trans_alloc_empty(
328 : struct xfs_mount *mp,
329 : struct xfs_trans **tpp)
330 : {
331 2243502842 : struct xfs_trans_res resv = {0};
332 :
333 2243502842 : 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 377297330 : xfs_trans_mod_sb(
354 : xfs_trans_t *tp,
355 : uint field,
356 : int64_t delta)
357 : {
358 377297330 : uint32_t flags = (XFS_TRANS_DIRTY|XFS_TRANS_SB_DIRTY);
359 377297330 : xfs_mount_t *mp = tp->t_mountp;
360 :
361 377297330 : switch (field) {
362 1363377 : case XFS_TRANS_SB_ICOUNT:
363 1363377 : tp->t_icount_delta += delta;
364 1363377 : if (xfs_has_lazysbcount(mp))
365 1363267 : flags &= ~XFS_TRANS_SB_DIRTY;
366 : break;
367 143453308 : case XFS_TRANS_SB_IFREE:
368 143453308 : tp->t_ifree_delta += delta;
369 143453308 : if (xfs_has_lazysbcount(mp))
370 143113966 : flags &= ~XFS_TRANS_SB_DIRTY;
371 : break;
372 122256225 : 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 122256225 : if (delta < 0) {
379 43337417 : tp->t_blk_res_used += (uint)-delta;
380 43337417 : if (tp->t_blk_res_used > tp->t_blk_res)
381 0 : xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
382 78918808 : } else if (delta > 0 && (tp->t_flags & XFS_TRANS_RES_FDBLKS)) {
383 7366 : 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 7366 : blkres_delta = min_t(int64_t, delta,
393 : UINT_MAX - tp->t_blk_res);
394 7366 : tp->t_blk_res += blkres_delta;
395 7366 : delta -= blkres_delta;
396 : }
397 122256225 : tp->t_fdblocks_delta += delta;
398 122256225 : if (xfs_has_lazysbcount(mp))
399 122238835 : flags &= ~XFS_TRANS_SB_DIRTY;
400 : break;
401 23248657 : 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 23248657 : tp->t_res_fdblocks_delta += delta;
408 23248657 : if (xfs_has_lazysbcount(mp))
409 23248541 : flags &= ~XFS_TRANS_SB_DIRTY;
410 : break;
411 86973517 : 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 86973517 : if (delta < 0) {
418 53331259 : tp->t_rtx_res_used += (uint)-delta;
419 53331259 : ASSERT(tp->t_rtx_res_used <= tp->t_rtx_res);
420 : }
421 86973517 : tp->t_frextents_delta += delta;
422 86973517 : 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 750 : case XFS_TRANS_SB_DBLOCKS:
433 750 : tp->t_dblocks_delta += delta;
434 750 : break;
435 453 : case XFS_TRANS_SB_AGCOUNT:
436 453 : ASSERT(delta > 0);
437 453 : tp->t_agcount_delta += delta;
438 453 : break;
439 0 : case XFS_TRANS_SB_IMAXPCT:
440 0 : tp->t_imaxpct_delta += delta;
441 0 : break;
442 3 : case XFS_TRANS_SB_REXTSIZE:
443 3 : tp->t_rextsize_delta += delta;
444 3 : break;
445 311 : case XFS_TRANS_SB_RBMBLOCKS:
446 311 : tp->t_rbmblocks_delta += delta;
447 311 : break;
448 342 : case XFS_TRANS_SB_RBLOCKS:
449 342 : tp->t_rblocks_delta += delta;
450 342 : break;
451 342 : case XFS_TRANS_SB_REXTENTS:
452 342 : tp->t_rextents_delta += delta;
453 342 : break;
454 45 : case XFS_TRANS_SB_REXTSLOG:
455 45 : tp->t_rextslog_delta += delta;
456 45 : break;
457 0 : default:
458 0 : ASSERT(0);
459 0 : return;
460 : }
461 :
462 377297330 : 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 81247437 : xfs_trans_apply_sb_deltas(
475 : xfs_trans_t *tp)
476 : {
477 81247437 : struct xfs_dsb *sbp;
478 81247437 : struct xfs_buf *bp;
479 81247437 : int whole = 0;
480 :
481 81247437 : bp = xfs_trans_getsb(tp);
482 81247437 : sbp = bp->b_addr;
483 :
484 : /*
485 : * Only update the superblock counters if we are logging them
486 : */
487 81247437 : if (!xfs_has_lazysbcount((tp->t_mountp))) {
488 1131 : if (tp->t_icount_delta)
489 11 : be64_add_cpu(&sbp->sb_icount, tp->t_icount_delta);
490 1131 : if (tp->t_ifree_delta)
491 1121 : be64_add_cpu(&sbp->sb_ifree, tp->t_ifree_delta);
492 1131 : if (tp->t_fdblocks_delta)
493 32 : be64_add_cpu(&sbp->sb_fdblocks, tp->t_fdblocks_delta);
494 1131 : 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 81247437 : if (tp->t_frextents_delta || tp->t_res_frextents_delta) {
513 81245556 : struct xfs_mount *mp = tp->t_mountp;
514 81245556 : int64_t rtxdelta;
515 :
516 81245556 : rtxdelta = tp->t_frextents_delta + tp->t_res_frextents_delta;
517 :
518 81245556 : spin_lock(&mp->m_sb_lock);
519 81245556 : be64_add_cpu(&sbp->sb_frextents, rtxdelta);
520 81245556 : mp->m_sb.sb_frextents += rtxdelta;
521 81245556 : spin_unlock(&mp->m_sb_lock);
522 : }
523 :
524 81247437 : if (tp->t_dblocks_delta) {
525 750 : be64_add_cpu(&sbp->sb_dblocks, tp->t_dblocks_delta);
526 750 : whole = 1;
527 : }
528 81247437 : if (tp->t_agcount_delta) {
529 453 : be32_add_cpu(&sbp->sb_agcount, tp->t_agcount_delta);
530 453 : whole = 1;
531 : }
532 81247437 : if (tp->t_imaxpct_delta) {
533 0 : sbp->sb_imax_pct += tp->t_imaxpct_delta;
534 0 : whole = 1;
535 : }
536 81247437 : if (tp->t_rextsize_delta) {
537 3 : be32_add_cpu(&sbp->sb_rextsize, tp->t_rextsize_delta);
538 3 : whole = 1;
539 : }
540 81247437 : if (tp->t_rbmblocks_delta) {
541 311 : be32_add_cpu(&sbp->sb_rbmblocks, tp->t_rbmblocks_delta);
542 311 : whole = 1;
543 : }
544 81247437 : if (tp->t_rblocks_delta) {
545 342 : be64_add_cpu(&sbp->sb_rblocks, tp->t_rblocks_delta);
546 342 : whole = 1;
547 : }
548 81247437 : if (tp->t_rextents_delta) {
549 342 : be64_add_cpu(&sbp->sb_rextents, tp->t_rextents_delta);
550 342 : whole = 1;
551 : }
552 81247437 : if (tp->t_rextslog_delta) {
553 45 : sbp->sb_rextslog += tp->t_rextslog_delta;
554 45 : whole = 1;
555 : }
556 :
557 81247437 : xfs_trans_buf_set_type(tp, bp, XFS_BLFT_SB_BUF);
558 81247437 : if (whole)
559 : /*
560 : * Log the whole thing, the fields are noncontiguous.
561 : */
562 1092 : 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 81246345 : 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 81247437 : }
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 4482411675 : xfs_trans_unreserve_and_mod_sb(
592 : struct xfs_trans *tp)
593 : {
594 4482411675 : struct xfs_mount *mp = tp->t_mountp;
595 4482411675 : bool rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0;
596 4482411675 : int64_t blkdelta = 0;
597 4482411675 : int64_t rtxdelta = 0;
598 4482411675 : int64_t idelta = 0;
599 4482411675 : int64_t ifreedelta = 0;
600 4482411675 : int error;
601 :
602 : /* calculate deltas */
603 4482411675 : if (tp->t_blk_res > 0)
604 : blkdelta = tp->t_blk_res;
605 4482411675 : if ((tp->t_fdblocks_delta != 0) &&
606 32 : (xfs_has_lazysbcount(mp) ||
607 32 : (tp->t_flags & XFS_TRANS_SB_DIRTY)))
608 115694952 : blkdelta += tp->t_fdblocks_delta;
609 :
610 4482411675 : if (tp->t_rtx_res > 0)
611 : rtxdelta = tp->t_rtx_res;
612 4482411675 : if ((tp->t_frextents_delta != 0) &&
613 81245556 : (tp->t_flags & XFS_TRANS_SB_DIRTY))
614 81245556 : rtxdelta += tp->t_frextents_delta;
615 :
616 4482411675 : if (xfs_has_lazysbcount(mp) ||
617 2403 : (tp->t_flags & XFS_TRANS_SB_DIRTY)) {
618 4482410403 : idelta = tp->t_icount_delta;
619 4482410403 : ifreedelta = tp->t_ifree_delta;
620 : }
621 :
622 : /* apply the per-cpu counters */
623 4482411675 : if (blkdelta) {
624 748194164 : error = xfs_mod_fdblocks(mp, blkdelta, rsvd);
625 748158102 : ASSERT(!error);
626 : }
627 :
628 4482375613 : if (idelta)
629 1363307 : percpu_counter_add_batch(&mp->m_icount, idelta,
630 : XFS_ICOUNT_BATCH);
631 :
632 4482375788 : if (ifreedelta)
633 143716663 : percpu_counter_add(&mp->m_ifree, ifreedelta);
634 :
635 4482384413 : if (rtxdelta) {
636 35790871 : error = xfs_mod_frextents(mp, rtxdelta);
637 35790876 : ASSERT(!error);
638 : }
639 :
640 4482384418 : if (!(tp->t_flags & XFS_TRANS_SB_DIRTY))
641 : return;
642 :
643 : /* apply remaining deltas */
644 81247437 : spin_lock(&mp->m_sb_lock);
645 81247437 : mp->m_sb.sb_fdblocks += tp->t_fdblocks_delta + tp->t_res_fdblocks_delta;
646 81247437 : mp->m_sb.sb_icount += idelta;
647 81247437 : 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 81247437 : mp->m_sb.sb_dblocks += tp->t_dblocks_delta;
655 81247437 : mp->m_sb.sb_agcount += tp->t_agcount_delta;
656 81247437 : mp->m_sb.sb_imax_pct += tp->t_imaxpct_delta;
657 81247437 : mp->m_sb.sb_rextsize += tp->t_rextsize_delta;
658 81247437 : mp->m_sb.sb_rbmblocks += tp->t_rbmblocks_delta;
659 81247437 : mp->m_sb.sb_rblocks += tp->t_rblocks_delta;
660 81247437 : mp->m_sb.sb_rextents += tp->t_rextents_delta;
661 81247437 : mp->m_sb.sb_rextslog += tp->t_rextslog_delta;
662 81247437 : 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 25001667291 : xfs_trans_add_item(
676 : struct xfs_trans *tp,
677 : struct xfs_log_item *lip)
678 : {
679 25001667291 : ASSERT(lip->li_log == tp->t_mountp->m_log);
680 25001667291 : ASSERT(lip->li_ailp == tp->t_mountp->m_ail);
681 25001667291 : ASSERT(list_empty(&lip->li_trans));
682 25001667291 : ASSERT(!test_bit(XFS_LI_DIRTY, &lip->li_flags));
683 :
684 25001667291 : list_add_tail(&lip->li_trans, &tp->t_items);
685 24986686153 : trace_xfs_trans_add_item(tp, _RET_IP_);
686 24977868718 : }
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 24943129909 : xfs_trans_del_item(
695 : struct xfs_log_item *lip)
696 : {
697 24943129909 : clear_bit(XFS_LI_DIRTY, &lip->li_flags);
698 24962940076 : list_del_init(&lip->li_trans);
699 24957084576 : }
700 :
701 : /* Detach and unlock all of the items in a transaction */
702 : static void
703 2744575540 : xfs_trans_free_items(
704 : struct xfs_trans *tp,
705 : bool abort)
706 : {
707 2744575540 : struct xfs_log_item *lip, *next;
708 :
709 2744575540 : trace_xfs_trans_free_items(tp, _RET_IP_);
710 :
711 2898072367 : list_for_each_entry_safe(lip, next, &tp->t_items, li_trans) {
712 153600604 : xfs_trans_del_item(lip);
713 154086239 : if (abort)
714 26507 : set_bit(XFS_LI_ABORTED, &lip->li_flags);
715 154086239 : if (lip->li_ops->iop_release)
716 154086239 : lip->li_ops->iop_release(lip);
717 : }
718 2744471763 : }
719 :
720 : static inline void
721 23181670 : 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 23181670 : int i;
729 :
730 23181670 : spin_lock(&ailp->ail_lock);
731 : /* xfs_trans_ail_update_bulk drops ailp->ail_lock */
732 23181670 : xfs_trans_ail_update_bulk(ailp, cur, log_items, nr_items, commit_lsn);
733 :
734 677773320 : for (i = 0; i < nr_items; i++) {
735 631409980 : struct xfs_log_item *lip = log_items[i];
736 :
737 631409980 : if (lip->li_ops->iop_unpin)
738 631409980 : lip->li_ops->iop_unpin(lip, 0);
739 : }
740 23181670 : }
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 5106030 : 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 5106030 : struct xfs_log_item *log_items[LOG_ITEM_BATCH_SIZE];
771 5106030 : struct xfs_log_vec *lv;
772 5106030 : struct xfs_ail_cursor cur;
773 5106030 : int i = 0;
774 :
775 5106030 : spin_lock(&ailp->ail_lock);
776 5106030 : xfs_trans_ail_cursor_last(ailp, &cur, commit_lsn);
777 5106030 : spin_unlock(&ailp->ail_lock);
778 :
779 : /* unpin all the log items */
780 655946073 : list_for_each_entry(lv, lv_chain, lv_list) {
781 650840043 : struct xfs_log_item *lip = lv->lv_item;
782 650840043 : xfs_lsn_t item_lsn;
783 :
784 650840043 : if (aborted)
785 1466469 : set_bit(XFS_LI_ABORTED, &lip->li_flags);
786 :
787 650840044 : if (lip->li_ops->flags & XFS_ITEM_RELEASE_WHEN_COMMITTED) {
788 2023103 : lip->li_ops->iop_release(lip);
789 2023103 : continue;
790 : }
791 :
792 648816941 : if (lip->li_ops->iop_committed)
793 611792172 : 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 648816939 : if (XFS_LSN_CMP(item_lsn, (xfs_lsn_t)-1) == 0)
799 15673307 : 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 633143632 : if (aborted) {
806 2881786 : ASSERT(xlog_is_shutdown(ailp->ail_log));
807 1440893 : if (lip->li_ops->iop_unpin)
808 1440893 : lip->li_ops->iop_unpin(lip, 1);
809 1440894 : continue;
810 : }
811 :
812 631702739 : 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 292759 : spin_lock(&ailp->ail_lock);
822 292759 : if (XFS_LSN_CMP(item_lsn, lip->li_lsn) > 0)
823 0 : xfs_trans_ail_update(ailp, lip, item_lsn);
824 : else
825 292759 : spin_unlock(&ailp->ail_lock);
826 292759 : if (lip->li_ops->iop_unpin)
827 292759 : lip->li_ops->iop_unpin(lip, 0);
828 292759 : continue;
829 : }
830 :
831 : /* Item is a candidate for bulk AIL insert. */
832 631409980 : log_items[i++] = lv->lv_item;
833 631409980 : if (i >= LOG_ITEM_BATCH_SIZE) {
834 18144762 : xfs_log_item_batch_insert(ailp, &cur, log_items,
835 : LOG_ITEM_BATCH_SIZE, commit_lsn);
836 18144762 : i = 0;
837 : }
838 : }
839 :
840 : /* make sure we insert the remainder! */
841 5106030 : if (i)
842 5036908 : xfs_log_item_batch_insert(ailp, &cur, log_items, i, commit_lsn);
843 :
844 5106030 : spin_lock(&ailp->ail_lock);
845 5106030 : xfs_trans_ail_cursor_done(&cur);
846 5106030 : spin_unlock(&ailp->ail_lock);
847 5106030 : }
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 10991207236 : xfs_trans_precommit_sort(
862 : void *unused_arg,
863 : const struct list_head *a,
864 : const struct list_head *b)
865 : {
866 10991207236 : struct xfs_log_item *lia = container_of(a,
867 : struct xfs_log_item, li_trans);
868 10991207236 : struct xfs_log_item *lib = container_of(b,
869 : struct xfs_log_item, li_trans);
870 10991207236 : 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 10991207236 : if (!lia->li_ops->iop_sort && !lib->li_ops->iop_sort)
877 : return 0;
878 5455494503 : if (!lia->li_ops->iop_sort)
879 : return 1;
880 5186851732 : if (!lib->li_ops->iop_sort)
881 : return -1;
882 :
883 1107878228 : diff = lia->li_ops->iop_sort(lia) - lib->li_ops->iop_sort(lib);
884 1108099204 : if (diff < 0)
885 : return -1;
886 359972247 : if (diff > 0)
887 318558239 : 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 2469749945 : xfs_trans_run_precommits(
900 : struct xfs_trans *tp)
901 : {
902 2469749945 : struct xfs_mount *mp = tp->t_mountp;
903 2469749945 : struct xfs_log_item *lip, *n;
904 2469749945 : 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 2469749945 : 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 11824393201 : list_for_each_entry_safe(lip, n, &tp->t_items, li_trans) {
920 9353063482 : if (!test_bit(XFS_LI_DIRTY, &lip->li_flags))
921 1333960737 : continue;
922 8019102745 : if (lip->li_ops->iop_precommit) {
923 2691166736 : error = lip->li_ops->iop_precommit(tp, lip);
924 2691821646 : if (error)
925 : break;
926 : }
927 : }
928 2471330052 : if (error)
929 333 : xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
930 2471330052 : 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 1755707118 : __xfs_trans_commit(
947 : struct xfs_trans *tp,
948 : bool regrant)
949 : {
950 1755707118 : struct xfs_mount *mp = tp->t_mountp;
951 1755707118 : struct xlog *log = mp->m_log;
952 1755707118 : xfs_csn_t commit_seq = 0;
953 1755707118 : int error = 0;
954 1755707118 : int sync = tp->t_flags & XFS_TRANS_SYNC;
955 :
956 1755707118 : trace_xfs_trans_commit(tp, _RET_IP_);
957 :
958 1754846999 : error = xfs_trans_run_precommits(tp);
959 1755237489 : if (error) {
960 333 : if (tp->t_flags & XFS_TRANS_PERM_LOG_RES)
961 325 : xfs_defer_cancel(tp);
962 333 : goto out_unreserve;
963 : }
964 :
965 : /*
966 : * Finish deferred items on final commit. Only permanent transactions
967 : * should ever have deferred ops.
968 : */
969 3510968700 : WARN_ON_ONCE(!list_empty(&tp->t_dfops) &&
970 : !(tp->t_flags & XFS_TRANS_PERM_LOG_RES));
971 1755237156 : if (!regrant && (tp->t_flags & XFS_TRANS_PERM_LOG_RES)) {
972 715114127 : error = xfs_defer_finish_noroll(&tp);
973 714484997 : if (error)
974 3147 : goto out_unreserve;
975 :
976 : /* Run precommits from final tx in defer chain. */
977 714481850 : error = xfs_trans_run_precommits(tp);
978 715544165 : 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 1755667194 : if (!(tp->t_flags & XFS_TRANS_DIRTY))
990 16964221 : 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 3477405946 : if (xlog_is_shutdown(log)) {
999 470 : error = -EIO;
1000 470 : goto out_unreserve;
1001 : }
1002 :
1003 1738702503 : ASSERT(tp->t_ticket != NULL);
1004 :
1005 : /*
1006 : * If we need to update the superblock, then do it now.
1007 : */
1008 1738702503 : if (tp->t_flags & XFS_TRANS_SB_DIRTY)
1009 81247437 : xfs_trans_apply_sb_deltas(tp);
1010 1738702503 : xfs_trans_apply_dquot_deltas(tp);
1011 :
1012 1738569935 : xlog_cil_commit(log, tp, &commit_seq, regrant);
1013 :
1014 1739418986 : 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 1739019092 : if (sync) {
1021 206746 : error = xfs_log_force_seq(mp, commit_seq, XFS_LOG_SYNC, NULL);
1022 206746 : XFS_STATS_INC(mp, xs_trans_sync);
1023 : } else {
1024 1738812346 : XFS_STATS_INC(mp, xs_trans_async);
1025 : }
1026 :
1027 : return error;
1028 :
1029 16968171 : out_unreserve:
1030 16968171 : 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 16968133 : xfs_trans_unreserve_and_mod_dquots(tp);
1038 16965061 : if (tp->t_ticket) {
1039 16955126 : if (regrant && !xlog_is_shutdown(log))
1040 902 : xfs_log_ticket_regrant(log, tp->t_ticket);
1041 : else
1042 16953165 : xfs_log_ticket_ungrant(log, tp->t_ticket);
1043 16958207 : tp->t_ticket = NULL;
1044 : }
1045 16969201 : xfs_trans_free_items(tp, !!error);
1046 16966621 : xfs_trans_free(tp);
1047 :
1048 16968550 : XFS_STATS_INC(mp, xs_trans_empty);
1049 16969881 : return error;
1050 : }
1051 :
1052 : int
1053 864551396 : xfs_trans_commit(
1054 : struct xfs_trans *tp)
1055 : {
1056 864551396 : 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 2728905100 : xfs_trans_cancel(
1077 : struct xfs_trans *tp)
1078 : {
1079 2728905100 : struct xfs_mount *mp = tp->t_mountp;
1080 2728905100 : struct xlog *log = mp->m_log;
1081 2728905100 : bool dirty = (tp->t_flags & XFS_TRANS_DIRTY);
1082 :
1083 2728905100 : 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 2724986577 : if (!list_empty(&tp->t_dfops)) {
1092 40 : ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
1093 40 : dirty = true;
1094 40 : 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 2724990613 : if (dirty && !xfs_is_shutdown(mp)) {
1104 19 : XFS_ERROR_REPORT("xfs_trans_cancel", XFS_ERRLEVEL_LOW, mp);
1105 19 : 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 5450762238 : if (!dirty && !xlog_is_shutdown(log)) {
1110 2725839199 : struct xfs_log_item *lip;
1111 :
1112 2861107756 : list_for_each_entry(lip, &tp->t_items, li_trans)
1113 135268557 : ASSERT(!xlog_item_is_intent_done(lip));
1114 : }
1115 : #endif
1116 2724986577 : xfs_trans_unreserve_and_mod_sb(tp);
1117 2727153491 : xfs_trans_unreserve_and_mod_dquots(tp);
1118 :
1119 2727613132 : if (tp->t_ticket) {
1120 458587823 : xfs_log_ticket_ungrant(log, tp->t_ticket);
1121 459059376 : tp->t_ticket = NULL;
1122 : }
1123 :
1124 2728084685 : xfs_trans_free_items(tp, dirty);
1125 2727677370 : xfs_trans_free(tp);
1126 2729915125 : }
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 891400860 : xfs_trans_roll(
1137 : struct xfs_trans **tpp)
1138 : {
1139 891400860 : struct xfs_trans *trans = *tpp;
1140 891400860 : struct xfs_trans_res tres;
1141 891400860 : int error;
1142 :
1143 891400860 : trace_xfs_trans_roll(trans, _RET_IP_);
1144 :
1145 : /*
1146 : * Copy the critical parameters from one trans to the next.
1147 : */
1148 891357953 : tres.tr_logres = trans->t_log_res;
1149 891357953 : tres.tr_logcount = trans->t_log_count;
1150 :
1151 891357953 : *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 891422293 : error = __xfs_trans_commit(trans, true);
1161 891576703 : 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 891576094 : tres.tr_logflags = XFS_TRANS_PERM_LOG_RES;
1173 891576094 : 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 500869805 : 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 500869805 : struct xfs_trans *tp;
1193 500869805 : struct xfs_mount *mp = ip->i_mount;
1194 500869805 : bool retried = false;
1195 500871769 : int error;
1196 :
1197 500871769 : retry:
1198 500871769 : error = xfs_trans_alloc(mp, resv, dblocks,
1199 500871769 : rblocks / mp->m_sb.sb_rextsize,
1200 : force ? XFS_TRANS_RESERVE : 0, &tp);
1201 500812565 : if (error)
1202 10813972 : return error;
1203 :
1204 489998593 : xfs_ilock(ip, XFS_ILOCK_EXCL);
1205 490091140 : xfs_trans_ijoin(tp, ip, 0);
1206 :
1207 490095392 : error = xfs_qm_dqattach_locked(ip, false);
1208 490089372 : if (error) {
1209 : /* Caller should have allocated the dquots! */
1210 4 : ASSERT(error != -ENOENT);
1211 4 : goto out_cancel;
1212 : }
1213 :
1214 490089368 : error = xfs_trans_reserve_quota_nblks(tp, ip, dblocks, rblocks, force);
1215 490074444 : if ((error == -EDQUOT || error == -ENOSPC) && !retried) {
1216 1964 : xfs_trans_cancel(tp);
1217 1964 : xfs_iunlock(ip, XFS_ILOCK_EXCL);
1218 1964 : xfs_blockgc_free_quota(ip, 0);
1219 1964 : retried = true;
1220 1964 : goto retry;
1221 : }
1222 490072480 : if (error)
1223 1842 : goto out_cancel;
1224 :
1225 490070638 : *tpp = tp;
1226 490070638 : return 0;
1227 :
1228 1846 : out_cancel:
1229 1846 : xfs_trans_cancel(tp);
1230 1846 : xfs_iunlock(ip, XFS_ILOCK_EXCL);
1231 1846 : 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 85638979 : 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 85638979 : struct xfs_trans *tp;
1249 85638979 : bool retried = false;
1250 85649926 : int error;
1251 :
1252 85649926 : retry:
1253 85649926 : error = xfs_trans_alloc(mp, resv, dblocks, 0, 0, &tp);
1254 85355471 : if (error)
1255 964064 : return error;
1256 :
1257 84391407 : error = xfs_trans_reserve_quota_icreate(tp, udqp, gdqp, pdqp, dblocks);
1258 84854795 : if ((error == -EDQUOT || error == -ENOSPC) && !retried) {
1259 10947 : xfs_trans_cancel(tp);
1260 10945 : xfs_blockgc_free_dquots(mp, udqp, gdqp, pdqp, 0);
1261 10947 : retried = true;
1262 10947 : goto retry;
1263 : }
1264 84843848 : if (error) {
1265 10140 : xfs_trans_cancel(tp);
1266 10140 : return error;
1267 : }
1268 :
1269 84833708 : *tpp = tp;
1270 84833708 : 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 29540655 : 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 29540655 : struct xfs_trans *tp;
1292 29540655 : struct xfs_mount *mp = ip->i_mount;
1293 29540655 : struct xfs_dquot *udqp;
1294 29540655 : struct xfs_dquot *gdqp;
1295 29540655 : struct xfs_dquot *pdqp;
1296 29540655 : bool retried = false;
1297 29540661 : int error;
1298 :
1299 29540661 : retry:
1300 29540661 : error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ichange, 0, 0, 0, &tp);
1301 29525785 : if (error)
1302 1 : return error;
1303 :
1304 29525784 : xfs_ilock(ip, XFS_ILOCK_EXCL);
1305 29534037 : xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
1306 :
1307 29520771 : error = xfs_qm_dqattach_locked(ip, false);
1308 29485781 : if (error) {
1309 : /* Caller should have allocated the dquots! */
1310 279 : ASSERT(error != -ENOENT);
1311 279 : 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 29485502 : udqp = (new_udqp != ip->i_udquot) ? new_udqp : NULL;
1321 29485502 : gdqp = (new_gdqp != ip->i_gdquot) ? new_gdqp : NULL;
1322 29485502 : pdqp = (new_pdqp != ip->i_pdquot) ? new_pdqp : NULL;
1323 29485502 : if (udqp || gdqp || pdqp) {
1324 7504148 : unsigned int qflags = XFS_QMOPT_RES_REGBLKS;
1325 :
1326 7504148 : if (force)
1327 7178239 : 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 7504148 : error = xfs_trans_reserve_quota_bydquots(tp, mp, udqp, gdqp,
1336 7504148 : pdqp, ip->i_nblocks + ip->i_delayed_blks,
1337 : 1, qflags);
1338 7549808 : if ((error == -EDQUOT || error == -ENOSPC) && !retried) {
1339 6 : xfs_trans_cancel(tp);
1340 6 : xfs_blockgc_free_dquots(mp, udqp, gdqp, pdqp, 0);
1341 6 : retried = true;
1342 6 : goto retry;
1343 : }
1344 7549802 : if (error)
1345 6 : goto out_cancel;
1346 : }
1347 :
1348 29531150 : *tpp = tp;
1349 29531150 : return 0;
1350 :
1351 285 : out_cancel:
1352 285 : xfs_trans_cancel(tp);
1353 285 : 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 64908029 : 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 64908029 : struct xfs_trans *tp;
1377 64908029 : struct xfs_mount *mp = ip->i_mount;
1378 64908029 : unsigned int resblks;
1379 64908029 : bool retried = false;
1380 64921445 : int error;
1381 :
1382 64921445 : retry:
1383 64921445 : *nospace_error = 0;
1384 64921445 : resblks = *dblocks;
1385 64921445 : error = xfs_trans_alloc(mp, resv, resblks, 0, 0, &tp);
1386 64882927 : if (error == -ENOSPC) {
1387 140229 : *nospace_error = error;
1388 140229 : resblks = 0;
1389 140229 : error = xfs_trans_alloc(mp, resv, resblks, 0, 0, &tp);
1390 : }
1391 64882914 : if (error)
1392 0 : return error;
1393 :
1394 64882914 : xfs_lock_two_inodes(dp, XFS_ILOCK_EXCL, ip, XFS_ILOCK_EXCL);
1395 :
1396 64898959 : xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
1397 64891360 : xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
1398 :
1399 64941308 : error = xfs_qm_dqattach_locked(dp, false);
1400 64932551 : if (error) {
1401 : /* Caller should have allocated the dquots! */
1402 0 : ASSERT(error != -ENOENT);
1403 0 : goto out_cancel;
1404 : }
1405 :
1406 64932551 : error = xfs_qm_dqattach_locked(ip, false);
1407 64934190 : if (error) {
1408 : /* Caller should have allocated the dquots! */
1409 0 : ASSERT(error != -ENOENT);
1410 0 : goto out_cancel;
1411 : }
1412 :
1413 64934190 : if (resblks == 0)
1414 140222 : goto done;
1415 :
1416 64793968 : error = xfs_trans_reserve_quota_nblks(tp, dp, resblks, 0, false);
1417 64786858 : if (error == -EDQUOT || error == -ENOSPC) {
1418 25675 : if (!retried) {
1419 13416 : xfs_trans_cancel(tp);
1420 13416 : xfs_blockgc_free_quota(dp, 0);
1421 13416 : retried = true;
1422 13416 : goto retry;
1423 : }
1424 :
1425 12259 : *nospace_error = error;
1426 12259 : resblks = 0;
1427 12259 : error = 0;
1428 : }
1429 64773442 : if (error)
1430 0 : goto out_cancel;
1431 :
1432 64761183 : done:
1433 64913664 : *tpp = tp;
1434 64913664 : *dblocks = resblks;
1435 64913664 : return 0;
1436 :
1437 0 : out_cancel:
1438 0 : xfs_trans_cancel(tp);
1439 0 : return error;
1440 : }
|
