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

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

Version: ~ [ linux-5.14-rc3 ] ~ [ linux-5.13.5 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.53 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.135 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.198 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.240 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.276 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.276 ] ~ [ 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) 2010 Red Hat, Inc. All Rights Reserved.
  3  *
  4  * This program is free software; you can redistribute it and/or
  5  * modify it under the terms of the GNU General Public License as
  6  * published by the Free Software Foundation.
  7  *
  8  * This program is distributed in the hope that it would be useful,
  9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 11  * GNU General Public License for more details.
 12  *
 13  * You should have received a copy of the GNU General Public License
 14  * along with this program; if not, write the Free Software Foundation,
 15  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 16  */
 17 
 18 #include "xfs.h"
 19 #include "xfs_fs.h"
 20 #include "xfs_log_format.h"
 21 #include "xfs_shared.h"
 22 #include "xfs_trans_resv.h"
 23 #include "xfs_sb.h"
 24 #include "xfs_ag.h"
 25 #include "xfs_mount.h"
 26 #include "xfs_error.h"
 27 #include "xfs_alloc.h"
 28 #include "xfs_extent_busy.h"
 29 #include "xfs_discard.h"
 30 #include "xfs_trans.h"
 31 #include "xfs_trans_priv.h"
 32 #include "xfs_log.h"
 33 #include "xfs_log_priv.h"
 34 
 35 /*
 36  * Allocate a new ticket. Failing to get a new ticket makes it really hard to
 37  * recover, so we don't allow failure here. Also, we allocate in a context that
 38  * we don't want to be issuing transactions from, so we need to tell the
 39  * allocation code this as well.
 40  *
 41  * We don't reserve any space for the ticket - we are going to steal whatever
 42  * space we require from transactions as they commit. To ensure we reserve all
 43  * the space required, we need to set the current reservation of the ticket to
 44  * zero so that we know to steal the initial transaction overhead from the
 45  * first transaction commit.
 46  */
 47 static struct xlog_ticket *
 48 xlog_cil_ticket_alloc(
 49         struct xlog     *log)
 50 {
 51         struct xlog_ticket *tic;
 52 
 53         tic = xlog_ticket_alloc(log, 0, 1, XFS_TRANSACTION, 0,
 54                                 KM_SLEEP|KM_NOFS);
 55         tic->t_trans_type = XFS_TRANS_CHECKPOINT;
 56 
 57         /*
 58          * set the current reservation to zero so we know to steal the basic
 59          * transaction overhead reservation from the first transaction commit.
 60          */
 61         tic->t_curr_res = 0;
 62         return tic;
 63 }
 64 
 65 /*
 66  * After the first stage of log recovery is done, we know where the head and
 67  * tail of the log are. We need this log initialisation done before we can
 68  * initialise the first CIL checkpoint context.
 69  *
 70  * Here we allocate a log ticket to track space usage during a CIL push.  This
 71  * ticket is passed to xlog_write() directly so that we don't slowly leak log
 72  * space by failing to account for space used by log headers and additional
 73  * region headers for split regions.
 74  */
 75 void
 76 xlog_cil_init_post_recovery(
 77         struct xlog     *log)
 78 {
 79         log->l_cilp->xc_ctx->ticket = xlog_cil_ticket_alloc(log);
 80         log->l_cilp->xc_ctx->sequence = 1;
 81 }
 82 
 83 /*
 84  * Prepare the log item for insertion into the CIL. Calculate the difference in
 85  * log space and vectors it will consume, and if it is a new item pin it as
 86  * well.
 87  */
 88 STATIC void
 89 xfs_cil_prepare_item(
 90         struct xlog             *log,
 91         struct xfs_log_vec      *lv,
 92         struct xfs_log_vec      *old_lv,
 93         int                     *diff_len,
 94         int                     *diff_iovecs)
 95 {
 96         /* Account for the new LV being passed in */
 97         if (lv->lv_buf_len != XFS_LOG_VEC_ORDERED) {
 98                 *diff_len += lv->lv_bytes;
 99                 *diff_iovecs += lv->lv_niovecs;
100         }
101 
102         /*
103          * If there is no old LV, this is the first time we've seen the item in
104          * this CIL context and so we need to pin it. If we are replacing the
105          * old_lv, then remove the space it accounts for and free it.
106          */
107         if (!old_lv)
108                 lv->lv_item->li_ops->iop_pin(lv->lv_item);
109         else if (old_lv != lv) {
110                 ASSERT(lv->lv_buf_len != XFS_LOG_VEC_ORDERED);
111 
112                 *diff_len -= old_lv->lv_bytes;
113                 *diff_iovecs -= old_lv->lv_niovecs;
114                 kmem_free(old_lv);
115         }
116 
117         /* attach new log vector to log item */
118         lv->lv_item->li_lv = lv;
119 
120         /*
121          * If this is the first time the item is being committed to the
122          * CIL, store the sequence number on the log item so we can
123          * tell in future commits whether this is the first checkpoint
124          * the item is being committed into.
125          */
126         if (!lv->lv_item->li_seq)
127                 lv->lv_item->li_seq = log->l_cilp->xc_ctx->sequence;
128 }
129 
130 /*
131  * Format log item into a flat buffers
132  *
133  * For delayed logging, we need to hold a formatted buffer containing all the
134  * changes on the log item. This enables us to relog the item in memory and
135  * write it out asynchronously without needing to relock the object that was
136  * modified at the time it gets written into the iclog.
137  *
138  * This function builds a vector for the changes in each log item in the
139  * transaction. It then works out the length of the buffer needed for each log
140  * item, allocates them and formats the vector for the item into the buffer.
141  * The buffer is then attached to the log item are then inserted into the
142  * Committed Item List for tracking until the next checkpoint is written out.
143  *
144  * We don't set up region headers during this process; we simply copy the
145  * regions into the flat buffer. We can do this because we still have to do a
146  * formatting step to write the regions into the iclog buffer.  Writing the
147  * ophdrs during the iclog write means that we can support splitting large
148  * regions across iclog boundares without needing a change in the format of the
149  * item/region encapsulation.
150  *
151  * Hence what we need to do now is change the rewrite the vector array to point
152  * to the copied region inside the buffer we just allocated. This allows us to
153  * format the regions into the iclog as though they are being formatted
154  * directly out of the objects themselves.
155  */
156 static void
157 xlog_cil_insert_format_items(
158         struct xlog             *log,
159         struct xfs_trans        *tp,
160         int                     *diff_len,
161         int                     *diff_iovecs)
162 {
163         struct xfs_log_item_desc *lidp;
164 
165 
166         /* Bail out if we didn't find a log item.  */
167         if (list_empty(&tp->t_items)) {
168                 ASSERT(0);
169                 return;
170         }
171 
172         list_for_each_entry(lidp, &tp->t_items, lid_trans) {
173                 struct xfs_log_item *lip = lidp->lid_item;
174                 struct xfs_log_vec *lv;
175                 struct xfs_log_vec *old_lv;
176                 int     niovecs = 0;
177                 int     nbytes = 0;
178                 int     buf_size;
179                 bool    ordered = false;
180 
181                 /* Skip items which aren't dirty in this transaction. */
182                 if (!(lidp->lid_flags & XFS_LID_DIRTY))
183                         continue;
184 
185                 /* get number of vecs and size of data to be stored */
186                 lip->li_ops->iop_size(lip, &niovecs, &nbytes);
187 
188                 /* Skip items that do not have any vectors for writing */
189                 if (!niovecs)
190                         continue;
191 
192                 /*
193                  * Ordered items need to be tracked but we do not wish to write
194                  * them. We need a logvec to track the object, but we do not
195                  * need an iovec or buffer to be allocated for copying data.
196                  */
197                 if (niovecs == XFS_LOG_VEC_ORDERED) {
198                         ordered = true;
199                         niovecs = 0;
200                         nbytes = 0;
201                 }
202 
203                 /*
204                  * We 64-bit align the length of each iovec so that the start
205                  * of the next one is naturally aligned.  We'll need to
206                  * account for that slack space here. Then round nbytes up
207                  * to 64-bit alignment so that the initial buffer alignment is
208                  * easy to calculate and verify.
209                  */
210                 nbytes += niovecs * sizeof(uint64_t);
211                 nbytes = round_up(nbytes, sizeof(uint64_t));
212 
213                 /* grab the old item if it exists for reservation accounting */
214                 old_lv = lip->li_lv;
215 
216                 /*
217                  * The data buffer needs to start 64-bit aligned, so round up
218                  * that space to ensure we can align it appropriately and not
219                  * overrun the buffer.
220                  */
221                 buf_size = nbytes +
222                            round_up((sizeof(struct xfs_log_vec) +
223                                      niovecs * sizeof(struct xfs_log_iovec)),
224                                     sizeof(uint64_t));
225 
226                 /* compare to existing item size */
227                 if (lip->li_lv && buf_size <= lip->li_lv->lv_size) {
228                         /* same or smaller, optimise common overwrite case */
229                         lv = lip->li_lv;
230                         lv->lv_next = NULL;
231 
232                         if (ordered)
233                                 goto insert;
234 
235                         /*
236                          * set the item up as though it is a new insertion so
237                          * that the space reservation accounting is correct.
238                          */
239                         *diff_iovecs -= lv->lv_niovecs;
240                         *diff_len -= lv->lv_bytes;
241                 } else {
242                         /* allocate new data chunk */
243                         lv = kmem_zalloc(buf_size, KM_SLEEP|KM_NOFS);
244                         lv->lv_item = lip;
245                         lv->lv_size = buf_size;
246                         if (ordered) {
247                                 /* track as an ordered logvec */
248                                 ASSERT(lip->li_lv == NULL);
249                                 lv->lv_buf_len = XFS_LOG_VEC_ORDERED;
250                                 goto insert;
251                         }
252                         lv->lv_iovecp = (struct xfs_log_iovec *)&lv[1];
253                 }
254 
255                 /* Ensure the lv is set up according to ->iop_size */
256                 lv->lv_niovecs = niovecs;
257 
258                 /* The allocated data region lies beyond the iovec region */
259                 lv->lv_buf_len = 0;
260                 lv->lv_bytes = 0;
261                 lv->lv_buf = (char *)lv + buf_size - nbytes;
262                 ASSERT(IS_ALIGNED((unsigned long)lv->lv_buf, sizeof(uint64_t)));
263 
264                 lip->li_ops->iop_format(lip, lv);
265 insert:
266                 ASSERT(lv->lv_buf_len <= nbytes);
267                 xfs_cil_prepare_item(log, lv, old_lv, diff_len, diff_iovecs);
268         }
269 }
270 
271 /*
272  * Insert the log items into the CIL and calculate the difference in space
273  * consumed by the item. Add the space to the checkpoint ticket and calculate
274  * if the change requires additional log metadata. If it does, take that space
275  * as well. Remove the amount of space we added to the checkpoint ticket from
276  * the current transaction ticket so that the accounting works out correctly.
277  */
278 static void
279 xlog_cil_insert_items(
280         struct xlog             *log,
281         struct xfs_trans        *tp)
282 {
283         struct xfs_cil          *cil = log->l_cilp;
284         struct xfs_cil_ctx      *ctx = cil->xc_ctx;
285         struct xfs_log_item_desc *lidp;
286         int                     len = 0;
287         int                     diff_iovecs = 0;
288         int                     iclog_space;
289 
290         ASSERT(tp);
291 
292         /*
293          * We can do this safely because the context can't checkpoint until we
294          * are done so it doesn't matter exactly how we update the CIL.
295          */
296         xlog_cil_insert_format_items(log, tp, &len, &diff_iovecs);
297 
298         /*
299          * Now (re-)position everything modified at the tail of the CIL.
300          * We do this here so we only need to take the CIL lock once during
301          * the transaction commit.
302          */
303         spin_lock(&cil->xc_cil_lock);
304         list_for_each_entry(lidp, &tp->t_items, lid_trans) {
305                 struct xfs_log_item     *lip = lidp->lid_item;
306 
307                 /* Skip items which aren't dirty in this transaction. */
308                 if (!(lidp->lid_flags & XFS_LID_DIRTY))
309                         continue;
310 
311                 list_move_tail(&lip->li_cil, &cil->xc_cil);
312         }
313 
314         /* account for space used by new iovec headers  */
315         len += diff_iovecs * sizeof(xlog_op_header_t);
316         ctx->nvecs += diff_iovecs;
317 
318         /* attach the transaction to the CIL if it has any busy extents */
319         if (!list_empty(&tp->t_busy))
320                 list_splice_init(&tp->t_busy, &ctx->busy_extents);
321 
322         /*
323          * Now transfer enough transaction reservation to the context ticket
324          * for the checkpoint. The context ticket is special - the unit
325          * reservation has to grow as well as the current reservation as we
326          * steal from tickets so we can correctly determine the space used
327          * during the transaction commit.
328          */
329         if (ctx->ticket->t_curr_res == 0) {
330                 ctx->ticket->t_curr_res = ctx->ticket->t_unit_res;
331                 tp->t_ticket->t_curr_res -= ctx->ticket->t_unit_res;
332         }
333 
334         /* do we need space for more log record headers? */
335         iclog_space = log->l_iclog_size - log->l_iclog_hsize;
336         if (len > 0 && (ctx->space_used / iclog_space !=
337                                 (ctx->space_used + len) / iclog_space)) {
338                 int hdrs;
339 
340                 hdrs = (len + iclog_space - 1) / iclog_space;
341                 /* need to take into account split region headers, too */
342                 hdrs *= log->l_iclog_hsize + sizeof(struct xlog_op_header);
343                 ctx->ticket->t_unit_res += hdrs;
344                 ctx->ticket->t_curr_res += hdrs;
345                 tp->t_ticket->t_curr_res -= hdrs;
346                 ASSERT(tp->t_ticket->t_curr_res >= len);
347         }
348         tp->t_ticket->t_curr_res -= len;
349         ctx->space_used += len;
350 
351         spin_unlock(&cil->xc_cil_lock);
352 }
353 
354 static void
355 xlog_cil_free_logvec(
356         struct xfs_log_vec      *log_vector)
357 {
358         struct xfs_log_vec      *lv;
359 
360         for (lv = log_vector; lv; ) {
361                 struct xfs_log_vec *next = lv->lv_next;
362                 kmem_free(lv);
363                 lv = next;
364         }
365 }
366 
367 /*
368  * Mark all items committed and clear busy extents. We free the log vector
369  * chains in a separate pass so that we unpin the log items as quickly as
370  * possible.
371  */
372 static void
373 xlog_cil_committed(
374         void    *args,
375         int     abort)
376 {
377         struct xfs_cil_ctx      *ctx = args;
378         struct xfs_mount        *mp = ctx->cil->xc_log->l_mp;
379 
380         xfs_trans_committed_bulk(ctx->cil->xc_log->l_ailp, ctx->lv_chain,
381                                         ctx->start_lsn, abort);
382 
383         xfs_extent_busy_sort(&ctx->busy_extents);
384         xfs_extent_busy_clear(mp, &ctx->busy_extents,
385                              (mp->m_flags & XFS_MOUNT_DISCARD) && !abort);
386 
387         /*
388          * If we are aborting the commit, wake up anyone waiting on the
389          * committing list.  If we don't, then a shutdown we can leave processes
390          * waiting in xlog_cil_force_lsn() waiting on a sequence commit that
391          * will never happen because we aborted it.
392          */
393         spin_lock(&ctx->cil->xc_push_lock);
394         if (abort)
395                 wake_up_all(&ctx->cil->xc_commit_wait);
396         list_del(&ctx->committing);
397         spin_unlock(&ctx->cil->xc_push_lock);
398 
399         xlog_cil_free_logvec(ctx->lv_chain);
400 
401         if (!list_empty(&ctx->busy_extents)) {
402                 ASSERT(mp->m_flags & XFS_MOUNT_DISCARD);
403 
404                 xfs_discard_extents(mp, &ctx->busy_extents);
405                 xfs_extent_busy_clear(mp, &ctx->busy_extents, false);
406         }
407 
408         kmem_free(ctx);
409 }
410 
411 /*
412  * Push the Committed Item List to the log. If @push_seq flag is zero, then it
413  * is a background flush and so we can chose to ignore it. Otherwise, if the
414  * current sequence is the same as @push_seq we need to do a flush. If
415  * @push_seq is less than the current sequence, then it has already been
416  * flushed and we don't need to do anything - the caller will wait for it to
417  * complete if necessary.
418  *
419  * @push_seq is a value rather than a flag because that allows us to do an
420  * unlocked check of the sequence number for a match. Hence we can allows log
421  * forces to run racily and not issue pushes for the same sequence twice. If we
422  * get a race between multiple pushes for the same sequence they will block on
423  * the first one and then abort, hence avoiding needless pushes.
424  */
425 STATIC int
426 xlog_cil_push(
427         struct xlog             *log)
428 {
429         struct xfs_cil          *cil = log->l_cilp;
430         struct xfs_log_vec      *lv;
431         struct xfs_cil_ctx      *ctx;
432         struct xfs_cil_ctx      *new_ctx;
433         struct xlog_in_core     *commit_iclog;
434         struct xlog_ticket      *tic;
435         int                     num_iovecs;
436         int                     error = 0;
437         struct xfs_trans_header thdr;
438         struct xfs_log_iovec    lhdr;
439         struct xfs_log_vec      lvhdr = { NULL };
440         xfs_lsn_t               commit_lsn;
441         xfs_lsn_t               push_seq;
442 
443         if (!cil)
444                 return 0;
445 
446         new_ctx = kmem_zalloc(sizeof(*new_ctx), KM_SLEEP|KM_NOFS);
447         new_ctx->ticket = xlog_cil_ticket_alloc(log);
448 
449         down_write(&cil->xc_ctx_lock);
450         ctx = cil->xc_ctx;
451 
452         spin_lock(&cil->xc_push_lock);
453         push_seq = cil->xc_push_seq;
454         ASSERT(push_seq <= ctx->sequence);
455 
456         /*
457          * Check if we've anything to push. If there is nothing, then we don't
458          * move on to a new sequence number and so we have to be able to push
459          * this sequence again later.
460          */
461         if (list_empty(&cil->xc_cil)) {
462                 cil->xc_push_seq = 0;
463                 spin_unlock(&cil->xc_push_lock);
464                 goto out_skip;
465         }
466 
467 
468         /* check for a previously pushed seqeunce */
469         if (push_seq < cil->xc_ctx->sequence) {
470                 spin_unlock(&cil->xc_push_lock);
471                 goto out_skip;
472         }
473 
474         /*
475          * We are now going to push this context, so add it to the committing
476          * list before we do anything else. This ensures that anyone waiting on
477          * this push can easily detect the difference between a "push in
478          * progress" and "CIL is empty, nothing to do".
479          *
480          * IOWs, a wait loop can now check for:
481          *      the current sequence not being found on the committing list;
482          *      an empty CIL; and
483          *      an unchanged sequence number
484          * to detect a push that had nothing to do and therefore does not need
485          * waiting on. If the CIL is not empty, we get put on the committing
486          * list before emptying the CIL and bumping the sequence number. Hence
487          * an empty CIL and an unchanged sequence number means we jumped out
488          * above after doing nothing.
489          *
490          * Hence the waiter will either find the commit sequence on the
491          * committing list or the sequence number will be unchanged and the CIL
492          * still dirty. In that latter case, the push has not yet started, and
493          * so the waiter will have to continue trying to check the CIL
494          * committing list until it is found. In extreme cases of delay, the
495          * sequence may fully commit between the attempts the wait makes to wait
496          * on the commit sequence.
497          */
498         list_add(&ctx->committing, &cil->xc_committing);
499         spin_unlock(&cil->xc_push_lock);
500 
501         /*
502          * pull all the log vectors off the items in the CIL, and
503          * remove the items from the CIL. We don't need the CIL lock
504          * here because it's only needed on the transaction commit
505          * side which is currently locked out by the flush lock.
506          */
507         lv = NULL;
508         num_iovecs = 0;
509         while (!list_empty(&cil->xc_cil)) {
510                 struct xfs_log_item     *item;
511 
512                 item = list_first_entry(&cil->xc_cil,
513                                         struct xfs_log_item, li_cil);
514                 list_del_init(&item->li_cil);
515                 if (!ctx->lv_chain)
516                         ctx->lv_chain = item->li_lv;
517                 else
518                         lv->lv_next = item->li_lv;
519                 lv = item->li_lv;
520                 item->li_lv = NULL;
521                 num_iovecs += lv->lv_niovecs;
522         }
523 
524         /*
525          * initialise the new context and attach it to the CIL. Then attach
526          * the current context to the CIL committing lsit so it can be found
527          * during log forces to extract the commit lsn of the sequence that
528          * needs to be forced.
529          */
530         INIT_LIST_HEAD(&new_ctx->committing);
531         INIT_LIST_HEAD(&new_ctx->busy_extents);
532         new_ctx->sequence = ctx->sequence + 1;
533         new_ctx->cil = cil;
534         cil->xc_ctx = new_ctx;
535 
536         /*
537          * The switch is now done, so we can drop the context lock and move out
538          * of a shared context. We can't just go straight to the commit record,
539          * though - we need to synchronise with previous and future commits so
540          * that the commit records are correctly ordered in the log to ensure
541          * that we process items during log IO completion in the correct order.
542          *
543          * For example, if we get an EFI in one checkpoint and the EFD in the
544          * next (e.g. due to log forces), we do not want the checkpoint with
545          * the EFD to be committed before the checkpoint with the EFI.  Hence
546          * we must strictly order the commit records of the checkpoints so
547          * that: a) the checkpoint callbacks are attached to the iclogs in the
548          * correct order; and b) the checkpoints are replayed in correct order
549          * in log recovery.
550          *
551          * Hence we need to add this context to the committing context list so
552          * that higher sequences will wait for us to write out a commit record
553          * before they do.
554          *
555          * xfs_log_force_lsn requires us to mirror the new sequence into the cil
556          * structure atomically with the addition of this sequence to the
557          * committing list. This also ensures that we can do unlocked checks
558          * against the current sequence in log forces without risking
559          * deferencing a freed context pointer.
560          */
561         spin_lock(&cil->xc_push_lock);
562         cil->xc_current_sequence = new_ctx->sequence;
563         spin_unlock(&cil->xc_push_lock);
564         up_write(&cil->xc_ctx_lock);
565 
566         /*
567          * Build a checkpoint transaction header and write it to the log to
568          * begin the transaction. We need to account for the space used by the
569          * transaction header here as it is not accounted for in xlog_write().
570          *
571          * The LSN we need to pass to the log items on transaction commit is
572          * the LSN reported by the first log vector write. If we use the commit
573          * record lsn then we can move the tail beyond the grant write head.
574          */
575         tic = ctx->ticket;
576         thdr.th_magic = XFS_TRANS_HEADER_MAGIC;
577         thdr.th_type = XFS_TRANS_CHECKPOINT;
578         thdr.th_tid = tic->t_tid;
579         thdr.th_num_items = num_iovecs;
580         lhdr.i_addr = &thdr;
581         lhdr.i_len = sizeof(xfs_trans_header_t);
582         lhdr.i_type = XLOG_REG_TYPE_TRANSHDR;
583         tic->t_curr_res -= lhdr.i_len + sizeof(xlog_op_header_t);
584 
585         lvhdr.lv_niovecs = 1;
586         lvhdr.lv_iovecp = &lhdr;
587         lvhdr.lv_next = ctx->lv_chain;
588 
589         error = xlog_write(log, &lvhdr, tic, &ctx->start_lsn, NULL, 0);
590         if (error)
591                 goto out_abort_free_ticket;
592 
593         /*
594          * now that we've written the checkpoint into the log, strictly
595          * order the commit records so replay will get them in the right order.
596          */
597 restart:
598         spin_lock(&cil->xc_push_lock);
599         list_for_each_entry(new_ctx, &cil->xc_committing, committing) {
600                 /*
601                  * Avoid getting stuck in this loop because we were woken by the
602                  * shutdown, but then went back to sleep once already in the
603                  * shutdown state.
604                  */
605                 if (XLOG_FORCED_SHUTDOWN(log)) {
606                         spin_unlock(&cil->xc_push_lock);
607                         goto out_abort_free_ticket;
608                 }
609 
610                 /*
611                  * Higher sequences will wait for this one so skip them.
612                  * Don't wait for our own sequence, either.
613                  */
614                 if (new_ctx->sequence >= ctx->sequence)
615                         continue;
616                 if (!new_ctx->commit_lsn) {
617                         /*
618                          * It is still being pushed! Wait for the push to
619                          * complete, then start again from the beginning.
620                          */
621                         xlog_wait(&cil->xc_commit_wait, &cil->xc_push_lock);
622                         goto restart;
623                 }
624         }
625         spin_unlock(&cil->xc_push_lock);
626 
627         /* xfs_log_done always frees the ticket on error. */
628         commit_lsn = xfs_log_done(log->l_mp, tic, &commit_iclog, 0);
629         if (commit_lsn == -1)
630                 goto out_abort;
631 
632         /* attach all the transactions w/ busy extents to iclog */
633         ctx->log_cb.cb_func = xlog_cil_committed;
634         ctx->log_cb.cb_arg = ctx;
635         error = xfs_log_notify(log->l_mp, commit_iclog, &ctx->log_cb);
636         if (error)
637                 goto out_abort;
638 
639         /*
640          * now the checkpoint commit is complete and we've attached the
641          * callbacks to the iclog we can assign the commit LSN to the context
642          * and wake up anyone who is waiting for the commit to complete.
643          */
644         spin_lock(&cil->xc_push_lock);
645         ctx->commit_lsn = commit_lsn;
646         wake_up_all(&cil->xc_commit_wait);
647         spin_unlock(&cil->xc_push_lock);
648 
649         /* release the hounds! */
650         return xfs_log_release_iclog(log->l_mp, commit_iclog);
651 
652 out_skip:
653         up_write(&cil->xc_ctx_lock);
654         xfs_log_ticket_put(new_ctx->ticket);
655         kmem_free(new_ctx);
656         return 0;
657 
658 out_abort_free_ticket:
659         xfs_log_ticket_put(tic);
660 out_abort:
661         xlog_cil_committed(ctx, XFS_LI_ABORTED);
662         return -EIO;
663 }
664 
665 static void
666 xlog_cil_push_work(
667         struct work_struct      *work)
668 {
669         struct xfs_cil          *cil = container_of(work, struct xfs_cil,
670                                                         xc_push_work);
671         xlog_cil_push(cil->xc_log);
672 }
673 
674 /*
675  * We need to push CIL every so often so we don't cache more than we can fit in
676  * the log. The limit really is that a checkpoint can't be more than half the
677  * log (the current checkpoint is not allowed to overwrite the previous
678  * checkpoint), but commit latency and memory usage limit this to a smaller
679  * size.
680  */
681 static void
682 xlog_cil_push_background(
683         struct xlog     *log)
684 {
685         struct xfs_cil  *cil = log->l_cilp;
686 
687         /*
688          * The cil won't be empty because we are called while holding the
689          * context lock so whatever we added to the CIL will still be there
690          */
691         ASSERT(!list_empty(&cil->xc_cil));
692 
693         /*
694          * don't do a background push if we haven't used up all the
695          * space available yet.
696          */
697         if (cil->xc_ctx->space_used < XLOG_CIL_SPACE_LIMIT(log))
698                 return;
699 
700         spin_lock(&cil->xc_push_lock);
701         if (cil->xc_push_seq < cil->xc_current_sequence) {
702                 cil->xc_push_seq = cil->xc_current_sequence;
703                 queue_work(log->l_mp->m_cil_workqueue, &cil->xc_push_work);
704         }
705         spin_unlock(&cil->xc_push_lock);
706 
707 }
708 
709 /*
710  * xlog_cil_push_now() is used to trigger an immediate CIL push to the sequence
711  * number that is passed. When it returns, the work will be queued for
712  * @push_seq, but it won't be completed. The caller is expected to do any
713  * waiting for push_seq to complete if it is required.
714  */
715 static void
716 xlog_cil_push_now(
717         struct xlog     *log,
718         xfs_lsn_t       push_seq)
719 {
720         struct xfs_cil  *cil = log->l_cilp;
721 
722         if (!cil)
723                 return;
724 
725         ASSERT(push_seq && push_seq <= cil->xc_current_sequence);
726 
727         /* start on any pending background push to minimise wait time on it */
728         flush_work(&cil->xc_push_work);
729 
730         /*
731          * If the CIL is empty or we've already pushed the sequence then
732          * there's no work we need to do.
733          */
734         spin_lock(&cil->xc_push_lock);
735         if (list_empty(&cil->xc_cil) || push_seq <= cil->xc_push_seq) {
736                 spin_unlock(&cil->xc_push_lock);
737                 return;
738         }
739 
740         cil->xc_push_seq = push_seq;
741         queue_work(log->l_mp->m_cil_workqueue, &cil->xc_push_work);
742         spin_unlock(&cil->xc_push_lock);
743 }
744 
745 bool
746 xlog_cil_empty(
747         struct xlog     *log)
748 {
749         struct xfs_cil  *cil = log->l_cilp;
750         bool            empty = false;
751 
752         spin_lock(&cil->xc_push_lock);
753         if (list_empty(&cil->xc_cil))
754                 empty = true;
755         spin_unlock(&cil->xc_push_lock);
756         return empty;
757 }
758 
759 /*
760  * Commit a transaction with the given vector to the Committed Item List.
761  *
762  * To do this, we need to format the item, pin it in memory if required and
763  * account for the space used by the transaction. Once we have done that we
764  * need to release the unused reservation for the transaction, attach the
765  * transaction to the checkpoint context so we carry the busy extents through
766  * to checkpoint completion, and then unlock all the items in the transaction.
767  *
768  * Called with the context lock already held in read mode to lock out
769  * background commit, returns without it held once background commits are
770  * allowed again.
771  */
772 void
773 xfs_log_commit_cil(
774         struct xfs_mount        *mp,
775         struct xfs_trans        *tp,
776         xfs_lsn_t               *commit_lsn,
777         int                     flags)
778 {
779         struct xlog             *log = mp->m_log;
780         struct xfs_cil          *cil = log->l_cilp;
781         int                     log_flags = 0;
782 
783         if (flags & XFS_TRANS_RELEASE_LOG_RES)
784                 log_flags = XFS_LOG_REL_PERM_RESERV;
785 
786         /* lock out background commit */
787         down_read(&cil->xc_ctx_lock);
788 
789         xlog_cil_insert_items(log, tp);
790 
791         /* check we didn't blow the reservation */
792         if (tp->t_ticket->t_curr_res < 0)
793                 xlog_print_tic_res(mp, tp->t_ticket);
794 
795         tp->t_commit_lsn = cil->xc_ctx->sequence;
796         if (commit_lsn)
797                 *commit_lsn = tp->t_commit_lsn;
798 
799         xfs_log_done(mp, tp->t_ticket, NULL, log_flags);
800         xfs_trans_unreserve_and_mod_sb(tp);
801 
802         /*
803          * Once all the items of the transaction have been copied to the CIL,
804          * the items can be unlocked and freed.
805          *
806          * This needs to be done before we drop the CIL context lock because we
807          * have to update state in the log items and unlock them before they go
808          * to disk. If we don't, then the CIL checkpoint can race with us and
809          * we can run checkpoint completion before we've updated and unlocked
810          * the log items. This affects (at least) processing of stale buffers,
811          * inodes and EFIs.
812          */
813         xfs_trans_free_items(tp, tp->t_commit_lsn, 0);
814 
815         xlog_cil_push_background(log);
816 
817         up_read(&cil->xc_ctx_lock);
818 }
819 
820 /*
821  * Conditionally push the CIL based on the sequence passed in.
822  *
823  * We only need to push if we haven't already pushed the sequence
824  * number given. Hence the only time we will trigger a push here is
825  * if the push sequence is the same as the current context.
826  *
827  * We return the current commit lsn to allow the callers to determine if a
828  * iclog flush is necessary following this call.
829  */
830 xfs_lsn_t
831 xlog_cil_force_lsn(
832         struct xlog     *log,
833         xfs_lsn_t       sequence)
834 {
835         struct xfs_cil          *cil = log->l_cilp;
836         struct xfs_cil_ctx      *ctx;
837         xfs_lsn_t               commit_lsn = NULLCOMMITLSN;
838 
839         ASSERT(sequence <= cil->xc_current_sequence);
840 
841         /*
842          * check to see if we need to force out the current context.
843          * xlog_cil_push() handles racing pushes for the same sequence,
844          * so no need to deal with it here.
845          */
846 restart:
847         xlog_cil_push_now(log, sequence);
848 
849         /*
850          * See if we can find a previous sequence still committing.
851          * We need to wait for all previous sequence commits to complete
852          * before allowing the force of push_seq to go ahead. Hence block
853          * on commits for those as well.
854          */
855         spin_lock(&cil->xc_push_lock);
856         list_for_each_entry(ctx, &cil->xc_committing, committing) {
857                 /*
858                  * Avoid getting stuck in this loop because we were woken by the
859                  * shutdown, but then went back to sleep once already in the
860                  * shutdown state.
861                  */
862                 if (XLOG_FORCED_SHUTDOWN(log))
863                         goto out_shutdown;
864                 if (ctx->sequence > sequence)
865                         continue;
866                 if (!ctx->commit_lsn) {
867                         /*
868                          * It is still being pushed! Wait for the push to
869                          * complete, then start again from the beginning.
870                          */
871                         xlog_wait(&cil->xc_commit_wait, &cil->xc_push_lock);
872                         goto restart;
873                 }
874                 if (ctx->sequence != sequence)
875                         continue;
876                 /* found it! */
877                 commit_lsn = ctx->commit_lsn;
878         }
879 
880         /*
881          * The call to xlog_cil_push_now() executes the push in the background.
882          * Hence by the time we have got here it our sequence may not have been
883          * pushed yet. This is true if the current sequence still matches the
884          * push sequence after the above wait loop and the CIL still contains
885          * dirty objects. This is guaranteed by the push code first adding the
886          * context to the committing list before emptying the CIL.
887          *
888          * Hence if we don't find the context in the committing list and the
889          * current sequence number is unchanged then the CIL contents are
890          * significant.  If the CIL is empty, if means there was nothing to push
891          * and that means there is nothing to wait for. If the CIL is not empty,
892          * it means we haven't yet started the push, because if it had started
893          * we would have found the context on the committing list.
894          */
895         if (sequence == cil->xc_current_sequence &&
896             !list_empty(&cil->xc_cil)) {
897                 spin_unlock(&cil->xc_push_lock);
898                 goto restart;
899         }
900 
901         spin_unlock(&cil->xc_push_lock);
902         return commit_lsn;
903 
904         /*
905          * We detected a shutdown in progress. We need to trigger the log force
906          * to pass through it's iclog state machine error handling, even though
907          * we are already in a shutdown state. Hence we can't return
908          * NULLCOMMITLSN here as that has special meaning to log forces (i.e.
909          * LSN is already stable), so we return a zero LSN instead.
910          */
911 out_shutdown:
912         spin_unlock(&cil->xc_push_lock);
913         return 0;
914 }
915 
916 /*
917  * Check if the current log item was first committed in this sequence.
918  * We can't rely on just the log item being in the CIL, we have to check
919  * the recorded commit sequence number.
920  *
921  * Note: for this to be used in a non-racy manner, it has to be called with
922  * CIL flushing locked out. As a result, it should only be used during the
923  * transaction commit process when deciding what to format into the item.
924  */
925 bool
926 xfs_log_item_in_current_chkpt(
927         struct xfs_log_item *lip)
928 {
929         struct xfs_cil_ctx *ctx;
930 
931         if (list_empty(&lip->li_cil))
932                 return false;
933 
934         ctx = lip->li_mountp->m_log->l_cilp->xc_ctx;
935 
936         /*
937          * li_seq is written on the first commit of a log item to record the
938          * first checkpoint it is written to. Hence if it is different to the
939          * current sequence, we're in a new checkpoint.
940          */
941         if (XFS_LSN_CMP(lip->li_seq, ctx->sequence) != 0)
942                 return false;
943         return true;
944 }
945 
946 /*
947  * Perform initial CIL structure initialisation.
948  */
949 int
950 xlog_cil_init(
951         struct xlog     *log)
952 {
953         struct xfs_cil  *cil;
954         struct xfs_cil_ctx *ctx;
955 
956         cil = kmem_zalloc(sizeof(*cil), KM_SLEEP|KM_MAYFAIL);
957         if (!cil)
958                 return -ENOMEM;
959 
960         ctx = kmem_zalloc(sizeof(*ctx), KM_SLEEP|KM_MAYFAIL);
961         if (!ctx) {
962                 kmem_free(cil);
963                 return -ENOMEM;
964         }
965 
966         INIT_WORK(&cil->xc_push_work, xlog_cil_push_work);
967         INIT_LIST_HEAD(&cil->xc_cil);
968         INIT_LIST_HEAD(&cil->xc_committing);
969         spin_lock_init(&cil->xc_cil_lock);
970         spin_lock_init(&cil->xc_push_lock);
971         init_rwsem(&cil->xc_ctx_lock);
972         init_waitqueue_head(&cil->xc_commit_wait);
973 
974         INIT_LIST_HEAD(&ctx->committing);
975         INIT_LIST_HEAD(&ctx->busy_extents);
976         ctx->sequence = 1;
977         ctx->cil = cil;
978         cil->xc_ctx = ctx;
979         cil->xc_current_sequence = ctx->sequence;
980 
981         cil->xc_log = log;
982         log->l_cilp = cil;
983         return 0;
984 }
985 
986 void
987 xlog_cil_destroy(
988         struct xlog     *log)
989 {
990         if (log->l_cilp->xc_ctx) {
991                 if (log->l_cilp->xc_ctx->ticket)
992                         xfs_log_ticket_put(log->l_cilp->xc_ctx->ticket);
993                 kmem_free(log->l_cilp->xc_ctx);
994         }
995 
996         ASSERT(list_empty(&log->l_cilp->xc_cil));
997         kmem_free(log->l_cilp);
998 }
999 
1000 

~ [ 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