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

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

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

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