~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/xfs/xfs_trans.c

Version: ~ [ linux-5.16 ] ~ [ linux-5.15.13 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.90 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.170 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.224 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.261 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.296 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.298 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
  3  * Copyright (C) 2010 Red Hat, Inc.
  4  * All Rights Reserved.
  5  *
  6  * This program is free software; you can redistribute it and/or
  7  * modify it under the terms of the GNU General Public License as
  8  * published by the Free Software Foundation.
  9  *
 10  * This program is distributed in the hope that it would be useful,
 11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13  * GNU General Public License for more details.
 14  *
 15  * You should have received a copy of the GNU General Public License
 16  * along with this program; if not, write the Free Software Foundation,
 17  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 18  */
 19 #include "xfs.h"
 20 #include "xfs_fs.h"
 21 #include "xfs_format.h"
 22 #include "xfs_log.h"
 23 #include "xfs_trans.h"
 24 #include "xfs_sb.h"
 25 #include "xfs_ag.h"
 26 #include "xfs_mount.h"
 27 #include "xfs_error.h"
 28 #include "xfs_da_btree.h"
 29 #include "xfs_bmap_btree.h"
 30 #include "xfs_alloc_btree.h"
 31 #include "xfs_ialloc_btree.h"
 32 #include "xfs_dinode.h"
 33 #include "xfs_inode.h"
 34 #include "xfs_btree.h"
 35 #include "xfs_ialloc.h"
 36 #include "xfs_alloc.h"
 37 #include "xfs_extent_busy.h"
 38 #include "xfs_bmap.h"
 39 #include "xfs_quota.h"
 40 #include "xfs_qm.h"
 41 #include "xfs_trans_priv.h"
 42 #include "xfs_trans_space.h"
 43 #include "xfs_inode_item.h"
 44 #include "xfs_log_priv.h"
 45 #include "xfs_buf_item.h"
 46 #include "xfs_trace.h"
 47 
 48 kmem_zone_t     *xfs_trans_zone;
 49 kmem_zone_t     *xfs_log_item_desc_zone;
 50 
 51 /*
 52  * Initialize the precomputed transaction reservation values
 53  * in the mount structure.
 54  */
 55 void
 56 xfs_trans_init(
 57         struct xfs_mount        *mp)
 58 {
 59         xfs_trans_resv_calc(mp, M_RES(mp));
 60 }
 61 
 62 /*
 63  * This routine is called to allocate a transaction structure.
 64  * The type parameter indicates the type of the transaction.  These
 65  * are enumerated in xfs_trans.h.
 66  *
 67  * Dynamically allocate the transaction structure from the transaction
 68  * zone, initialize it, and return it to the caller.
 69  */
 70 xfs_trans_t *
 71 xfs_trans_alloc(
 72         xfs_mount_t     *mp,
 73         uint            type)
 74 {
 75         xfs_trans_t     *tp;
 76 
 77         sb_start_intwrite(mp->m_super);
 78         tp = _xfs_trans_alloc(mp, type, KM_SLEEP);
 79         tp->t_flags |= XFS_TRANS_FREEZE_PROT;
 80         return tp;
 81 }
 82 
 83 xfs_trans_t *
 84 _xfs_trans_alloc(
 85         xfs_mount_t     *mp,
 86         uint            type,
 87         xfs_km_flags_t  memflags)
 88 {
 89         xfs_trans_t     *tp;
 90 
 91         WARN_ON(mp->m_super->s_writers.frozen == SB_FREEZE_COMPLETE);
 92         atomic_inc(&mp->m_active_trans);
 93 
 94         tp = kmem_zone_zalloc(xfs_trans_zone, memflags);
 95         tp->t_magic = XFS_TRANS_HEADER_MAGIC;
 96         tp->t_type = type;
 97         tp->t_mountp = mp;
 98         INIT_LIST_HEAD(&tp->t_items);
 99         INIT_LIST_HEAD(&tp->t_busy);
100         return tp;
101 }
102 
103 /*
104  * Free the transaction structure.  If there is more clean up
105  * to do when the structure is freed, add it here.
106  */
107 STATIC void
108 xfs_trans_free(
109         struct xfs_trans        *tp)
110 {
111         xfs_extent_busy_sort(&tp->t_busy);
112         xfs_extent_busy_clear(tp->t_mountp, &tp->t_busy, false);
113 
114         atomic_dec(&tp->t_mountp->m_active_trans);
115         if (tp->t_flags & XFS_TRANS_FREEZE_PROT)
116                 sb_end_intwrite(tp->t_mountp->m_super);
117         xfs_trans_free_dqinfo(tp);
118         kmem_zone_free(xfs_trans_zone, tp);
119 }
120 
121 /*
122  * This is called to create a new transaction which will share the
123  * permanent log reservation of the given transaction.  The remaining
124  * unused block and rt extent reservations are also inherited.  This
125  * implies that the original transaction is no longer allowed to allocate
126  * blocks.  Locks and log items, however, are no inherited.  They must
127  * be added to the new transaction explicitly.
128  */
129 xfs_trans_t *
130 xfs_trans_dup(
131         xfs_trans_t     *tp)
132 {
133         xfs_trans_t     *ntp;
134 
135         ntp = kmem_zone_zalloc(xfs_trans_zone, KM_SLEEP);
136 
137         /*
138          * Initialize the new transaction structure.
139          */
140         ntp->t_magic = XFS_TRANS_HEADER_MAGIC;
141         ntp->t_type = tp->t_type;
142         ntp->t_mountp = tp->t_mountp;
143         INIT_LIST_HEAD(&ntp->t_items);
144         INIT_LIST_HEAD(&ntp->t_busy);
145 
146         ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
147         ASSERT(tp->t_ticket != NULL);
148 
149         ntp->t_flags = XFS_TRANS_PERM_LOG_RES |
150                        (tp->t_flags & XFS_TRANS_RESERVE) |
151                        (tp->t_flags & XFS_TRANS_FREEZE_PROT);
152         /* We gave our writer reference to the new transaction */
153         tp->t_flags &= ~XFS_TRANS_FREEZE_PROT;
154         ntp->t_ticket = xfs_log_ticket_get(tp->t_ticket);
155         ntp->t_blk_res = tp->t_blk_res - tp->t_blk_res_used;
156         tp->t_blk_res = tp->t_blk_res_used;
157         ntp->t_rtx_res = tp->t_rtx_res - tp->t_rtx_res_used;
158         tp->t_rtx_res = tp->t_rtx_res_used;
159         ntp->t_pflags = tp->t_pflags;
160 
161         xfs_trans_dup_dqinfo(tp, ntp);
162 
163         atomic_inc(&tp->t_mountp->m_active_trans);
164         return ntp;
165 }
166 
167 /*
168  * This is called to reserve free disk blocks and log space for the
169  * given transaction.  This must be done before allocating any resources
170  * within the transaction.
171  *
172  * This will return ENOSPC if there are not enough blocks available.
173  * It will sleep waiting for available log space.
174  * The only valid value for the flags parameter is XFS_RES_LOG_PERM, which
175  * is used by long running transactions.  If any one of the reservations
176  * fails then they will all be backed out.
177  *
178  * This does not do quota reservations. That typically is done by the
179  * caller afterwards.
180  */
181 int
182 xfs_trans_reserve(
183         struct xfs_trans        *tp,
184         struct xfs_trans_res    *resp,
185         uint                    blocks,
186         uint                    rtextents)
187 {
188         int             error = 0;
189         int             rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0;
190 
191         /* Mark this thread as being in a transaction */
192         current_set_flags_nested(&tp->t_pflags, PF_FSTRANS);
193 
194         /*
195          * Attempt to reserve the needed disk blocks by decrementing
196          * the number needed from the number available.  This will
197          * fail if the count would go below zero.
198          */
199         if (blocks > 0) {
200                 error = xfs_icsb_modify_counters(tp->t_mountp, XFS_SBS_FDBLOCKS,
201                                           -((int64_t)blocks), rsvd);
202                 if (error != 0) {
203                         current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
204                         return (XFS_ERROR(ENOSPC));
205                 }
206                 tp->t_blk_res += blocks;
207         }
208 
209         /*
210          * Reserve the log space needed for this transaction.
211          */
212         if (resp->tr_logres > 0) {
213                 bool    permanent = false;
214 
215                 ASSERT(tp->t_log_res == 0 ||
216                        tp->t_log_res == resp->tr_logres);
217                 ASSERT(tp->t_log_count == 0 ||
218                        tp->t_log_count == resp->tr_logcount);
219 
220                 if (resp->tr_logflags & XFS_TRANS_PERM_LOG_RES) {
221                         tp->t_flags |= XFS_TRANS_PERM_LOG_RES;
222                         permanent = true;
223                 } else {
224                         ASSERT(tp->t_ticket == NULL);
225                         ASSERT(!(tp->t_flags & XFS_TRANS_PERM_LOG_RES));
226                 }
227 
228                 if (tp->t_ticket != NULL) {
229                         ASSERT(resp->tr_logflags & XFS_TRANS_PERM_LOG_RES);
230                         error = xfs_log_regrant(tp->t_mountp, tp->t_ticket);
231                 } else {
232                         error = xfs_log_reserve(tp->t_mountp,
233                                                 resp->tr_logres,
234                                                 resp->tr_logcount,
235                                                 &tp->t_ticket, XFS_TRANSACTION,
236                                                 permanent, tp->t_type);
237                 }
238 
239                 if (error)
240                         goto undo_blocks;
241 
242                 tp->t_log_res = resp->tr_logres;
243                 tp->t_log_count = resp->tr_logcount;
244         }
245 
246         /*
247          * Attempt to reserve the needed realtime extents by decrementing
248          * the number needed from the number available.  This will
249          * fail if the count would go below zero.
250          */
251         if (rtextents > 0) {
252                 error = xfs_mod_incore_sb(tp->t_mountp, XFS_SBS_FREXTENTS,
253                                           -((int64_t)rtextents), rsvd);
254                 if (error) {
255                         error = XFS_ERROR(ENOSPC);
256                         goto undo_log;
257                 }
258                 tp->t_rtx_res += rtextents;
259         }
260 
261         return 0;
262 
263         /*
264          * Error cases jump to one of these labels to undo any
265          * reservations which have already been performed.
266          */
267 undo_log:
268         if (resp->tr_logres > 0) {
269                 int             log_flags;
270 
271                 if (resp->tr_logflags & XFS_TRANS_PERM_LOG_RES) {
272                         log_flags = XFS_LOG_REL_PERM_RESERV;
273                 } else {
274                         log_flags = 0;
275                 }
276                 xfs_log_done(tp->t_mountp, tp->t_ticket, NULL, log_flags);
277                 tp->t_ticket = NULL;
278                 tp->t_log_res = 0;
279                 tp->t_flags &= ~XFS_TRANS_PERM_LOG_RES;
280         }
281 
282 undo_blocks:
283         if (blocks > 0) {
284                 xfs_icsb_modify_counters(tp->t_mountp, XFS_SBS_FDBLOCKS,
285                                          (int64_t)blocks, rsvd);
286                 tp->t_blk_res = 0;
287         }
288 
289         current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
290 
291         return error;
292 }
293 
294 /*
295  * Record the indicated change to the given field for application
296  * to the file system's superblock when the transaction commits.
297  * For now, just store the change in the transaction structure.
298  *
299  * Mark the transaction structure to indicate that the superblock
300  * needs to be updated before committing.
301  *
302  * Because we may not be keeping track of allocated/free inodes and
303  * used filesystem blocks in the superblock, we do not mark the
304  * superblock dirty in this transaction if we modify these fields.
305  * We still need to update the transaction deltas so that they get
306  * applied to the incore superblock, but we don't want them to
307  * cause the superblock to get locked and logged if these are the
308  * only fields in the superblock that the transaction modifies.
309  */
310 void
311 xfs_trans_mod_sb(
312         xfs_trans_t     *tp,
313         uint            field,
314         int64_t         delta)
315 {
316         uint32_t        flags = (XFS_TRANS_DIRTY|XFS_TRANS_SB_DIRTY);
317         xfs_mount_t     *mp = tp->t_mountp;
318 
319         switch (field) {
320         case XFS_TRANS_SB_ICOUNT:
321                 tp->t_icount_delta += delta;
322                 if (xfs_sb_version_haslazysbcount(&mp->m_sb))
323                         flags &= ~XFS_TRANS_SB_DIRTY;
324                 break;
325         case XFS_TRANS_SB_IFREE:
326                 tp->t_ifree_delta += delta;
327                 if (xfs_sb_version_haslazysbcount(&mp->m_sb))
328                         flags &= ~XFS_TRANS_SB_DIRTY;
329                 break;
330         case XFS_TRANS_SB_FDBLOCKS:
331                 /*
332                  * Track the number of blocks allocated in the
333                  * transaction.  Make sure it does not exceed the
334                  * number reserved.
335                  */
336                 if (delta < 0) {
337                         tp->t_blk_res_used += (uint)-delta;
338                         ASSERT(tp->t_blk_res_used <= tp->t_blk_res);
339                 }
340                 tp->t_fdblocks_delta += delta;
341                 if (xfs_sb_version_haslazysbcount(&mp->m_sb))
342                         flags &= ~XFS_TRANS_SB_DIRTY;
343                 break;
344         case XFS_TRANS_SB_RES_FDBLOCKS:
345                 /*
346                  * The allocation has already been applied to the
347                  * in-core superblock's counter.  This should only
348                  * be applied to the on-disk superblock.
349                  */
350                 ASSERT(delta < 0);
351                 tp->t_res_fdblocks_delta += delta;
352                 if (xfs_sb_version_haslazysbcount(&mp->m_sb))
353                         flags &= ~XFS_TRANS_SB_DIRTY;
354                 break;
355         case XFS_TRANS_SB_FREXTENTS:
356                 /*
357                  * Track the number of blocks allocated in the
358                  * transaction.  Make sure it does not exceed the
359                  * number reserved.
360                  */
361                 if (delta < 0) {
362                         tp->t_rtx_res_used += (uint)-delta;
363                         ASSERT(tp->t_rtx_res_used <= tp->t_rtx_res);
364                 }
365                 tp->t_frextents_delta += delta;
366                 break;
367         case XFS_TRANS_SB_RES_FREXTENTS:
368                 /*
369                  * The allocation has already been applied to the
370                  * in-core superblock's counter.  This should only
371                  * be applied to the on-disk superblock.
372                  */
373                 ASSERT(delta < 0);
374                 tp->t_res_frextents_delta += delta;
375                 break;
376         case XFS_TRANS_SB_DBLOCKS:
377                 ASSERT(delta > 0);
378                 tp->t_dblocks_delta += delta;
379                 break;
380         case XFS_TRANS_SB_AGCOUNT:
381                 ASSERT(delta > 0);
382                 tp->t_agcount_delta += delta;
383                 break;
384         case XFS_TRANS_SB_IMAXPCT:
385                 tp->t_imaxpct_delta += delta;
386                 break;
387         case XFS_TRANS_SB_REXTSIZE:
388                 tp->t_rextsize_delta += delta;
389                 break;
390         case XFS_TRANS_SB_RBMBLOCKS:
391                 tp->t_rbmblocks_delta += delta;
392                 break;
393         case XFS_TRANS_SB_RBLOCKS:
394                 tp->t_rblocks_delta += delta;
395                 break;
396         case XFS_TRANS_SB_REXTENTS:
397                 tp->t_rextents_delta += delta;
398                 break;
399         case XFS_TRANS_SB_REXTSLOG:
400                 tp->t_rextslog_delta += delta;
401                 break;
402         default:
403                 ASSERT(0);
404                 return;
405         }
406 
407         tp->t_flags |= flags;
408 }
409 
410 /*
411  * xfs_trans_apply_sb_deltas() is called from the commit code
412  * to bring the superblock buffer into the current transaction
413  * and modify it as requested by earlier calls to xfs_trans_mod_sb().
414  *
415  * For now we just look at each field allowed to change and change
416  * it if necessary.
417  */
418 STATIC void
419 xfs_trans_apply_sb_deltas(
420         xfs_trans_t     *tp)
421 {
422         xfs_dsb_t       *sbp;
423         xfs_buf_t       *bp;
424         int             whole = 0;
425 
426         bp = xfs_trans_getsb(tp, tp->t_mountp, 0);
427         sbp = XFS_BUF_TO_SBP(bp);
428 
429         /*
430          * Check that superblock mods match the mods made to AGF counters.
431          */
432         ASSERT((tp->t_fdblocks_delta + tp->t_res_fdblocks_delta) ==
433                (tp->t_ag_freeblks_delta + tp->t_ag_flist_delta +
434                 tp->t_ag_btree_delta));
435 
436         /*
437          * Only update the superblock counters if we are logging them
438          */
439         if (!xfs_sb_version_haslazysbcount(&(tp->t_mountp->m_sb))) {
440                 if (tp->t_icount_delta)
441                         be64_add_cpu(&sbp->sb_icount, tp->t_icount_delta);
442                 if (tp->t_ifree_delta)
443                         be64_add_cpu(&sbp->sb_ifree, tp->t_ifree_delta);
444                 if (tp->t_fdblocks_delta)
445                         be64_add_cpu(&sbp->sb_fdblocks, tp->t_fdblocks_delta);
446                 if (tp->t_res_fdblocks_delta)
447                         be64_add_cpu(&sbp->sb_fdblocks, tp->t_res_fdblocks_delta);
448         }
449 
450         if (tp->t_frextents_delta)
451                 be64_add_cpu(&sbp->sb_frextents, tp->t_frextents_delta);
452         if (tp->t_res_frextents_delta)
453                 be64_add_cpu(&sbp->sb_frextents, tp->t_res_frextents_delta);
454 
455         if (tp->t_dblocks_delta) {
456                 be64_add_cpu(&sbp->sb_dblocks, tp->t_dblocks_delta);
457                 whole = 1;
458         }
459         if (tp->t_agcount_delta) {
460                 be32_add_cpu(&sbp->sb_agcount, tp->t_agcount_delta);
461                 whole = 1;
462         }
463         if (tp->t_imaxpct_delta) {
464                 sbp->sb_imax_pct += tp->t_imaxpct_delta;
465                 whole = 1;
466         }
467         if (tp->t_rextsize_delta) {
468                 be32_add_cpu(&sbp->sb_rextsize, tp->t_rextsize_delta);
469                 whole = 1;
470         }
471         if (tp->t_rbmblocks_delta) {
472                 be32_add_cpu(&sbp->sb_rbmblocks, tp->t_rbmblocks_delta);
473                 whole = 1;
474         }
475         if (tp->t_rblocks_delta) {
476                 be64_add_cpu(&sbp->sb_rblocks, tp->t_rblocks_delta);
477                 whole = 1;
478         }
479         if (tp->t_rextents_delta) {
480                 be64_add_cpu(&sbp->sb_rextents, tp->t_rextents_delta);
481                 whole = 1;
482         }
483         if (tp->t_rextslog_delta) {
484                 sbp->sb_rextslog += tp->t_rextslog_delta;
485                 whole = 1;
486         }
487 
488         xfs_trans_buf_set_type(tp, bp, XFS_BLFT_SB_BUF);
489         if (whole)
490                 /*
491                  * Log the whole thing, the fields are noncontiguous.
492                  */
493                 xfs_trans_log_buf(tp, bp, 0, sizeof(xfs_dsb_t) - 1);
494         else
495                 /*
496                  * Since all the modifiable fields are contiguous, we
497                  * can get away with this.
498                  */
499                 xfs_trans_log_buf(tp, bp, offsetof(xfs_dsb_t, sb_icount),
500                                   offsetof(xfs_dsb_t, sb_frextents) +
501                                   sizeof(sbp->sb_frextents) - 1);
502 }
503 
504 /*
505  * xfs_trans_unreserve_and_mod_sb() is called to release unused reservations
506  * and apply superblock counter changes to the in-core superblock.  The
507  * t_res_fdblocks_delta and t_res_frextents_delta fields are explicitly NOT
508  * applied to the in-core superblock.  The idea is that that has already been
509  * done.
510  *
511  * This is done efficiently with a single call to xfs_mod_incore_sb_batch().
512  * However, we have to ensure that we only modify each superblock field only
513  * once because the application of the delta values may not be atomic. That can
514  * lead to ENOSPC races occurring if we have two separate modifcations of the
515  * free space counter to put back the entire reservation and then take away
516  * what we used.
517  *
518  * If we are not logging superblock counters, then the inode allocated/free and
519  * used block counts are not updated in the on disk superblock. In this case,
520  * XFS_TRANS_SB_DIRTY will not be set when the transaction is updated but we
521  * still need to update the incore superblock with the changes.
522  */
523 void
524 xfs_trans_unreserve_and_mod_sb(
525         xfs_trans_t     *tp)
526 {
527         xfs_mod_sb_t    msb[9]; /* If you add cases, add entries */
528         xfs_mod_sb_t    *msbp;
529         xfs_mount_t     *mp = tp->t_mountp;
530         /* REFERENCED */
531         int             error;
532         int             rsvd;
533         int64_t         blkdelta = 0;
534         int64_t         rtxdelta = 0;
535         int64_t         idelta = 0;
536         int64_t         ifreedelta = 0;
537 
538         msbp = msb;
539         rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0;
540 
541         /* calculate deltas */
542         if (tp->t_blk_res > 0)
543                 blkdelta = tp->t_blk_res;
544         if ((tp->t_fdblocks_delta != 0) &&
545             (xfs_sb_version_haslazysbcount(&mp->m_sb) ||
546              (tp->t_flags & XFS_TRANS_SB_DIRTY)))
547                 blkdelta += tp->t_fdblocks_delta;
548 
549         if (tp->t_rtx_res > 0)
550                 rtxdelta = tp->t_rtx_res;
551         if ((tp->t_frextents_delta != 0) &&
552             (tp->t_flags & XFS_TRANS_SB_DIRTY))
553                 rtxdelta += tp->t_frextents_delta;
554 
555         if (xfs_sb_version_haslazysbcount(&mp->m_sb) ||
556              (tp->t_flags & XFS_TRANS_SB_DIRTY)) {
557                 idelta = tp->t_icount_delta;
558                 ifreedelta = tp->t_ifree_delta;
559         }
560 
561         /* apply the per-cpu counters */
562         if (blkdelta) {
563                 error = xfs_icsb_modify_counters(mp, XFS_SBS_FDBLOCKS,
564                                                  blkdelta, rsvd);
565                 if (error)
566                         goto out;
567         }
568 
569         if (idelta) {
570                 error = xfs_icsb_modify_counters(mp, XFS_SBS_ICOUNT,
571                                                  idelta, rsvd);
572                 if (error)
573                         goto out_undo_fdblocks;
574         }
575 
576         if (ifreedelta) {
577                 error = xfs_icsb_modify_counters(mp, XFS_SBS_IFREE,
578                                                  ifreedelta, rsvd);
579                 if (error)
580                         goto out_undo_icount;
581         }
582 
583         /* apply remaining deltas */
584         if (rtxdelta != 0) {
585                 msbp->msb_field = XFS_SBS_FREXTENTS;
586                 msbp->msb_delta = rtxdelta;
587                 msbp++;
588         }
589 
590         if (tp->t_flags & XFS_TRANS_SB_DIRTY) {
591                 if (tp->t_dblocks_delta != 0) {
592                         msbp->msb_field = XFS_SBS_DBLOCKS;
593                         msbp->msb_delta = tp->t_dblocks_delta;
594                         msbp++;
595                 }
596                 if (tp->t_agcount_delta != 0) {
597                         msbp->msb_field = XFS_SBS_AGCOUNT;
598                         msbp->msb_delta = tp->t_agcount_delta;
599                         msbp++;
600                 }
601                 if (tp->t_imaxpct_delta != 0) {
602                         msbp->msb_field = XFS_SBS_IMAX_PCT;
603                         msbp->msb_delta = tp->t_imaxpct_delta;
604                         msbp++;
605                 }
606                 if (tp->t_rextsize_delta != 0) {
607                         msbp->msb_field = XFS_SBS_REXTSIZE;
608                         msbp->msb_delta = tp->t_rextsize_delta;
609                         msbp++;
610                 }
611                 if (tp->t_rbmblocks_delta != 0) {
612                         msbp->msb_field = XFS_SBS_RBMBLOCKS;
613                         msbp->msb_delta = tp->t_rbmblocks_delta;
614                         msbp++;
615                 }
616                 if (tp->t_rblocks_delta != 0) {
617                         msbp->msb_field = XFS_SBS_RBLOCKS;
618                         msbp->msb_delta = tp->t_rblocks_delta;
619                         msbp++;
620                 }
621                 if (tp->t_rextents_delta != 0) {
622                         msbp->msb_field = XFS_SBS_REXTENTS;
623                         msbp->msb_delta = tp->t_rextents_delta;
624                         msbp++;
625                 }
626                 if (tp->t_rextslog_delta != 0) {
627                         msbp->msb_field = XFS_SBS_REXTSLOG;
628                         msbp->msb_delta = tp->t_rextslog_delta;
629                         msbp++;
630                 }
631         }
632 
633         /*
634          * If we need to change anything, do it.
635          */
636         if (msbp > msb) {
637                 error = xfs_mod_incore_sb_batch(tp->t_mountp, msb,
638                         (uint)(msbp - msb), rsvd);
639                 if (error)
640                         goto out_undo_ifreecount;
641         }
642 
643         return;
644 
645 out_undo_ifreecount:
646         if (ifreedelta)
647                 xfs_icsb_modify_counters(mp, XFS_SBS_IFREE, -ifreedelta, rsvd);
648 out_undo_icount:
649         if (idelta)
650                 xfs_icsb_modify_counters(mp, XFS_SBS_ICOUNT, -idelta, rsvd);
651 out_undo_fdblocks:
652         if (blkdelta)
653                 xfs_icsb_modify_counters(mp, XFS_SBS_FDBLOCKS, -blkdelta, rsvd);
654 out:
655         ASSERT(error == 0);
656         return;
657 }
658 
659 /*
660  * Add the given log item to the transaction's list of log items.
661  *
662  * The log item will now point to its new descriptor with its li_desc field.
663  */
664 void
665 xfs_trans_add_item(
666         struct xfs_trans        *tp,
667         struct xfs_log_item     *lip)
668 {
669         struct xfs_log_item_desc *lidp;
670 
671         ASSERT(lip->li_mountp == tp->t_mountp);
672         ASSERT(lip->li_ailp == tp->t_mountp->m_ail);
673 
674         lidp = kmem_zone_zalloc(xfs_log_item_desc_zone, KM_SLEEP | KM_NOFS);
675 
676         lidp->lid_item = lip;
677         lidp->lid_flags = 0;
678         list_add_tail(&lidp->lid_trans, &tp->t_items);
679 
680         lip->li_desc = lidp;
681 }
682 
683 STATIC void
684 xfs_trans_free_item_desc(
685         struct xfs_log_item_desc *lidp)
686 {
687         list_del_init(&lidp->lid_trans);
688         kmem_zone_free(xfs_log_item_desc_zone, lidp);
689 }
690 
691 /*
692  * Unlink and free the given descriptor.
693  */
694 void
695 xfs_trans_del_item(
696         struct xfs_log_item     *lip)
697 {
698         xfs_trans_free_item_desc(lip->li_desc);
699         lip->li_desc = NULL;
700 }
701 
702 /*
703  * Unlock all of the items of a transaction and free all the descriptors
704  * of that transaction.
705  */
706 void
707 xfs_trans_free_items(
708         struct xfs_trans        *tp,
709         xfs_lsn_t               commit_lsn,
710         int                     flags)
711 {
712         struct xfs_log_item_desc *lidp, *next;
713 
714         list_for_each_entry_safe(lidp, next, &tp->t_items, lid_trans) {
715                 struct xfs_log_item     *lip = lidp->lid_item;
716 
717                 lip->li_desc = NULL;
718 
719                 if (commit_lsn != NULLCOMMITLSN)
720                         lip->li_ops->iop_committing(lip, commit_lsn);
721                 if (flags & XFS_TRANS_ABORT)
722                         lip->li_flags |= XFS_LI_ABORTED;
723                 lip->li_ops->iop_unlock(lip);
724 
725                 xfs_trans_free_item_desc(lidp);
726         }
727 }
728 
729 static inline void
730 xfs_log_item_batch_insert(
731         struct xfs_ail          *ailp,
732         struct xfs_ail_cursor   *cur,
733         struct xfs_log_item     **log_items,
734         int                     nr_items,
735         xfs_lsn_t               commit_lsn)
736 {
737         int     i;
738 
739         spin_lock(&ailp->xa_lock);
740         /* xfs_trans_ail_update_bulk drops ailp->xa_lock */
741         xfs_trans_ail_update_bulk(ailp, cur, log_items, nr_items, commit_lsn);
742 
743         for (i = 0; i < nr_items; i++) {
744                 struct xfs_log_item *lip = log_items[i];
745 
746                 lip->li_ops->iop_unpin(lip, 0);
747         }
748 }
749 
750 /*
751  * Bulk operation version of xfs_trans_committed that takes a log vector of
752  * items to insert into the AIL. This uses bulk AIL insertion techniques to
753  * minimise lock traffic.
754  *
755  * If we are called with the aborted flag set, it is because a log write during
756  * a CIL checkpoint commit has failed. In this case, all the items in the
757  * checkpoint have already gone through iop_commited and iop_unlock, which
758  * means that checkpoint commit abort handling is treated exactly the same
759  * as an iclog write error even though we haven't started any IO yet. Hence in
760  * this case all we need to do is iop_committed processing, followed by an
761  * iop_unpin(aborted) call.
762  *
763  * The AIL cursor is used to optimise the insert process. If commit_lsn is not
764  * at the end of the AIL, the insert cursor avoids the need to walk
765  * the AIL to find the insertion point on every xfs_log_item_batch_insert()
766  * call. This saves a lot of needless list walking and is a net win, even
767  * though it slightly increases that amount of AIL lock traffic to set it up
768  * and tear it down.
769  */
770 void
771 xfs_trans_committed_bulk(
772         struct xfs_ail          *ailp,
773         struct xfs_log_vec      *log_vector,
774         xfs_lsn_t               commit_lsn,
775         int                     aborted)
776 {
777 #define LOG_ITEM_BATCH_SIZE     32
778         struct xfs_log_item     *log_items[LOG_ITEM_BATCH_SIZE];
779         struct xfs_log_vec      *lv;
780         struct xfs_ail_cursor   cur;
781         int                     i = 0;
782 
783         spin_lock(&ailp->xa_lock);
784         xfs_trans_ail_cursor_last(ailp, &cur, commit_lsn);
785         spin_unlock(&ailp->xa_lock);
786 
787         /* unpin all the log items */
788         for (lv = log_vector; lv; lv = lv->lv_next ) {
789                 struct xfs_log_item     *lip = lv->lv_item;
790                 xfs_lsn_t               item_lsn;
791 
792                 if (aborted)
793                         lip->li_flags |= XFS_LI_ABORTED;
794                 item_lsn = lip->li_ops->iop_committed(lip, commit_lsn);
795 
796                 /* item_lsn of -1 means the item needs no further processing */
797                 if (XFS_LSN_CMP(item_lsn, (xfs_lsn_t)-1) == 0)
798                         continue;
799 
800                 /*
801                  * if we are aborting the operation, no point in inserting the
802                  * object into the AIL as we are in a shutdown situation.
803                  */
804                 if (aborted) {
805                         ASSERT(XFS_FORCED_SHUTDOWN(ailp->xa_mount));
806                         lip->li_ops->iop_unpin(lip, 1);
807                         continue;
808                 }
809 
810                 if (item_lsn != commit_lsn) {
811 
812                         /*
813                          * Not a bulk update option due to unusual item_lsn.
814                          * Push into AIL immediately, rechecking the lsn once
815                          * we have the ail lock. Then unpin the item. This does
816                          * not affect the AIL cursor the bulk insert path is
817                          * using.
818                          */
819                         spin_lock(&ailp->xa_lock);
820                         if (XFS_LSN_CMP(item_lsn, lip->li_lsn) > 0)
821                                 xfs_trans_ail_update(ailp, lip, item_lsn);
822                         else
823                                 spin_unlock(&ailp->xa_lock);
824                         lip->li_ops->iop_unpin(lip, 0);
825                         continue;
826                 }
827 
828                 /* Item is a candidate for bulk AIL insert.  */
829                 log_items[i++] = lv->lv_item;
830                 if (i >= LOG_ITEM_BATCH_SIZE) {
831                         xfs_log_item_batch_insert(ailp, &cur, log_items,
832                                         LOG_ITEM_BATCH_SIZE, commit_lsn);
833                         i = 0;
834                 }
835         }
836 
837         /* make sure we insert the remainder! */
838         if (i)
839                 xfs_log_item_batch_insert(ailp, &cur, log_items, i, commit_lsn);
840 
841         spin_lock(&ailp->xa_lock);
842         xfs_trans_ail_cursor_done(ailp, &cur);
843         spin_unlock(&ailp->xa_lock);
844 }
845 
846 /*
847  * Commit the given transaction to the log.
848  *
849  * XFS disk error handling mechanism is not based on a typical
850  * transaction abort mechanism. Logically after the filesystem
851  * gets marked 'SHUTDOWN', we can't let any new transactions
852  * be durable - ie. committed to disk - because some metadata might
853  * be inconsistent. In such cases, this returns an error, and the
854  * caller may assume that all locked objects joined to the transaction
855  * have already been unlocked as if the commit had succeeded.
856  * Do not reference the transaction structure after this call.
857  */
858 int
859 xfs_trans_commit(
860         struct xfs_trans        *tp,
861         uint                    flags)
862 {
863         struct xfs_mount        *mp = tp->t_mountp;
864         xfs_lsn_t               commit_lsn = -1;
865         int                     error = 0;
866         int                     log_flags = 0;
867         int                     sync = tp->t_flags & XFS_TRANS_SYNC;
868 
869         /*
870          * Determine whether this commit is releasing a permanent
871          * log reservation or not.
872          */
873         if (flags & XFS_TRANS_RELEASE_LOG_RES) {
874                 ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
875                 log_flags = XFS_LOG_REL_PERM_RESERV;
876         }
877 
878         /*
879          * If there is nothing to be logged by the transaction,
880          * then unlock all of the items associated with the
881          * transaction and free the transaction structure.
882          * Also make sure to return any reserved blocks to
883          * the free pool.
884          */
885         if (!(tp->t_flags & XFS_TRANS_DIRTY))
886                 goto out_unreserve;
887 
888         if (XFS_FORCED_SHUTDOWN(mp)) {
889                 error = XFS_ERROR(EIO);
890                 goto out_unreserve;
891         }
892 
893         ASSERT(tp->t_ticket != NULL);
894 
895         /*
896          * If we need to update the superblock, then do it now.
897          */
898         if (tp->t_flags & XFS_TRANS_SB_DIRTY)
899                 xfs_trans_apply_sb_deltas(tp);
900         xfs_trans_apply_dquot_deltas(tp);
901 
902         error = xfs_log_commit_cil(mp, tp, &commit_lsn, flags);
903         if (error == ENOMEM) {
904                 xfs_force_shutdown(mp, SHUTDOWN_LOG_IO_ERROR);
905                 error = XFS_ERROR(EIO);
906                 goto out_unreserve;
907         }
908 
909         current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
910         xfs_trans_free(tp);
911 
912         /*
913          * If the transaction needs to be synchronous, then force the
914          * log out now and wait for it.
915          */
916         if (sync) {
917                 if (!error) {
918                         error = _xfs_log_force_lsn(mp, commit_lsn,
919                                       XFS_LOG_SYNC, NULL);
920                 }
921                 XFS_STATS_INC(xs_trans_sync);
922         } else {
923                 XFS_STATS_INC(xs_trans_async);
924         }
925 
926         return error;
927 
928 out_unreserve:
929         xfs_trans_unreserve_and_mod_sb(tp);
930 
931         /*
932          * It is indeed possible for the transaction to be not dirty but
933          * the dqinfo portion to be.  All that means is that we have some
934          * (non-persistent) quota reservations that need to be unreserved.
935          */
936         xfs_trans_unreserve_and_mod_dquots(tp);
937         if (tp->t_ticket) {
938                 commit_lsn = xfs_log_done(mp, tp->t_ticket, NULL, log_flags);
939                 if (commit_lsn == -1 && !error)
940                         error = XFS_ERROR(EIO);
941         }
942         current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
943         xfs_trans_free_items(tp, NULLCOMMITLSN, error ? XFS_TRANS_ABORT : 0);
944         xfs_trans_free(tp);
945 
946         XFS_STATS_INC(xs_trans_empty);
947         return error;
948 }
949 
950 /*
951  * Unlock all of the transaction's items and free the transaction.
952  * The transaction must not have modified any of its items, because
953  * there is no way to restore them to their previous state.
954  *
955  * If the transaction has made a log reservation, make sure to release
956  * it as well.
957  */
958 void
959 xfs_trans_cancel(
960         xfs_trans_t             *tp,
961         int                     flags)
962 {
963         int                     log_flags;
964         xfs_mount_t             *mp = tp->t_mountp;
965 
966         /*
967          * See if the caller is being too lazy to figure out if
968          * the transaction really needs an abort.
969          */
970         if ((flags & XFS_TRANS_ABORT) && !(tp->t_flags & XFS_TRANS_DIRTY))
971                 flags &= ~XFS_TRANS_ABORT;
972         /*
973          * See if the caller is relying on us to shut down the
974          * filesystem.  This happens in paths where we detect
975          * corruption and decide to give up.
976          */
977         if ((tp->t_flags & XFS_TRANS_DIRTY) && !XFS_FORCED_SHUTDOWN(mp)) {
978                 XFS_ERROR_REPORT("xfs_trans_cancel", XFS_ERRLEVEL_LOW, mp);
979                 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
980         }
981 #ifdef DEBUG
982         if (!(flags & XFS_TRANS_ABORT) && !XFS_FORCED_SHUTDOWN(mp)) {
983                 struct xfs_log_item_desc *lidp;
984 
985                 list_for_each_entry(lidp, &tp->t_items, lid_trans)
986                         ASSERT(!(lidp->lid_item->li_type == XFS_LI_EFD));
987         }
988 #endif
989         xfs_trans_unreserve_and_mod_sb(tp);
990         xfs_trans_unreserve_and_mod_dquots(tp);
991 
992         if (tp->t_ticket) {
993                 if (flags & XFS_TRANS_RELEASE_LOG_RES) {
994                         ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
995                         log_flags = XFS_LOG_REL_PERM_RESERV;
996                 } else {
997                         log_flags = 0;
998                 }
999                 xfs_log_done(mp, tp->t_ticket, NULL, log_flags);
1000         }
1001 
1002         /* mark this thread as no longer being in a transaction */
1003         current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
1004 
1005         xfs_trans_free_items(tp, NULLCOMMITLSN, flags);
1006         xfs_trans_free(tp);
1007 }
1008 
1009 /*
1010  * Roll from one trans in the sequence of PERMANENT transactions to
1011  * the next: permanent transactions are only flushed out when
1012  * committed with XFS_TRANS_RELEASE_LOG_RES, but we still want as soon
1013  * as possible to let chunks of it go to the log. So we commit the
1014  * chunk we've been working on and get a new transaction to continue.
1015  */
1016 int
1017 xfs_trans_roll(
1018         struct xfs_trans        **tpp,
1019         struct xfs_inode        *dp)
1020 {
1021         struct xfs_trans        *trans;
1022         struct xfs_trans_res    tres;
1023         int                     error;
1024 
1025         /*
1026          * Ensure that the inode is always logged.
1027          */
1028         trans = *tpp;
1029         xfs_trans_log_inode(trans, dp, XFS_ILOG_CORE);
1030 
1031         /*
1032          * Copy the critical parameters from one trans to the next.
1033          */
1034         tres.tr_logres = trans->t_log_res;
1035         tres.tr_logcount = trans->t_log_count;
1036         *tpp = xfs_trans_dup(trans);
1037 
1038         /*
1039          * Commit the current transaction.
1040          * If this commit failed, then it'd just unlock those items that
1041          * are not marked ihold. That also means that a filesystem shutdown
1042          * is in progress. The caller takes the responsibility to cancel
1043          * the duplicate transaction that gets returned.
1044          */
1045         error = xfs_trans_commit(trans, 0);
1046         if (error)
1047                 return (error);
1048 
1049         trans = *tpp;
1050 
1051         /*
1052          * transaction commit worked ok so we can drop the extra ticket
1053          * reference that we gained in xfs_trans_dup()
1054          */
1055         xfs_log_ticket_put(trans->t_ticket);
1056 
1057 
1058         /*
1059          * Reserve space in the log for th next transaction.
1060          * This also pushes items in the "AIL", the list of logged items,
1061          * out to disk if they are taking up space at the tail of the log
1062          * that we want to use.  This requires that either nothing be locked
1063          * across this call, or that anything that is locked be logged in
1064          * the prior and the next transactions.
1065          */
1066         tres.tr_logflags = XFS_TRANS_PERM_LOG_RES;
1067         error = xfs_trans_reserve(trans, &tres, 0, 0);
1068         /*
1069          *  Ensure that the inode is in the new transaction and locked.
1070          */
1071         if (error)
1072                 return error;
1073 
1074         xfs_trans_ijoin(trans, dp, 0);
1075         return 0;
1076 }
1077 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp