Merge branch 'for-linus' of git://oss.sgi.com/xfs/xfs
[pandora-kernel.git] / fs / xfs / xfs_log.c
1 /*
2  * Copyright (c) 2000-2005 Silicon Graphics, Inc.
3  * All Rights Reserved.
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License as
7  * published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it would be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write the Free Software Foundation,
16  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17  */
18 #include "xfs.h"
19 #include "xfs_fs.h"
20 #include "xfs_types.h"
21 #include "xfs_bit.h"
22 #include "xfs_log.h"
23 #include "xfs_inum.h"
24 #include "xfs_trans.h"
25 #include "xfs_sb.h"
26 #include "xfs_ag.h"
27 #include "xfs_dir2.h"
28 #include "xfs_dmapi.h"
29 #include "xfs_mount.h"
30 #include "xfs_error.h"
31 #include "xfs_log_priv.h"
32 #include "xfs_buf_item.h"
33 #include "xfs_bmap_btree.h"
34 #include "xfs_alloc_btree.h"
35 #include "xfs_ialloc_btree.h"
36 #include "xfs_log_recover.h"
37 #include "xfs_trans_priv.h"
38 #include "xfs_dir2_sf.h"
39 #include "xfs_attr_sf.h"
40 #include "xfs_dinode.h"
41 #include "xfs_inode.h"
42 #include "xfs_rw.h"
43 #include "xfs_trace.h"
44
45 kmem_zone_t     *xfs_log_ticket_zone;
46
47 /* Local miscellaneous function prototypes */
48 STATIC int       xlog_commit_record(struct log *log, struct xlog_ticket *ticket,
49                                     xlog_in_core_t **, xfs_lsn_t *);
50 STATIC xlog_t *  xlog_alloc_log(xfs_mount_t     *mp,
51                                 xfs_buftarg_t   *log_target,
52                                 xfs_daddr_t     blk_offset,
53                                 int             num_bblks);
54 STATIC int       xlog_space_left(xlog_t *log, int cycle, int bytes);
55 STATIC int       xlog_sync(xlog_t *log, xlog_in_core_t *iclog);
56 STATIC void      xlog_dealloc_log(xlog_t *log);
57 STATIC int       xlog_write(struct log *log, struct xfs_log_vec *log_vector,
58                             struct xlog_ticket *tic, xfs_lsn_t *start_lsn,
59                             xlog_in_core_t **commit_iclog, uint flags);
60
61 /* local state machine functions */
62 STATIC void xlog_state_done_syncing(xlog_in_core_t *iclog, int);
63 STATIC void xlog_state_do_callback(xlog_t *log,int aborted, xlog_in_core_t *iclog);
64 STATIC int  xlog_state_get_iclog_space(xlog_t           *log,
65                                        int              len,
66                                        xlog_in_core_t   **iclog,
67                                        xlog_ticket_t    *ticket,
68                                        int              *continued_write,
69                                        int              *logoffsetp);
70 STATIC int  xlog_state_release_iclog(xlog_t             *log,
71                                      xlog_in_core_t     *iclog);
72 STATIC void xlog_state_switch_iclogs(xlog_t             *log,
73                                      xlog_in_core_t *iclog,
74                                      int                eventual_size);
75 STATIC void xlog_state_want_sync(xlog_t *log, xlog_in_core_t *iclog);
76
77 /* local functions to manipulate grant head */
78 STATIC int  xlog_grant_log_space(xlog_t         *log,
79                                  xlog_ticket_t  *xtic);
80 STATIC void xlog_grant_push_ail(xfs_mount_t     *mp,
81                                 int             need_bytes);
82 STATIC void xlog_regrant_reserve_log_space(xlog_t        *log,
83                                            xlog_ticket_t *ticket);
84 STATIC int xlog_regrant_write_log_space(xlog_t          *log,
85                                          xlog_ticket_t  *ticket);
86 STATIC void xlog_ungrant_log_space(xlog_t        *log,
87                                    xlog_ticket_t *ticket);
88
89
90 /* local ticket functions */
91 STATIC xlog_ticket_t    *xlog_ticket_alloc(xlog_t *log,
92                                          int    unit_bytes,
93                                          int    count,
94                                          char   clientid,
95                                          uint   flags);
96
97 #if defined(DEBUG)
98 STATIC void     xlog_verify_dest_ptr(xlog_t *log, char *ptr);
99 STATIC void     xlog_verify_grant_head(xlog_t *log, int equals);
100 STATIC void     xlog_verify_iclog(xlog_t *log, xlog_in_core_t *iclog,
101                                   int count, boolean_t syncing);
102 STATIC void     xlog_verify_tail_lsn(xlog_t *log, xlog_in_core_t *iclog,
103                                      xfs_lsn_t tail_lsn);
104 #else
105 #define xlog_verify_dest_ptr(a,b)
106 #define xlog_verify_grant_head(a,b)
107 #define xlog_verify_iclog(a,b,c,d)
108 #define xlog_verify_tail_lsn(a,b,c)
109 #endif
110
111 STATIC int      xlog_iclogs_empty(xlog_t *log);
112
113
114 static void
115 xlog_ins_ticketq(struct xlog_ticket **qp, struct xlog_ticket *tic)
116 {
117         if (*qp) {
118                 tic->t_next         = (*qp);
119                 tic->t_prev         = (*qp)->t_prev;
120                 (*qp)->t_prev->t_next = tic;
121                 (*qp)->t_prev       = tic;
122         } else {
123                 tic->t_prev = tic->t_next = tic;
124                 *qp = tic;
125         }
126
127         tic->t_flags |= XLOG_TIC_IN_Q;
128 }
129
130 static void
131 xlog_del_ticketq(struct xlog_ticket **qp, struct xlog_ticket *tic)
132 {
133         if (tic == tic->t_next) {
134                 *qp = NULL;
135         } else {
136                 *qp = tic->t_next;
137                 tic->t_next->t_prev = tic->t_prev;
138                 tic->t_prev->t_next = tic->t_next;
139         }
140
141         tic->t_next = tic->t_prev = NULL;
142         tic->t_flags &= ~XLOG_TIC_IN_Q;
143 }
144
145 static void
146 xlog_grant_sub_space(struct log *log, int bytes)
147 {
148         log->l_grant_write_bytes -= bytes;
149         if (log->l_grant_write_bytes < 0) {
150                 log->l_grant_write_bytes += log->l_logsize;
151                 log->l_grant_write_cycle--;
152         }
153
154         log->l_grant_reserve_bytes -= bytes;
155         if ((log)->l_grant_reserve_bytes < 0) {
156                 log->l_grant_reserve_bytes += log->l_logsize;
157                 log->l_grant_reserve_cycle--;
158         }
159
160 }
161
162 static void
163 xlog_grant_add_space_write(struct log *log, int bytes)
164 {
165         int tmp = log->l_logsize - log->l_grant_write_bytes;
166         if (tmp > bytes)
167                 log->l_grant_write_bytes += bytes;
168         else {
169                 log->l_grant_write_cycle++;
170                 log->l_grant_write_bytes = bytes - tmp;
171         }
172 }
173
174 static void
175 xlog_grant_add_space_reserve(struct log *log, int bytes)
176 {
177         int tmp = log->l_logsize - log->l_grant_reserve_bytes;
178         if (tmp > bytes)
179                 log->l_grant_reserve_bytes += bytes;
180         else {
181                 log->l_grant_reserve_cycle++;
182                 log->l_grant_reserve_bytes = bytes - tmp;
183         }
184 }
185
186 static inline void
187 xlog_grant_add_space(struct log *log, int bytes)
188 {
189         xlog_grant_add_space_write(log, bytes);
190         xlog_grant_add_space_reserve(log, bytes);
191 }
192
193 static void
194 xlog_tic_reset_res(xlog_ticket_t *tic)
195 {
196         tic->t_res_num = 0;
197         tic->t_res_arr_sum = 0;
198         tic->t_res_num_ophdrs = 0;
199 }
200
201 static void
202 xlog_tic_add_region(xlog_ticket_t *tic, uint len, uint type)
203 {
204         if (tic->t_res_num == XLOG_TIC_LEN_MAX) {
205                 /* add to overflow and start again */
206                 tic->t_res_o_flow += tic->t_res_arr_sum;
207                 tic->t_res_num = 0;
208                 tic->t_res_arr_sum = 0;
209         }
210
211         tic->t_res_arr[tic->t_res_num].r_len = len;
212         tic->t_res_arr[tic->t_res_num].r_type = type;
213         tic->t_res_arr_sum += len;
214         tic->t_res_num++;
215 }
216
217 /*
218  * NOTES:
219  *
220  *      1. currblock field gets updated at startup and after in-core logs
221  *              marked as with WANT_SYNC.
222  */
223
224 /*
225  * This routine is called when a user of a log manager ticket is done with
226  * the reservation.  If the ticket was ever used, then a commit record for
227  * the associated transaction is written out as a log operation header with
228  * no data.  The flag XLOG_TIC_INITED is set when the first write occurs with
229  * a given ticket.  If the ticket was one with a permanent reservation, then
230  * a few operations are done differently.  Permanent reservation tickets by
231  * default don't release the reservation.  They just commit the current
232  * transaction with the belief that the reservation is still needed.  A flag
233  * must be passed in before permanent reservations are actually released.
234  * When these type of tickets are not released, they need to be set into
235  * the inited state again.  By doing this, a start record will be written
236  * out when the next write occurs.
237  */
238 xfs_lsn_t
239 xfs_log_done(
240         struct xfs_mount        *mp,
241         struct xlog_ticket      *ticket,
242         struct xlog_in_core     **iclog,
243         uint                    flags)
244 {
245         struct log              *log = mp->m_log;
246         xfs_lsn_t               lsn = 0;
247
248         if (XLOG_FORCED_SHUTDOWN(log) ||
249             /*
250              * If nothing was ever written, don't write out commit record.
251              * If we get an error, just continue and give back the log ticket.
252              */
253             (((ticket->t_flags & XLOG_TIC_INITED) == 0) &&
254              (xlog_commit_record(log, ticket, iclog, &lsn)))) {
255                 lsn = (xfs_lsn_t) -1;
256                 if (ticket->t_flags & XLOG_TIC_PERM_RESERV) {
257                         flags |= XFS_LOG_REL_PERM_RESERV;
258                 }
259         }
260
261
262         if ((ticket->t_flags & XLOG_TIC_PERM_RESERV) == 0 ||
263             (flags & XFS_LOG_REL_PERM_RESERV)) {
264                 trace_xfs_log_done_nonperm(log, ticket);
265
266                 /*
267                  * Release ticket if not permanent reservation or a specific
268                  * request has been made to release a permanent reservation.
269                  */
270                 xlog_ungrant_log_space(log, ticket);
271                 xfs_log_ticket_put(ticket);
272         } else {
273                 trace_xfs_log_done_perm(log, ticket);
274
275                 xlog_regrant_reserve_log_space(log, ticket);
276                 /* If this ticket was a permanent reservation and we aren't
277                  * trying to release it, reset the inited flags; so next time
278                  * we write, a start record will be written out.
279                  */
280                 ticket->t_flags |= XLOG_TIC_INITED;
281         }
282
283         return lsn;
284 }
285
286 /*
287  * Attaches a new iclog I/O completion callback routine during
288  * transaction commit.  If the log is in error state, a non-zero
289  * return code is handed back and the caller is responsible for
290  * executing the callback at an appropriate time.
291  */
292 int
293 xfs_log_notify(
294         struct xfs_mount        *mp,
295         struct xlog_in_core     *iclog,
296         xfs_log_callback_t      *cb)
297 {
298         int     abortflg;
299
300         spin_lock(&iclog->ic_callback_lock);
301         abortflg = (iclog->ic_state & XLOG_STATE_IOERROR);
302         if (!abortflg) {
303                 ASSERT_ALWAYS((iclog->ic_state == XLOG_STATE_ACTIVE) ||
304                               (iclog->ic_state == XLOG_STATE_WANT_SYNC));
305                 cb->cb_next = NULL;
306                 *(iclog->ic_callback_tail) = cb;
307                 iclog->ic_callback_tail = &(cb->cb_next);
308         }
309         spin_unlock(&iclog->ic_callback_lock);
310         return abortflg;
311 }
312
313 int
314 xfs_log_release_iclog(
315         struct xfs_mount        *mp,
316         struct xlog_in_core     *iclog)
317 {
318         if (xlog_state_release_iclog(mp->m_log, iclog)) {
319                 xfs_force_shutdown(mp, SHUTDOWN_LOG_IO_ERROR);
320                 return EIO;
321         }
322
323         return 0;
324 }
325
326 /*
327  *  1. Reserve an amount of on-disk log space and return a ticket corresponding
328  *      to the reservation.
329  *  2. Potentially, push buffers at tail of log to disk.
330  *
331  * Each reservation is going to reserve extra space for a log record header.
332  * When writes happen to the on-disk log, we don't subtract the length of the
333  * log record header from any reservation.  By wasting space in each
334  * reservation, we prevent over allocation problems.
335  */
336 int
337 xfs_log_reserve(
338         struct xfs_mount        *mp,
339         int                     unit_bytes,
340         int                     cnt,
341         struct xlog_ticket      **ticket,
342         __uint8_t               client,
343         uint                    flags,
344         uint                    t_type)
345 {
346         struct log              *log = mp->m_log;
347         struct xlog_ticket      *internal_ticket;
348         int                     retval = 0;
349
350         ASSERT(client == XFS_TRANSACTION || client == XFS_LOG);
351         ASSERT((flags & XFS_LOG_NOSLEEP) == 0);
352
353         if (XLOG_FORCED_SHUTDOWN(log))
354                 return XFS_ERROR(EIO);
355
356         XFS_STATS_INC(xs_try_logspace);
357
358
359         if (*ticket != NULL) {
360                 ASSERT(flags & XFS_LOG_PERM_RESERV);
361                 internal_ticket = *ticket;
362
363                 trace_xfs_log_reserve(log, internal_ticket);
364
365                 xlog_grant_push_ail(mp, internal_ticket->t_unit_res);
366                 retval = xlog_regrant_write_log_space(log, internal_ticket);
367         } else {
368                 /* may sleep if need to allocate more tickets */
369                 internal_ticket = xlog_ticket_alloc(log, unit_bytes, cnt,
370                                                   client, flags);
371                 if (!internal_ticket)
372                         return XFS_ERROR(ENOMEM);
373                 internal_ticket->t_trans_type = t_type;
374                 *ticket = internal_ticket;
375
376                 trace_xfs_log_reserve(log, internal_ticket);
377
378                 xlog_grant_push_ail(mp,
379                                     (internal_ticket->t_unit_res *
380                                      internal_ticket->t_cnt));
381                 retval = xlog_grant_log_space(log, internal_ticket);
382         }
383
384         return retval;
385 }       /* xfs_log_reserve */
386
387
388 /*
389  * Mount a log filesystem
390  *
391  * mp           - ubiquitous xfs mount point structure
392  * log_target   - buftarg of on-disk log device
393  * blk_offset   - Start block # where block size is 512 bytes (BBSIZE)
394  * num_bblocks  - Number of BBSIZE blocks in on-disk log
395  *
396  * Return error or zero.
397  */
398 int
399 xfs_log_mount(
400         xfs_mount_t     *mp,
401         xfs_buftarg_t   *log_target,
402         xfs_daddr_t     blk_offset,
403         int             num_bblks)
404 {
405         int             error;
406
407         if (!(mp->m_flags & XFS_MOUNT_NORECOVERY))
408                 cmn_err(CE_NOTE, "XFS mounting filesystem %s", mp->m_fsname);
409         else {
410                 cmn_err(CE_NOTE,
411                         "!Mounting filesystem \"%s\" in no-recovery mode.  Filesystem will be inconsistent.",
412                         mp->m_fsname);
413                 ASSERT(mp->m_flags & XFS_MOUNT_RDONLY);
414         }
415
416         mp->m_log = xlog_alloc_log(mp, log_target, blk_offset, num_bblks);
417         if (IS_ERR(mp->m_log)) {
418                 error = -PTR_ERR(mp->m_log);
419                 goto out;
420         }
421
422         /*
423          * Initialize the AIL now we have a log.
424          */
425         error = xfs_trans_ail_init(mp);
426         if (error) {
427                 cmn_err(CE_WARN, "XFS: AIL initialisation failed: error %d", error);
428                 goto out_free_log;
429         }
430         mp->m_log->l_ailp = mp->m_ail;
431
432         /*
433          * skip log recovery on a norecovery mount.  pretend it all
434          * just worked.
435          */
436         if (!(mp->m_flags & XFS_MOUNT_NORECOVERY)) {
437                 int     readonly = (mp->m_flags & XFS_MOUNT_RDONLY);
438
439                 if (readonly)
440                         mp->m_flags &= ~XFS_MOUNT_RDONLY;
441
442                 error = xlog_recover(mp->m_log);
443
444                 if (readonly)
445                         mp->m_flags |= XFS_MOUNT_RDONLY;
446                 if (error) {
447                         cmn_err(CE_WARN, "XFS: log mount/recovery failed: error %d", error);
448                         goto out_destroy_ail;
449                 }
450         }
451
452         /* Normal transactions can now occur */
453         mp->m_log->l_flags &= ~XLOG_ACTIVE_RECOVERY;
454
455         return 0;
456
457 out_destroy_ail:
458         xfs_trans_ail_destroy(mp);
459 out_free_log:
460         xlog_dealloc_log(mp->m_log);
461 out:
462         return error;
463 }
464
465 /*
466  * Finish the recovery of the file system.  This is separate from
467  * the xfs_log_mount() call, because it depends on the code in
468  * xfs_mountfs() to read in the root and real-time bitmap inodes
469  * between calling xfs_log_mount() and here.
470  *
471  * mp           - ubiquitous xfs mount point structure
472  */
473 int
474 xfs_log_mount_finish(xfs_mount_t *mp)
475 {
476         int     error;
477
478         if (!(mp->m_flags & XFS_MOUNT_NORECOVERY))
479                 error = xlog_recover_finish(mp->m_log);
480         else {
481                 error = 0;
482                 ASSERT(mp->m_flags & XFS_MOUNT_RDONLY);
483         }
484
485         return error;
486 }
487
488 /*
489  * Final log writes as part of unmount.
490  *
491  * Mark the filesystem clean as unmount happens.  Note that during relocation
492  * this routine needs to be executed as part of source-bag while the
493  * deallocation must not be done until source-end.
494  */
495
496 /*
497  * Unmount record used to have a string "Unmount filesystem--" in the
498  * data section where the "Un" was really a magic number (XLOG_UNMOUNT_TYPE).
499  * We just write the magic number now since that particular field isn't
500  * currently architecture converted and "nUmount" is a bit foo.
501  * As far as I know, there weren't any dependencies on the old behaviour.
502  */
503
504 int
505 xfs_log_unmount_write(xfs_mount_t *mp)
506 {
507         xlog_t           *log = mp->m_log;
508         xlog_in_core_t   *iclog;
509 #ifdef DEBUG
510         xlog_in_core_t   *first_iclog;
511 #endif
512         xlog_ticket_t   *tic = NULL;
513         xfs_lsn_t        lsn;
514         int              error;
515
516         /*
517          * Don't write out unmount record on read-only mounts.
518          * Or, if we are doing a forced umount (typically because of IO errors).
519          */
520         if (mp->m_flags & XFS_MOUNT_RDONLY)
521                 return 0;
522
523         error = _xfs_log_force(mp, XFS_LOG_SYNC, NULL);
524         ASSERT(error || !(XLOG_FORCED_SHUTDOWN(log)));
525
526 #ifdef DEBUG
527         first_iclog = iclog = log->l_iclog;
528         do {
529                 if (!(iclog->ic_state & XLOG_STATE_IOERROR)) {
530                         ASSERT(iclog->ic_state & XLOG_STATE_ACTIVE);
531                         ASSERT(iclog->ic_offset == 0);
532                 }
533                 iclog = iclog->ic_next;
534         } while (iclog != first_iclog);
535 #endif
536         if (! (XLOG_FORCED_SHUTDOWN(log))) {
537                 error = xfs_log_reserve(mp, 600, 1, &tic,
538                                         XFS_LOG, 0, XLOG_UNMOUNT_REC_TYPE);
539                 if (!error) {
540                         /* the data section must be 32 bit size aligned */
541                         struct {
542                             __uint16_t magic;
543                             __uint16_t pad1;
544                             __uint32_t pad2; /* may as well make it 64 bits */
545                         } magic = {
546                                 .magic = XLOG_UNMOUNT_TYPE,
547                         };
548                         struct xfs_log_iovec reg = {
549                                 .i_addr = (void *)&magic,
550                                 .i_len = sizeof(magic),
551                                 .i_type = XLOG_REG_TYPE_UNMOUNT,
552                         };
553                         struct xfs_log_vec vec = {
554                                 .lv_niovecs = 1,
555                                 .lv_iovecp = &reg,
556                         };
557
558                         /* remove inited flag */
559                         tic->t_flags = 0;
560                         error = xlog_write(log, &vec, tic, &lsn,
561                                            NULL, XLOG_UNMOUNT_TRANS);
562                         /*
563                          * At this point, we're umounting anyway,
564                          * so there's no point in transitioning log state
565                          * to IOERROR. Just continue...
566                          */
567                 }
568
569                 if (error) {
570                         xfs_fs_cmn_err(CE_ALERT, mp,
571                                 "xfs_log_unmount: unmount record failed");
572                 }
573
574
575                 spin_lock(&log->l_icloglock);
576                 iclog = log->l_iclog;
577                 atomic_inc(&iclog->ic_refcnt);
578                 xlog_state_want_sync(log, iclog);
579                 spin_unlock(&log->l_icloglock);
580                 error = xlog_state_release_iclog(log, iclog);
581
582                 spin_lock(&log->l_icloglock);
583                 if (!(iclog->ic_state == XLOG_STATE_ACTIVE ||
584                       iclog->ic_state == XLOG_STATE_DIRTY)) {
585                         if (!XLOG_FORCED_SHUTDOWN(log)) {
586                                 sv_wait(&iclog->ic_force_wait, PMEM,
587                                         &log->l_icloglock, s);
588                         } else {
589                                 spin_unlock(&log->l_icloglock);
590                         }
591                 } else {
592                         spin_unlock(&log->l_icloglock);
593                 }
594                 if (tic) {
595                         trace_xfs_log_umount_write(log, tic);
596                         xlog_ungrant_log_space(log, tic);
597                         xfs_log_ticket_put(tic);
598                 }
599         } else {
600                 /*
601                  * We're already in forced_shutdown mode, couldn't
602                  * even attempt to write out the unmount transaction.
603                  *
604                  * Go through the motions of sync'ing and releasing
605                  * the iclog, even though no I/O will actually happen,
606                  * we need to wait for other log I/Os that may already
607                  * be in progress.  Do this as a separate section of
608                  * code so we'll know if we ever get stuck here that
609                  * we're in this odd situation of trying to unmount
610                  * a file system that went into forced_shutdown as
611                  * the result of an unmount..
612                  */
613                 spin_lock(&log->l_icloglock);
614                 iclog = log->l_iclog;
615                 atomic_inc(&iclog->ic_refcnt);
616
617                 xlog_state_want_sync(log, iclog);
618                 spin_unlock(&log->l_icloglock);
619                 error =  xlog_state_release_iclog(log, iclog);
620
621                 spin_lock(&log->l_icloglock);
622
623                 if ( ! (   iclog->ic_state == XLOG_STATE_ACTIVE
624                         || iclog->ic_state == XLOG_STATE_DIRTY
625                         || iclog->ic_state == XLOG_STATE_IOERROR) ) {
626
627                                 sv_wait(&iclog->ic_force_wait, PMEM,
628                                         &log->l_icloglock, s);
629                 } else {
630                         spin_unlock(&log->l_icloglock);
631                 }
632         }
633
634         return error;
635 }       /* xfs_log_unmount_write */
636
637 /*
638  * Deallocate log structures for unmount/relocation.
639  *
640  * We need to stop the aild from running before we destroy
641  * and deallocate the log as the aild references the log.
642  */
643 void
644 xfs_log_unmount(xfs_mount_t *mp)
645 {
646         xfs_trans_ail_destroy(mp);
647         xlog_dealloc_log(mp->m_log);
648 }
649
650 void
651 xfs_log_item_init(
652         struct xfs_mount        *mp,
653         struct xfs_log_item     *item,
654         int                     type,
655         struct xfs_item_ops     *ops)
656 {
657         item->li_mountp = mp;
658         item->li_ailp = mp->m_ail;
659         item->li_type = type;
660         item->li_ops = ops;
661 }
662
663 /*
664  * Write region vectors to log.  The write happens using the space reservation
665  * of the ticket (tic).  It is not a requirement that all writes for a given
666  * transaction occur with one call to xfs_log_write(). However, it is important
667  * to note that the transaction reservation code makes an assumption about the
668  * number of log headers a transaction requires that may be violated if you
669  * don't pass all the transaction vectors in one call....
670  */
671 int
672 xfs_log_write(
673         struct xfs_mount        *mp,
674         struct xfs_log_iovec    reg[],
675         int                     nentries,
676         struct xlog_ticket      *tic,
677         xfs_lsn_t               *start_lsn)
678 {
679         struct log              *log = mp->m_log;
680         int                     error;
681         struct xfs_log_vec      vec = {
682                 .lv_niovecs = nentries,
683                 .lv_iovecp = reg,
684         };
685
686         if (XLOG_FORCED_SHUTDOWN(log))
687                 return XFS_ERROR(EIO);
688
689         error = xlog_write(log, &vec, tic, start_lsn, NULL, 0);
690         if (error)
691                 xfs_force_shutdown(mp, SHUTDOWN_LOG_IO_ERROR);
692         return error;
693 }
694
695 void
696 xfs_log_move_tail(xfs_mount_t   *mp,
697                   xfs_lsn_t     tail_lsn)
698 {
699         xlog_ticket_t   *tic;
700         xlog_t          *log = mp->m_log;
701         int             need_bytes, free_bytes, cycle, bytes;
702
703         if (XLOG_FORCED_SHUTDOWN(log))
704                 return;
705
706         if (tail_lsn == 0) {
707                 /* needed since sync_lsn is 64 bits */
708                 spin_lock(&log->l_icloglock);
709                 tail_lsn = log->l_last_sync_lsn;
710                 spin_unlock(&log->l_icloglock);
711         }
712
713         spin_lock(&log->l_grant_lock);
714
715         /* Also an invalid lsn.  1 implies that we aren't passing in a valid
716          * tail_lsn.
717          */
718         if (tail_lsn != 1) {
719                 log->l_tail_lsn = tail_lsn;
720         }
721
722         if ((tic = log->l_write_headq)) {
723 #ifdef DEBUG
724                 if (log->l_flags & XLOG_ACTIVE_RECOVERY)
725                         panic("Recovery problem");
726 #endif
727                 cycle = log->l_grant_write_cycle;
728                 bytes = log->l_grant_write_bytes;
729                 free_bytes = xlog_space_left(log, cycle, bytes);
730                 do {
731                         ASSERT(tic->t_flags & XLOG_TIC_PERM_RESERV);
732
733                         if (free_bytes < tic->t_unit_res && tail_lsn != 1)
734                                 break;
735                         tail_lsn = 0;
736                         free_bytes -= tic->t_unit_res;
737                         sv_signal(&tic->t_wait);
738                         tic = tic->t_next;
739                 } while (tic != log->l_write_headq);
740         }
741         if ((tic = log->l_reserve_headq)) {
742 #ifdef DEBUG
743                 if (log->l_flags & XLOG_ACTIVE_RECOVERY)
744                         panic("Recovery problem");
745 #endif
746                 cycle = log->l_grant_reserve_cycle;
747                 bytes = log->l_grant_reserve_bytes;
748                 free_bytes = xlog_space_left(log, cycle, bytes);
749                 do {
750                         if (tic->t_flags & XLOG_TIC_PERM_RESERV)
751                                 need_bytes = tic->t_unit_res*tic->t_cnt;
752                         else
753                                 need_bytes = tic->t_unit_res;
754                         if (free_bytes < need_bytes && tail_lsn != 1)
755                                 break;
756                         tail_lsn = 0;
757                         free_bytes -= need_bytes;
758                         sv_signal(&tic->t_wait);
759                         tic = tic->t_next;
760                 } while (tic != log->l_reserve_headq);
761         }
762         spin_unlock(&log->l_grant_lock);
763 }       /* xfs_log_move_tail */
764
765 /*
766  * Determine if we have a transaction that has gone to disk
767  * that needs to be covered. To begin the transition to the idle state
768  * firstly the log needs to be idle (no AIL and nothing in the iclogs).
769  * If we are then in a state where covering is needed, the caller is informed
770  * that dummy transactions are required to move the log into the idle state.
771  *
772  * Because this is called as part of the sync process, we should also indicate
773  * that dummy transactions should be issued in anything but the covered or
774  * idle states. This ensures that the log tail is accurately reflected in
775  * the log at the end of the sync, hence if a crash occurrs avoids replay
776  * of transactions where the metadata is already on disk.
777  */
778 int
779 xfs_log_need_covered(xfs_mount_t *mp)
780 {
781         int             needed = 0;
782         xlog_t          *log = mp->m_log;
783
784         if (!xfs_fs_writable(mp))
785                 return 0;
786
787         spin_lock(&log->l_icloglock);
788         switch (log->l_covered_state) {
789         case XLOG_STATE_COVER_DONE:
790         case XLOG_STATE_COVER_DONE2:
791         case XLOG_STATE_COVER_IDLE:
792                 break;
793         case XLOG_STATE_COVER_NEED:
794         case XLOG_STATE_COVER_NEED2:
795                 if (!xfs_trans_ail_tail(log->l_ailp) &&
796                     xlog_iclogs_empty(log)) {
797                         if (log->l_covered_state == XLOG_STATE_COVER_NEED)
798                                 log->l_covered_state = XLOG_STATE_COVER_DONE;
799                         else
800                                 log->l_covered_state = XLOG_STATE_COVER_DONE2;
801                 }
802                 /* FALLTHRU */
803         default:
804                 needed = 1;
805                 break;
806         }
807         spin_unlock(&log->l_icloglock);
808         return needed;
809 }
810
811 /******************************************************************************
812  *
813  *      local routines
814  *
815  ******************************************************************************
816  */
817
818 /* xfs_trans_tail_ail returns 0 when there is nothing in the list.
819  * The log manager must keep track of the last LR which was committed
820  * to disk.  The lsn of this LR will become the new tail_lsn whenever
821  * xfs_trans_tail_ail returns 0.  If we don't do this, we run into
822  * the situation where stuff could be written into the log but nothing
823  * was ever in the AIL when asked.  Eventually, we panic since the
824  * tail hits the head.
825  *
826  * We may be holding the log iclog lock upon entering this routine.
827  */
828 xfs_lsn_t
829 xlog_assign_tail_lsn(xfs_mount_t *mp)
830 {
831         xfs_lsn_t tail_lsn;
832         xlog_t    *log = mp->m_log;
833
834         tail_lsn = xfs_trans_ail_tail(mp->m_ail);
835         spin_lock(&log->l_grant_lock);
836         if (tail_lsn != 0) {
837                 log->l_tail_lsn = tail_lsn;
838         } else {
839                 tail_lsn = log->l_tail_lsn = log->l_last_sync_lsn;
840         }
841         spin_unlock(&log->l_grant_lock);
842
843         return tail_lsn;
844 }       /* xlog_assign_tail_lsn */
845
846
847 /*
848  * Return the space in the log between the tail and the head.  The head
849  * is passed in the cycle/bytes formal parms.  In the special case where
850  * the reserve head has wrapped passed the tail, this calculation is no
851  * longer valid.  In this case, just return 0 which means there is no space
852  * in the log.  This works for all places where this function is called
853  * with the reserve head.  Of course, if the write head were to ever
854  * wrap the tail, we should blow up.  Rather than catch this case here,
855  * we depend on other ASSERTions in other parts of the code.   XXXmiken
856  *
857  * This code also handles the case where the reservation head is behind
858  * the tail.  The details of this case are described below, but the end
859  * result is that we return the size of the log as the amount of space left.
860  */
861 STATIC int
862 xlog_space_left(xlog_t *log, int cycle, int bytes)
863 {
864         int free_bytes;
865         int tail_bytes;
866         int tail_cycle;
867
868         tail_bytes = BBTOB(BLOCK_LSN(log->l_tail_lsn));
869         tail_cycle = CYCLE_LSN(log->l_tail_lsn);
870         if ((tail_cycle == cycle) && (bytes >= tail_bytes)) {
871                 free_bytes = log->l_logsize - (bytes - tail_bytes);
872         } else if ((tail_cycle + 1) < cycle) {
873                 return 0;
874         } else if (tail_cycle < cycle) {
875                 ASSERT(tail_cycle == (cycle - 1));
876                 free_bytes = tail_bytes - bytes;
877         } else {
878                 /*
879                  * The reservation head is behind the tail.
880                  * In this case we just want to return the size of the
881                  * log as the amount of space left.
882                  */
883                 xfs_fs_cmn_err(CE_ALERT, log->l_mp,
884                         "xlog_space_left: head behind tail\n"
885                         "  tail_cycle = %d, tail_bytes = %d\n"
886                         "  GH   cycle = %d, GH   bytes = %d",
887                         tail_cycle, tail_bytes, cycle, bytes);
888                 ASSERT(0);
889                 free_bytes = log->l_logsize;
890         }
891         return free_bytes;
892 }       /* xlog_space_left */
893
894
895 /*
896  * Log function which is called when an io completes.
897  *
898  * The log manager needs its own routine, in order to control what
899  * happens with the buffer after the write completes.
900  */
901 void
902 xlog_iodone(xfs_buf_t *bp)
903 {
904         xlog_in_core_t  *iclog;
905         xlog_t          *l;
906         int             aborted;
907
908         iclog = XFS_BUF_FSPRIVATE(bp, xlog_in_core_t *);
909         ASSERT(XFS_BUF_FSPRIVATE2(bp, unsigned long) == (unsigned long) 2);
910         XFS_BUF_SET_FSPRIVATE2(bp, (unsigned long)1);
911         aborted = 0;
912         l = iclog->ic_log;
913
914         /*
915          * If the _XFS_BARRIER_FAILED flag was set by a lower
916          * layer, it means the underlying device no longer supports
917          * barrier I/O. Warn loudly and turn off barriers.
918          */
919         if (bp->b_flags & _XFS_BARRIER_FAILED) {
920                 bp->b_flags &= ~_XFS_BARRIER_FAILED;
921                 l->l_mp->m_flags &= ~XFS_MOUNT_BARRIER;
922                 xfs_fs_cmn_err(CE_WARN, l->l_mp,
923                                 "xlog_iodone: Barriers are no longer supported"
924                                 " by device. Disabling barriers\n");
925         }
926
927         /*
928          * Race to shutdown the filesystem if we see an error.
929          */
930         if (XFS_TEST_ERROR((XFS_BUF_GETERROR(bp)), l->l_mp,
931                         XFS_ERRTAG_IODONE_IOERR, XFS_RANDOM_IODONE_IOERR)) {
932                 xfs_ioerror_alert("xlog_iodone", l->l_mp, bp, XFS_BUF_ADDR(bp));
933                 XFS_BUF_STALE(bp);
934                 xfs_force_shutdown(l->l_mp, SHUTDOWN_LOG_IO_ERROR);
935                 /*
936                  * This flag will be propagated to the trans-committed
937                  * callback routines to let them know that the log-commit
938                  * didn't succeed.
939                  */
940                 aborted = XFS_LI_ABORTED;
941         } else if (iclog->ic_state & XLOG_STATE_IOERROR) {
942                 aborted = XFS_LI_ABORTED;
943         }
944
945         /* log I/O is always issued ASYNC */
946         ASSERT(XFS_BUF_ISASYNC(bp));
947         xlog_state_done_syncing(iclog, aborted);
948         /*
949          * do not reference the buffer (bp) here as we could race
950          * with it being freed after writing the unmount record to the
951          * log.
952          */
953
954 }       /* xlog_iodone */
955
956 /*
957  * Return size of each in-core log record buffer.
958  *
959  * All machines get 8 x 32kB buffers by default, unless tuned otherwise.
960  *
961  * If the filesystem blocksize is too large, we may need to choose a
962  * larger size since the directory code currently logs entire blocks.
963  */
964
965 STATIC void
966 xlog_get_iclog_buffer_size(xfs_mount_t  *mp,
967                            xlog_t       *log)
968 {
969         int size;
970         int xhdrs;
971
972         if (mp->m_logbufs <= 0)
973                 log->l_iclog_bufs = XLOG_MAX_ICLOGS;
974         else
975                 log->l_iclog_bufs = mp->m_logbufs;
976
977         /*
978          * Buffer size passed in from mount system call.
979          */
980         if (mp->m_logbsize > 0) {
981                 size = log->l_iclog_size = mp->m_logbsize;
982                 log->l_iclog_size_log = 0;
983                 while (size != 1) {
984                         log->l_iclog_size_log++;
985                         size >>= 1;
986                 }
987
988                 if (xfs_sb_version_haslogv2(&mp->m_sb)) {
989                         /* # headers = size / 32k
990                          * one header holds cycles from 32k of data
991                          */
992
993                         xhdrs = mp->m_logbsize / XLOG_HEADER_CYCLE_SIZE;
994                         if (mp->m_logbsize % XLOG_HEADER_CYCLE_SIZE)
995                                 xhdrs++;
996                         log->l_iclog_hsize = xhdrs << BBSHIFT;
997                         log->l_iclog_heads = xhdrs;
998                 } else {
999                         ASSERT(mp->m_logbsize <= XLOG_BIG_RECORD_BSIZE);
1000                         log->l_iclog_hsize = BBSIZE;
1001                         log->l_iclog_heads = 1;
1002                 }
1003                 goto done;
1004         }
1005
1006         /* All machines use 32kB buffers by default. */
1007         log->l_iclog_size = XLOG_BIG_RECORD_BSIZE;
1008         log->l_iclog_size_log = XLOG_BIG_RECORD_BSHIFT;
1009
1010         /* the default log size is 16k or 32k which is one header sector */
1011         log->l_iclog_hsize = BBSIZE;
1012         log->l_iclog_heads = 1;
1013
1014 done:
1015         /* are we being asked to make the sizes selected above visible? */
1016         if (mp->m_logbufs == 0)
1017                 mp->m_logbufs = log->l_iclog_bufs;
1018         if (mp->m_logbsize == 0)
1019                 mp->m_logbsize = log->l_iclog_size;
1020 }       /* xlog_get_iclog_buffer_size */
1021
1022
1023 /*
1024  * This routine initializes some of the log structure for a given mount point.
1025  * Its primary purpose is to fill in enough, so recovery can occur.  However,
1026  * some other stuff may be filled in too.
1027  */
1028 STATIC xlog_t *
1029 xlog_alloc_log(xfs_mount_t      *mp,
1030                xfs_buftarg_t    *log_target,
1031                xfs_daddr_t      blk_offset,
1032                int              num_bblks)
1033 {
1034         xlog_t                  *log;
1035         xlog_rec_header_t       *head;
1036         xlog_in_core_t          **iclogp;
1037         xlog_in_core_t          *iclog, *prev_iclog=NULL;
1038         xfs_buf_t               *bp;
1039         int                     i;
1040         int                     iclogsize;
1041         int                     error = ENOMEM;
1042         uint                    log2_size = 0;
1043
1044         log = kmem_zalloc(sizeof(xlog_t), KM_MAYFAIL);
1045         if (!log) {
1046                 xlog_warn("XFS: Log allocation failed: No memory!");
1047                 goto out;
1048         }
1049
1050         log->l_mp          = mp;
1051         log->l_targ        = log_target;
1052         log->l_logsize     = BBTOB(num_bblks);
1053         log->l_logBBstart  = blk_offset;
1054         log->l_logBBsize   = num_bblks;
1055         log->l_covered_state = XLOG_STATE_COVER_IDLE;
1056         log->l_flags       |= XLOG_ACTIVE_RECOVERY;
1057
1058         log->l_prev_block  = -1;
1059         log->l_tail_lsn    = xlog_assign_lsn(1, 0);
1060         /* log->l_tail_lsn = 0x100000000LL; cycle = 1; current block = 0 */
1061         log->l_last_sync_lsn = log->l_tail_lsn;
1062         log->l_curr_cycle  = 1;     /* 0 is bad since this is initial value */
1063         log->l_grant_reserve_cycle = 1;
1064         log->l_grant_write_cycle = 1;
1065
1066         error = EFSCORRUPTED;
1067         if (xfs_sb_version_hassector(&mp->m_sb)) {
1068                 log2_size = mp->m_sb.sb_logsectlog;
1069                 if (log2_size < BBSHIFT) {
1070                         xlog_warn("XFS: Log sector size too small "
1071                                 "(0x%x < 0x%x)", log2_size, BBSHIFT);
1072                         goto out_free_log;
1073                 }
1074
1075                 log2_size -= BBSHIFT;
1076                 if (log2_size > mp->m_sectbb_log) {
1077                         xlog_warn("XFS: Log sector size too large "
1078                                 "(0x%x > 0x%x)", log2_size, mp->m_sectbb_log);
1079                         goto out_free_log;
1080                 }
1081
1082                 /* for larger sector sizes, must have v2 or external log */
1083                 if (log2_size && log->l_logBBstart > 0 &&
1084                             !xfs_sb_version_haslogv2(&mp->m_sb)) {
1085
1086                         xlog_warn("XFS: log sector size (0x%x) invalid "
1087                                   "for configuration.", log2_size);
1088                         goto out_free_log;
1089                 }
1090         }
1091         log->l_sectBBsize = 1 << log2_size;
1092
1093         xlog_get_iclog_buffer_size(mp, log);
1094
1095         error = ENOMEM;
1096         bp = xfs_buf_get_empty(log->l_iclog_size, mp->m_logdev_targp);
1097         if (!bp)
1098                 goto out_free_log;
1099         XFS_BUF_SET_IODONE_FUNC(bp, xlog_iodone);
1100         XFS_BUF_SET_FSPRIVATE2(bp, (unsigned long)1);
1101         ASSERT(XFS_BUF_ISBUSY(bp));
1102         ASSERT(XFS_BUF_VALUSEMA(bp) <= 0);
1103         log->l_xbuf = bp;
1104
1105         spin_lock_init(&log->l_icloglock);
1106         spin_lock_init(&log->l_grant_lock);
1107         sv_init(&log->l_flush_wait, 0, "flush_wait");
1108
1109         /* log record size must be multiple of BBSIZE; see xlog_rec_header_t */
1110         ASSERT((XFS_BUF_SIZE(bp) & BBMASK) == 0);
1111
1112         iclogp = &log->l_iclog;
1113         /*
1114          * The amount of memory to allocate for the iclog structure is
1115          * rather funky due to the way the structure is defined.  It is
1116          * done this way so that we can use different sizes for machines
1117          * with different amounts of memory.  See the definition of
1118          * xlog_in_core_t in xfs_log_priv.h for details.
1119          */
1120         iclogsize = log->l_iclog_size;
1121         ASSERT(log->l_iclog_size >= 4096);
1122         for (i=0; i < log->l_iclog_bufs; i++) {
1123                 *iclogp = kmem_zalloc(sizeof(xlog_in_core_t), KM_MAYFAIL);
1124                 if (!*iclogp)
1125                         goto out_free_iclog;
1126
1127                 iclog = *iclogp;
1128                 iclog->ic_prev = prev_iclog;
1129                 prev_iclog = iclog;
1130
1131                 bp = xfs_buf_get_noaddr(log->l_iclog_size, mp->m_logdev_targp);
1132                 if (!bp)
1133                         goto out_free_iclog;
1134                 if (!XFS_BUF_CPSEMA(bp))
1135                         ASSERT(0);
1136                 XFS_BUF_SET_IODONE_FUNC(bp, xlog_iodone);
1137                 XFS_BUF_SET_FSPRIVATE2(bp, (unsigned long)1);
1138                 iclog->ic_bp = bp;
1139                 iclog->ic_data = bp->b_addr;
1140 #ifdef DEBUG
1141                 log->l_iclog_bak[i] = (xfs_caddr_t)&(iclog->ic_header);
1142 #endif
1143                 head = &iclog->ic_header;
1144                 memset(head, 0, sizeof(xlog_rec_header_t));
1145                 head->h_magicno = cpu_to_be32(XLOG_HEADER_MAGIC_NUM);
1146                 head->h_version = cpu_to_be32(
1147                         xfs_sb_version_haslogv2(&log->l_mp->m_sb) ? 2 : 1);
1148                 head->h_size = cpu_to_be32(log->l_iclog_size);
1149                 /* new fields */
1150                 head->h_fmt = cpu_to_be32(XLOG_FMT);
1151                 memcpy(&head->h_fs_uuid, &mp->m_sb.sb_uuid, sizeof(uuid_t));
1152
1153                 iclog->ic_size = XFS_BUF_SIZE(bp) - log->l_iclog_hsize;
1154                 iclog->ic_state = XLOG_STATE_ACTIVE;
1155                 iclog->ic_log = log;
1156                 atomic_set(&iclog->ic_refcnt, 0);
1157                 spin_lock_init(&iclog->ic_callback_lock);
1158                 iclog->ic_callback_tail = &(iclog->ic_callback);
1159                 iclog->ic_datap = (char *)iclog->ic_data + log->l_iclog_hsize;
1160
1161                 ASSERT(XFS_BUF_ISBUSY(iclog->ic_bp));
1162                 ASSERT(XFS_BUF_VALUSEMA(iclog->ic_bp) <= 0);
1163                 sv_init(&iclog->ic_force_wait, SV_DEFAULT, "iclog-force");
1164                 sv_init(&iclog->ic_write_wait, SV_DEFAULT, "iclog-write");
1165
1166                 iclogp = &iclog->ic_next;
1167         }
1168         *iclogp = log->l_iclog;                 /* complete ring */
1169         log->l_iclog->ic_prev = prev_iclog;     /* re-write 1st prev ptr */
1170
1171         return log;
1172
1173 out_free_iclog:
1174         for (iclog = log->l_iclog; iclog; iclog = prev_iclog) {
1175                 prev_iclog = iclog->ic_next;
1176                 if (iclog->ic_bp) {
1177                         sv_destroy(&iclog->ic_force_wait);
1178                         sv_destroy(&iclog->ic_write_wait);
1179                         xfs_buf_free(iclog->ic_bp);
1180                 }
1181                 kmem_free(iclog);
1182         }
1183         spinlock_destroy(&log->l_icloglock);
1184         spinlock_destroy(&log->l_grant_lock);
1185         xfs_buf_free(log->l_xbuf);
1186 out_free_log:
1187         kmem_free(log);
1188 out:
1189         return ERR_PTR(-error);
1190 }       /* xlog_alloc_log */
1191
1192
1193 /*
1194  * Write out the commit record of a transaction associated with the given
1195  * ticket.  Return the lsn of the commit record.
1196  */
1197 STATIC int
1198 xlog_commit_record(
1199         struct log              *log,
1200         struct xlog_ticket      *ticket,
1201         struct xlog_in_core     **iclog,
1202         xfs_lsn_t               *commitlsnp)
1203 {
1204         struct xfs_mount *mp = log->l_mp;
1205         int     error;
1206         struct xfs_log_iovec reg = {
1207                 .i_addr = NULL,
1208                 .i_len = 0,
1209                 .i_type = XLOG_REG_TYPE_COMMIT,
1210         };
1211         struct xfs_log_vec vec = {
1212                 .lv_niovecs = 1,
1213                 .lv_iovecp = &reg,
1214         };
1215
1216         ASSERT_ALWAYS(iclog);
1217         error = xlog_write(log, &vec, ticket, commitlsnp, iclog,
1218                                         XLOG_COMMIT_TRANS);
1219         if (error)
1220                 xfs_force_shutdown(mp, SHUTDOWN_LOG_IO_ERROR);
1221         return error;
1222 }
1223
1224 /*
1225  * Push on the buffer cache code if we ever use more than 75% of the on-disk
1226  * log space.  This code pushes on the lsn which would supposedly free up
1227  * the 25% which we want to leave free.  We may need to adopt a policy which
1228  * pushes on an lsn which is further along in the log once we reach the high
1229  * water mark.  In this manner, we would be creating a low water mark.
1230  */
1231 STATIC void
1232 xlog_grant_push_ail(xfs_mount_t *mp,
1233                     int         need_bytes)
1234 {
1235     xlog_t      *log = mp->m_log;       /* pointer to the log */
1236     xfs_lsn_t   tail_lsn;               /* lsn of the log tail */
1237     xfs_lsn_t   threshold_lsn = 0;      /* lsn we'd like to be at */
1238     int         free_blocks;            /* free blocks left to write to */
1239     int         free_bytes;             /* free bytes left to write to */
1240     int         threshold_block;        /* block in lsn we'd like to be at */
1241     int         threshold_cycle;        /* lsn cycle we'd like to be at */
1242     int         free_threshold;
1243
1244     ASSERT(BTOBB(need_bytes) < log->l_logBBsize);
1245
1246     spin_lock(&log->l_grant_lock);
1247     free_bytes = xlog_space_left(log,
1248                                  log->l_grant_reserve_cycle,
1249                                  log->l_grant_reserve_bytes);
1250     tail_lsn = log->l_tail_lsn;
1251     free_blocks = BTOBBT(free_bytes);
1252
1253     /*
1254      * Set the threshold for the minimum number of free blocks in the
1255      * log to the maximum of what the caller needs, one quarter of the
1256      * log, and 256 blocks.
1257      */
1258     free_threshold = BTOBB(need_bytes);
1259     free_threshold = MAX(free_threshold, (log->l_logBBsize >> 2));
1260     free_threshold = MAX(free_threshold, 256);
1261     if (free_blocks < free_threshold) {
1262         threshold_block = BLOCK_LSN(tail_lsn) + free_threshold;
1263         threshold_cycle = CYCLE_LSN(tail_lsn);
1264         if (threshold_block >= log->l_logBBsize) {
1265             threshold_block -= log->l_logBBsize;
1266             threshold_cycle += 1;
1267         }
1268         threshold_lsn = xlog_assign_lsn(threshold_cycle, threshold_block);
1269
1270         /* Don't pass in an lsn greater than the lsn of the last
1271          * log record known to be on disk.
1272          */
1273         if (XFS_LSN_CMP(threshold_lsn, log->l_last_sync_lsn) > 0)
1274             threshold_lsn = log->l_last_sync_lsn;
1275     }
1276     spin_unlock(&log->l_grant_lock);
1277
1278     /*
1279      * Get the transaction layer to kick the dirty buffers out to
1280      * disk asynchronously. No point in trying to do this if
1281      * the filesystem is shutting down.
1282      */
1283     if (threshold_lsn &&
1284         !XLOG_FORCED_SHUTDOWN(log))
1285             xfs_trans_ail_push(log->l_ailp, threshold_lsn);
1286 }       /* xlog_grant_push_ail */
1287
1288 /*
1289  * The bdstrat callback function for log bufs. This gives us a central
1290  * place to trap bufs in case we get hit by a log I/O error and need to
1291  * shutdown. Actually, in practice, even when we didn't get a log error,
1292  * we transition the iclogs to IOERROR state *after* flushing all existing
1293  * iclogs to disk. This is because we don't want anymore new transactions to be
1294  * started or completed afterwards.
1295  */
1296 STATIC int
1297 xlog_bdstrat(
1298         struct xfs_buf          *bp)
1299 {
1300         struct xlog_in_core     *iclog;
1301
1302         iclog = XFS_BUF_FSPRIVATE(bp, xlog_in_core_t *);
1303         if (iclog->ic_state & XLOG_STATE_IOERROR) {
1304                 XFS_BUF_ERROR(bp, EIO);
1305                 XFS_BUF_STALE(bp);
1306                 xfs_biodone(bp);
1307                 /*
1308                  * It would seem logical to return EIO here, but we rely on
1309                  * the log state machine to propagate I/O errors instead of
1310                  * doing it here.
1311                  */
1312                 return 0;
1313         }
1314
1315         bp->b_flags |= _XBF_RUN_QUEUES;
1316         xfs_buf_iorequest(bp);
1317         return 0;
1318 }
1319
1320 /*
1321  * Flush out the in-core log (iclog) to the on-disk log in an asynchronous 
1322  * fashion.  Previously, we should have moved the current iclog
1323  * ptr in the log to point to the next available iclog.  This allows further
1324  * write to continue while this code syncs out an iclog ready to go.
1325  * Before an in-core log can be written out, the data section must be scanned
1326  * to save away the 1st word of each BBSIZE block into the header.  We replace
1327  * it with the current cycle count.  Each BBSIZE block is tagged with the
1328  * cycle count because there in an implicit assumption that drives will
1329  * guarantee that entire 512 byte blocks get written at once.  In other words,
1330  * we can't have part of a 512 byte block written and part not written.  By
1331  * tagging each block, we will know which blocks are valid when recovering
1332  * after an unclean shutdown.
1333  *
1334  * This routine is single threaded on the iclog.  No other thread can be in
1335  * this routine with the same iclog.  Changing contents of iclog can there-
1336  * fore be done without grabbing the state machine lock.  Updating the global
1337  * log will require grabbing the lock though.
1338  *
1339  * The entire log manager uses a logical block numbering scheme.  Only
1340  * log_sync (and then only bwrite()) know about the fact that the log may
1341  * not start with block zero on a given device.  The log block start offset
1342  * is added immediately before calling bwrite().
1343  */
1344
1345 STATIC int
1346 xlog_sync(xlog_t                *log,
1347           xlog_in_core_t        *iclog)
1348 {
1349         xfs_caddr_t     dptr;           /* pointer to byte sized element */
1350         xfs_buf_t       *bp;
1351         int             i;
1352         uint            count;          /* byte count of bwrite */
1353         uint            count_init;     /* initial count before roundup */
1354         int             roundoff;       /* roundoff to BB or stripe */
1355         int             split = 0;      /* split write into two regions */
1356         int             error;
1357         int             v2 = xfs_sb_version_haslogv2(&log->l_mp->m_sb);
1358
1359         XFS_STATS_INC(xs_log_writes);
1360         ASSERT(atomic_read(&iclog->ic_refcnt) == 0);
1361
1362         /* Add for LR header */
1363         count_init = log->l_iclog_hsize + iclog->ic_offset;
1364
1365         /* Round out the log write size */
1366         if (v2 && log->l_mp->m_sb.sb_logsunit > 1) {
1367                 /* we have a v2 stripe unit to use */
1368                 count = XLOG_LSUNITTOB(log, XLOG_BTOLSUNIT(log, count_init));
1369         } else {
1370                 count = BBTOB(BTOBB(count_init));
1371         }
1372         roundoff = count - count_init;
1373         ASSERT(roundoff >= 0);
1374         ASSERT((v2 && log->l_mp->m_sb.sb_logsunit > 1 && 
1375                 roundoff < log->l_mp->m_sb.sb_logsunit)
1376                 || 
1377                 (log->l_mp->m_sb.sb_logsunit <= 1 && 
1378                  roundoff < BBTOB(1)));
1379
1380         /* move grant heads by roundoff in sync */
1381         spin_lock(&log->l_grant_lock);
1382         xlog_grant_add_space(log, roundoff);
1383         spin_unlock(&log->l_grant_lock);
1384
1385         /* put cycle number in every block */
1386         xlog_pack_data(log, iclog, roundoff); 
1387
1388         /* real byte length */
1389         if (v2) {
1390                 iclog->ic_header.h_len =
1391                         cpu_to_be32(iclog->ic_offset + roundoff);
1392         } else {
1393                 iclog->ic_header.h_len =
1394                         cpu_to_be32(iclog->ic_offset);
1395         }
1396
1397         bp = iclog->ic_bp;
1398         ASSERT(XFS_BUF_FSPRIVATE2(bp, unsigned long) == (unsigned long)1);
1399         XFS_BUF_SET_FSPRIVATE2(bp, (unsigned long)2);
1400         XFS_BUF_SET_ADDR(bp, BLOCK_LSN(be64_to_cpu(iclog->ic_header.h_lsn)));
1401
1402         XFS_STATS_ADD(xs_log_blocks, BTOBB(count));
1403
1404         /* Do we need to split this write into 2 parts? */
1405         if (XFS_BUF_ADDR(bp) + BTOBB(count) > log->l_logBBsize) {
1406                 split = count - (BBTOB(log->l_logBBsize - XFS_BUF_ADDR(bp)));
1407                 count = BBTOB(log->l_logBBsize - XFS_BUF_ADDR(bp));
1408                 iclog->ic_bwritecnt = 2;        /* split into 2 writes */
1409         } else {
1410                 iclog->ic_bwritecnt = 1;
1411         }
1412         XFS_BUF_SET_COUNT(bp, count);
1413         XFS_BUF_SET_FSPRIVATE(bp, iclog);       /* save for later */
1414         XFS_BUF_ZEROFLAGS(bp);
1415         XFS_BUF_BUSY(bp);
1416         XFS_BUF_ASYNC(bp);
1417         bp->b_flags |= XBF_LOG_BUFFER;
1418         /*
1419          * Do an ordered write for the log block.
1420          * Its unnecessary to flush the first split block in the log wrap case.
1421          */
1422         if (!split && (log->l_mp->m_flags & XFS_MOUNT_BARRIER))
1423                 XFS_BUF_ORDERED(bp);
1424
1425         ASSERT(XFS_BUF_ADDR(bp) <= log->l_logBBsize-1);
1426         ASSERT(XFS_BUF_ADDR(bp) + BTOBB(count) <= log->l_logBBsize);
1427
1428         xlog_verify_iclog(log, iclog, count, B_TRUE);
1429
1430         /* account for log which doesn't start at block #0 */
1431         XFS_BUF_SET_ADDR(bp, XFS_BUF_ADDR(bp) + log->l_logBBstart);
1432         /*
1433          * Don't call xfs_bwrite here. We do log-syncs even when the filesystem
1434          * is shutting down.
1435          */
1436         XFS_BUF_WRITE(bp);
1437
1438         if ((error = xlog_bdstrat(bp))) {
1439                 xfs_ioerror_alert("xlog_sync", log->l_mp, bp,
1440                                   XFS_BUF_ADDR(bp));
1441                 return error;
1442         }
1443         if (split) {
1444                 bp = iclog->ic_log->l_xbuf;
1445                 ASSERT(XFS_BUF_FSPRIVATE2(bp, unsigned long) ==
1446                                                         (unsigned long)1);
1447                 XFS_BUF_SET_FSPRIVATE2(bp, (unsigned long)2);
1448                 XFS_BUF_SET_ADDR(bp, 0);             /* logical 0 */
1449                 XFS_BUF_SET_PTR(bp, (xfs_caddr_t)((__psint_t)&(iclog->ic_header)+
1450                                             (__psint_t)count), split);
1451                 XFS_BUF_SET_FSPRIVATE(bp, iclog);
1452                 XFS_BUF_ZEROFLAGS(bp);
1453                 XFS_BUF_BUSY(bp);
1454                 XFS_BUF_ASYNC(bp);
1455                 bp->b_flags |= XBF_LOG_BUFFER;
1456                 if (log->l_mp->m_flags & XFS_MOUNT_BARRIER)
1457                         XFS_BUF_ORDERED(bp);
1458                 dptr = XFS_BUF_PTR(bp);
1459                 /*
1460                  * Bump the cycle numbers at the start of each block
1461                  * since this part of the buffer is at the start of
1462                  * a new cycle.  Watch out for the header magic number
1463                  * case, though.
1464                  */
1465                 for (i = 0; i < split; i += BBSIZE) {
1466                         be32_add_cpu((__be32 *)dptr, 1);
1467                         if (be32_to_cpu(*(__be32 *)dptr) == XLOG_HEADER_MAGIC_NUM)
1468                                 be32_add_cpu((__be32 *)dptr, 1);
1469                         dptr += BBSIZE;
1470                 }
1471
1472                 ASSERT(XFS_BUF_ADDR(bp) <= log->l_logBBsize-1);
1473                 ASSERT(XFS_BUF_ADDR(bp) + BTOBB(count) <= log->l_logBBsize);
1474
1475                 /* account for internal log which doesn't start at block #0 */
1476                 XFS_BUF_SET_ADDR(bp, XFS_BUF_ADDR(bp) + log->l_logBBstart);
1477                 XFS_BUF_WRITE(bp);
1478                 if ((error = xlog_bdstrat(bp))) {
1479                         xfs_ioerror_alert("xlog_sync (split)", log->l_mp,
1480                                           bp, XFS_BUF_ADDR(bp));
1481                         return error;
1482                 }
1483         }
1484         return 0;
1485 }       /* xlog_sync */
1486
1487
1488 /*
1489  * Deallocate a log structure
1490  */
1491 STATIC void
1492 xlog_dealloc_log(xlog_t *log)
1493 {
1494         xlog_in_core_t  *iclog, *next_iclog;
1495         int             i;
1496
1497         iclog = log->l_iclog;
1498         for (i=0; i<log->l_iclog_bufs; i++) {
1499                 sv_destroy(&iclog->ic_force_wait);
1500                 sv_destroy(&iclog->ic_write_wait);
1501                 xfs_buf_free(iclog->ic_bp);
1502                 next_iclog = iclog->ic_next;
1503                 kmem_free(iclog);
1504                 iclog = next_iclog;
1505         }
1506         spinlock_destroy(&log->l_icloglock);
1507         spinlock_destroy(&log->l_grant_lock);
1508
1509         xfs_buf_free(log->l_xbuf);
1510         log->l_mp->m_log = NULL;
1511         kmem_free(log);
1512 }       /* xlog_dealloc_log */
1513
1514 /*
1515  * Update counters atomically now that memcpy is done.
1516  */
1517 /* ARGSUSED */
1518 static inline void
1519 xlog_state_finish_copy(xlog_t           *log,
1520                        xlog_in_core_t   *iclog,
1521                        int              record_cnt,
1522                        int              copy_bytes)
1523 {
1524         spin_lock(&log->l_icloglock);
1525
1526         be32_add_cpu(&iclog->ic_header.h_num_logops, record_cnt);
1527         iclog->ic_offset += copy_bytes;
1528
1529         spin_unlock(&log->l_icloglock);
1530 }       /* xlog_state_finish_copy */
1531
1532
1533
1534
1535 /*
1536  * print out info relating to regions written which consume
1537  * the reservation
1538  */
1539 STATIC void
1540 xlog_print_tic_res(xfs_mount_t *mp, xlog_ticket_t *ticket)
1541 {
1542         uint i;
1543         uint ophdr_spc = ticket->t_res_num_ophdrs * (uint)sizeof(xlog_op_header_t);
1544
1545         /* match with XLOG_REG_TYPE_* in xfs_log.h */
1546         static char *res_type_str[XLOG_REG_TYPE_MAX] = {
1547             "bformat",
1548             "bchunk",
1549             "efi_format",
1550             "efd_format",
1551             "iformat",
1552             "icore",
1553             "iext",
1554             "ibroot",
1555             "ilocal",
1556             "iattr_ext",
1557             "iattr_broot",
1558             "iattr_local",
1559             "qformat",
1560             "dquot",
1561             "quotaoff",
1562             "LR header",
1563             "unmount",
1564             "commit",
1565             "trans header"
1566         };
1567         static char *trans_type_str[XFS_TRANS_TYPE_MAX] = {
1568             "SETATTR_NOT_SIZE",
1569             "SETATTR_SIZE",
1570             "INACTIVE",
1571             "CREATE",
1572             "CREATE_TRUNC",
1573             "TRUNCATE_FILE",
1574             "REMOVE",
1575             "LINK",
1576             "RENAME",
1577             "MKDIR",
1578             "RMDIR",
1579             "SYMLINK",
1580             "SET_DMATTRS",
1581             "GROWFS",
1582             "STRAT_WRITE",
1583             "DIOSTRAT",
1584             "WRITE_SYNC",
1585             "WRITEID",
1586             "ADDAFORK",
1587             "ATTRINVAL",
1588             "ATRUNCATE",
1589             "ATTR_SET",
1590             "ATTR_RM",
1591             "ATTR_FLAG",
1592             "CLEAR_AGI_BUCKET",
1593             "QM_SBCHANGE",
1594             "DUMMY1",
1595             "DUMMY2",
1596             "QM_QUOTAOFF",
1597             "QM_DQALLOC",
1598             "QM_SETQLIM",
1599             "QM_DQCLUSTER",
1600             "QM_QINOCREATE",
1601             "QM_QUOTAOFF_END",
1602             "SB_UNIT",
1603             "FSYNC_TS",
1604             "GROWFSRT_ALLOC",
1605             "GROWFSRT_ZERO",
1606             "GROWFSRT_FREE",
1607             "SWAPEXT"
1608         };
1609
1610         xfs_fs_cmn_err(CE_WARN, mp,
1611                         "xfs_log_write: reservation summary:\n"
1612                         "  trans type  = %s (%u)\n"
1613                         "  unit res    = %d bytes\n"
1614                         "  current res = %d bytes\n"
1615                         "  total reg   = %u bytes (o/flow = %u bytes)\n"
1616                         "  ophdrs      = %u (ophdr space = %u bytes)\n"
1617                         "  ophdr + reg = %u bytes\n"
1618                         "  num regions = %u\n",
1619                         ((ticket->t_trans_type <= 0 ||
1620                           ticket->t_trans_type > XFS_TRANS_TYPE_MAX) ?
1621                           "bad-trans-type" : trans_type_str[ticket->t_trans_type-1]),
1622                         ticket->t_trans_type,
1623                         ticket->t_unit_res,
1624                         ticket->t_curr_res,
1625                         ticket->t_res_arr_sum, ticket->t_res_o_flow,
1626                         ticket->t_res_num_ophdrs, ophdr_spc,
1627                         ticket->t_res_arr_sum + 
1628                         ticket->t_res_o_flow + ophdr_spc,
1629                         ticket->t_res_num);
1630
1631         for (i = 0; i < ticket->t_res_num; i++) {
1632                 uint r_type = ticket->t_res_arr[i].r_type; 
1633                 cmn_err(CE_WARN,
1634                             "region[%u]: %s - %u bytes\n",
1635                             i, 
1636                             ((r_type <= 0 || r_type > XLOG_REG_TYPE_MAX) ?
1637                             "bad-rtype" : res_type_str[r_type-1]),
1638                             ticket->t_res_arr[i].r_len);
1639         }
1640 }
1641
1642 /*
1643  * Calculate the potential space needed by the log vector.  Each region gets
1644  * its own xlog_op_header_t and may need to be double word aligned.
1645  */
1646 static int
1647 xlog_write_calc_vec_length(
1648         struct xlog_ticket      *ticket,
1649         struct xfs_log_vec      *log_vector)
1650 {
1651         struct xfs_log_vec      *lv;
1652         int                     headers = 0;
1653         int                     len = 0;
1654         int                     i;
1655
1656         /* acct for start rec of xact */
1657         if (ticket->t_flags & XLOG_TIC_INITED)
1658                 headers++;
1659
1660         for (lv = log_vector; lv; lv = lv->lv_next) {
1661                 headers += lv->lv_niovecs;
1662
1663                 for (i = 0; i < lv->lv_niovecs; i++) {
1664                         struct xfs_log_iovec    *vecp = &lv->lv_iovecp[i];
1665
1666                         len += vecp->i_len;
1667                         xlog_tic_add_region(ticket, vecp->i_len, vecp->i_type);
1668                 }
1669         }
1670
1671         ticket->t_res_num_ophdrs += headers;
1672         len += headers * sizeof(struct xlog_op_header);
1673
1674         return len;
1675 }
1676
1677 /*
1678  * If first write for transaction, insert start record  We can't be trying to
1679  * commit if we are inited.  We can't have any "partial_copy" if we are inited.
1680  */
1681 static int
1682 xlog_write_start_rec(
1683         struct xlog_op_header   *ophdr,
1684         struct xlog_ticket      *ticket)
1685 {
1686         if (!(ticket->t_flags & XLOG_TIC_INITED))
1687                 return 0;
1688
1689         ophdr->oh_tid   = cpu_to_be32(ticket->t_tid);
1690         ophdr->oh_clientid = ticket->t_clientid;
1691         ophdr->oh_len = 0;
1692         ophdr->oh_flags = XLOG_START_TRANS;
1693         ophdr->oh_res2 = 0;
1694
1695         ticket->t_flags &= ~XLOG_TIC_INITED;
1696
1697         return sizeof(struct xlog_op_header);
1698 }
1699
1700 static xlog_op_header_t *
1701 xlog_write_setup_ophdr(
1702         struct log              *log,
1703         struct xlog_op_header   *ophdr,
1704         struct xlog_ticket      *ticket,
1705         uint                    flags)
1706 {
1707         ophdr->oh_tid = cpu_to_be32(ticket->t_tid);
1708         ophdr->oh_clientid = ticket->t_clientid;
1709         ophdr->oh_res2 = 0;
1710
1711         /* are we copying a commit or unmount record? */
1712         ophdr->oh_flags = flags;
1713
1714         /*
1715          * We've seen logs corrupted with bad transaction client ids.  This
1716          * makes sure that XFS doesn't generate them on.  Turn this into an EIO
1717          * and shut down the filesystem.
1718          */
1719         switch (ophdr->oh_clientid)  {
1720         case XFS_TRANSACTION:
1721         case XFS_VOLUME:
1722         case XFS_LOG:
1723                 break;
1724         default:
1725                 xfs_fs_cmn_err(CE_WARN, log->l_mp,
1726                         "Bad XFS transaction clientid 0x%x in ticket 0x%p",
1727                         ophdr->oh_clientid, ticket);
1728                 return NULL;
1729         }
1730
1731         return ophdr;
1732 }
1733
1734 /*
1735  * Set up the parameters of the region copy into the log. This has
1736  * to handle region write split across multiple log buffers - this
1737  * state is kept external to this function so that this code can
1738  * can be written in an obvious, self documenting manner.
1739  */
1740 static int
1741 xlog_write_setup_copy(
1742         struct xlog_ticket      *ticket,
1743         struct xlog_op_header   *ophdr,
1744         int                     space_available,
1745         int                     space_required,
1746         int                     *copy_off,
1747         int                     *copy_len,
1748         int                     *last_was_partial_copy,
1749         int                     *bytes_consumed)
1750 {
1751         int                     still_to_copy;
1752
1753         still_to_copy = space_required - *bytes_consumed;
1754         *copy_off = *bytes_consumed;
1755
1756         if (still_to_copy <= space_available) {
1757                 /* write of region completes here */
1758                 *copy_len = still_to_copy;
1759                 ophdr->oh_len = cpu_to_be32(*copy_len);
1760                 if (*last_was_partial_copy)
1761                         ophdr->oh_flags |= (XLOG_END_TRANS|XLOG_WAS_CONT_TRANS);
1762                 *last_was_partial_copy = 0;
1763                 *bytes_consumed = 0;
1764                 return 0;
1765         }
1766
1767         /* partial write of region, needs extra log op header reservation */
1768         *copy_len = space_available;
1769         ophdr->oh_len = cpu_to_be32(*copy_len);
1770         ophdr->oh_flags |= XLOG_CONTINUE_TRANS;
1771         if (*last_was_partial_copy)
1772                 ophdr->oh_flags |= XLOG_WAS_CONT_TRANS;
1773         *bytes_consumed += *copy_len;
1774         (*last_was_partial_copy)++;
1775
1776         /* account for new log op header */
1777         ticket->t_curr_res -= sizeof(struct xlog_op_header);
1778         ticket->t_res_num_ophdrs++;
1779
1780         return sizeof(struct xlog_op_header);
1781 }
1782
1783 static int
1784 xlog_write_copy_finish(
1785         struct log              *log,
1786         struct xlog_in_core     *iclog,
1787         uint                    flags,
1788         int                     *record_cnt,
1789         int                     *data_cnt,
1790         int                     *partial_copy,
1791         int                     *partial_copy_len,
1792         int                     log_offset,
1793         struct xlog_in_core     **commit_iclog)
1794 {
1795         if (*partial_copy) {
1796                 /*
1797                  * This iclog has already been marked WANT_SYNC by
1798                  * xlog_state_get_iclog_space.
1799                  */
1800                 xlog_state_finish_copy(log, iclog, *record_cnt, *data_cnt);
1801                 *record_cnt = 0;
1802                 *data_cnt = 0;
1803                 return xlog_state_release_iclog(log, iclog);
1804         }
1805
1806         *partial_copy = 0;
1807         *partial_copy_len = 0;
1808
1809         if (iclog->ic_size - log_offset <= sizeof(xlog_op_header_t)) {
1810                 /* no more space in this iclog - push it. */
1811                 xlog_state_finish_copy(log, iclog, *record_cnt, *data_cnt);
1812                 *record_cnt = 0;
1813                 *data_cnt = 0;
1814
1815                 spin_lock(&log->l_icloglock);
1816                 xlog_state_want_sync(log, iclog);
1817                 spin_unlock(&log->l_icloglock);
1818
1819                 if (!commit_iclog)
1820                         return xlog_state_release_iclog(log, iclog);
1821                 ASSERT(flags & XLOG_COMMIT_TRANS);
1822                 *commit_iclog = iclog;
1823         }
1824
1825         return 0;
1826 }
1827
1828 /*
1829  * Write some region out to in-core log
1830  *
1831  * This will be called when writing externally provided regions or when
1832  * writing out a commit record for a given transaction.
1833  *
1834  * General algorithm:
1835  *      1. Find total length of this write.  This may include adding to the
1836  *              lengths passed in.
1837  *      2. Check whether we violate the tickets reservation.
1838  *      3. While writing to this iclog
1839  *          A. Reserve as much space in this iclog as can get
1840  *          B. If this is first write, save away start lsn
1841  *          C. While writing this region:
1842  *              1. If first write of transaction, write start record
1843  *              2. Write log operation header (header per region)
1844  *              3. Find out if we can fit entire region into this iclog
1845  *              4. Potentially, verify destination memcpy ptr
1846  *              5. Memcpy (partial) region
1847  *              6. If partial copy, release iclog; otherwise, continue
1848  *                      copying more regions into current iclog
1849  *      4. Mark want sync bit (in simulation mode)
1850  *      5. Release iclog for potential flush to on-disk log.
1851  *
1852  * ERRORS:
1853  * 1.   Panic if reservation is overrun.  This should never happen since
1854  *      reservation amounts are generated internal to the filesystem.
1855  * NOTES:
1856  * 1. Tickets are single threaded data structures.
1857  * 2. The XLOG_END_TRANS & XLOG_CONTINUE_TRANS flags are passed down to the
1858  *      syncing routine.  When a single log_write region needs to span
1859  *      multiple in-core logs, the XLOG_CONTINUE_TRANS bit should be set
1860  *      on all log operation writes which don't contain the end of the
1861  *      region.  The XLOG_END_TRANS bit is used for the in-core log
1862  *      operation which contains the end of the continued log_write region.
1863  * 3. When xlog_state_get_iclog_space() grabs the rest of the current iclog,
1864  *      we don't really know exactly how much space will be used.  As a result,
1865  *      we don't update ic_offset until the end when we know exactly how many
1866  *      bytes have been written out.
1867  */
1868 STATIC int
1869 xlog_write(
1870         struct log              *log,
1871         struct xfs_log_vec      *log_vector,
1872         struct xlog_ticket      *ticket,
1873         xfs_lsn_t               *start_lsn,
1874         struct xlog_in_core     **commit_iclog,
1875         uint                    flags)
1876 {
1877         struct xlog_in_core     *iclog = NULL;
1878         struct xfs_log_iovec    *vecp;
1879         struct xfs_log_vec      *lv;
1880         int                     len;
1881         int                     index;
1882         int                     partial_copy = 0;
1883         int                     partial_copy_len = 0;
1884         int                     contwr = 0;
1885         int                     record_cnt = 0;
1886         int                     data_cnt = 0;
1887         int                     error;
1888
1889         *start_lsn = 0;
1890
1891         len = xlog_write_calc_vec_length(ticket, log_vector);
1892         if (ticket->t_curr_res < len) {
1893                 xlog_print_tic_res(log->l_mp, ticket);
1894 #ifdef DEBUG
1895                 xlog_panic(
1896         "xfs_log_write: reservation ran out. Need to up reservation");
1897 #else
1898                 /* Customer configurable panic */
1899                 xfs_cmn_err(XFS_PTAG_LOGRES, CE_ALERT, log->l_mp,
1900         "xfs_log_write: reservation ran out. Need to up reservation");
1901
1902                 /* If we did not panic, shutdown the filesystem */
1903                 xfs_force_shutdown(log->l_mp, SHUTDOWN_CORRUPT_INCORE);
1904 #endif
1905         }
1906
1907         ticket->t_curr_res -= len;
1908
1909         index = 0;
1910         lv = log_vector;
1911         vecp = lv->lv_iovecp;
1912         while (lv && index < lv->lv_niovecs) {
1913                 void            *ptr;
1914                 int             log_offset;
1915
1916                 error = xlog_state_get_iclog_space(log, len, &iclog, ticket,
1917                                                    &contwr, &log_offset);
1918                 if (error)
1919                         return error;
1920
1921                 ASSERT(log_offset <= iclog->ic_size - 1);
1922                 ptr = iclog->ic_datap + log_offset;
1923
1924                 /* start_lsn is the first lsn written to. That's all we need. */
1925                 if (!*start_lsn)
1926                         *start_lsn = be64_to_cpu(iclog->ic_header.h_lsn);
1927
1928                 /*
1929                  * This loop writes out as many regions as can fit in the amount
1930                  * of space which was allocated by xlog_state_get_iclog_space().
1931                  */
1932                 while (lv && index < lv->lv_niovecs) {
1933                         struct xfs_log_iovec    *reg = &vecp[index];
1934                         struct xlog_op_header   *ophdr;
1935                         int                     start_rec_copy;
1936                         int                     copy_len;
1937                         int                     copy_off;
1938
1939                         ASSERT(reg->i_len % sizeof(__int32_t) == 0);
1940                         ASSERT((unsigned long)ptr % sizeof(__int32_t) == 0);
1941
1942                         start_rec_copy = xlog_write_start_rec(ptr, ticket);
1943                         if (start_rec_copy) {
1944                                 record_cnt++;
1945                                 xlog_write_adv_cnt(&ptr, &len, &log_offset,
1946                                                    start_rec_copy);
1947                         }
1948
1949                         ophdr = xlog_write_setup_ophdr(log, ptr, ticket, flags);
1950                         if (!ophdr)
1951                                 return XFS_ERROR(EIO);
1952
1953                         xlog_write_adv_cnt(&ptr, &len, &log_offset,
1954                                            sizeof(struct xlog_op_header));
1955
1956                         len += xlog_write_setup_copy(ticket, ophdr,
1957                                                      iclog->ic_size-log_offset,
1958                                                      reg->i_len,
1959                                                      &copy_off, &copy_len,
1960                                                      &partial_copy,
1961                                                      &partial_copy_len);
1962                         xlog_verify_dest_ptr(log, ptr);
1963
1964                         /* copy region */
1965                         ASSERT(copy_len >= 0);
1966                         memcpy(ptr, reg->i_addr + copy_off, copy_len);
1967                         xlog_write_adv_cnt(&ptr, &len, &log_offset, copy_len);
1968
1969                         copy_len += start_rec_copy + sizeof(xlog_op_header_t);
1970                         record_cnt++;
1971                         data_cnt += contwr ? copy_len : 0;
1972
1973                         error = xlog_write_copy_finish(log, iclog, flags,
1974                                                        &record_cnt, &data_cnt,
1975                                                        &partial_copy,
1976                                                        &partial_copy_len,
1977                                                        log_offset,
1978                                                        commit_iclog);
1979                         if (error)
1980                                 return error;
1981
1982                         /*
1983                          * if we had a partial copy, we need to get more iclog
1984                          * space but we don't want to increment the region
1985                          * index because there is still more is this region to
1986                          * write.
1987                          *
1988                          * If we completed writing this region, and we flushed
1989                          * the iclog (indicated by resetting of the record
1990                          * count), then we also need to get more log space. If
1991                          * this was the last record, though, we are done and
1992                          * can just return.
1993                          */
1994                         if (partial_copy)
1995                                 break;
1996
1997                         if (++index == lv->lv_niovecs) {
1998                                 lv = lv->lv_next;
1999                                 index = 0;
2000                                 if (lv)
2001                                         vecp = lv->lv_iovecp;
2002                         }
2003                         if (record_cnt == 0) {
2004                                 if (!lv)
2005                                         return 0;
2006                                 break;
2007                         }
2008                 }
2009         }
2010
2011         ASSERT(len == 0);
2012
2013         xlog_state_finish_copy(log, iclog, record_cnt, data_cnt);
2014         if (!commit_iclog)
2015                 return xlog_state_release_iclog(log, iclog);
2016
2017         ASSERT(flags & XLOG_COMMIT_TRANS);
2018         *commit_iclog = iclog;
2019         return 0;
2020 }
2021
2022
2023 /*****************************************************************************
2024  *
2025  *              State Machine functions
2026  *
2027  *****************************************************************************
2028  */
2029
2030 /* Clean iclogs starting from the head.  This ordering must be
2031  * maintained, so an iclog doesn't become ACTIVE beyond one that
2032  * is SYNCING.  This is also required to maintain the notion that we use
2033  * a ordered wait queue to hold off would be writers to the log when every
2034  * iclog is trying to sync to disk.
2035  *
2036  * State Change: DIRTY -> ACTIVE
2037  */
2038 STATIC void
2039 xlog_state_clean_log(xlog_t *log)
2040 {
2041         xlog_in_core_t  *iclog;
2042         int changed = 0;
2043
2044         iclog = log->l_iclog;
2045         do {
2046                 if (iclog->ic_state == XLOG_STATE_DIRTY) {
2047                         iclog->ic_state = XLOG_STATE_ACTIVE;
2048                         iclog->ic_offset       = 0;
2049                         ASSERT(iclog->ic_callback == NULL);
2050                         /*
2051                          * If the number of ops in this iclog indicate it just
2052                          * contains the dummy transaction, we can
2053                          * change state into IDLE (the second time around).
2054                          * Otherwise we should change the state into
2055                          * NEED a dummy.
2056                          * We don't need to cover the dummy.
2057                          */
2058                         if (!changed &&
2059                            (be32_to_cpu(iclog->ic_header.h_num_logops) ==
2060                                         XLOG_COVER_OPS)) {
2061                                 changed = 1;
2062                         } else {
2063                                 /*
2064                                  * We have two dirty iclogs so start over
2065                                  * This could also be num of ops indicates
2066                                  * this is not the dummy going out.
2067                                  */
2068                                 changed = 2;
2069                         }
2070                         iclog->ic_header.h_num_logops = 0;
2071                         memset(iclog->ic_header.h_cycle_data, 0,
2072                               sizeof(iclog->ic_header.h_cycle_data));
2073                         iclog->ic_header.h_lsn = 0;
2074                 } else if (iclog->ic_state == XLOG_STATE_ACTIVE)
2075                         /* do nothing */;
2076                 else
2077                         break;  /* stop cleaning */
2078                 iclog = iclog->ic_next;
2079         } while (iclog != log->l_iclog);
2080
2081         /* log is locked when we are called */
2082         /*
2083          * Change state for the dummy log recording.
2084          * We usually go to NEED. But we go to NEED2 if the changed indicates
2085          * we are done writing the dummy record.
2086          * If we are done with the second dummy recored (DONE2), then
2087          * we go to IDLE.
2088          */
2089         if (changed) {
2090                 switch (log->l_covered_state) {
2091                 case XLOG_STATE_COVER_IDLE:
2092                 case XLOG_STATE_COVER_NEED:
2093                 case XLOG_STATE_COVER_NEED2:
2094                         log->l_covered_state = XLOG_STATE_COVER_NEED;
2095                         break;
2096
2097                 case XLOG_STATE_COVER_DONE:
2098                         if (changed == 1)
2099                                 log->l_covered_state = XLOG_STATE_COVER_NEED2;
2100                         else
2101                                 log->l_covered_state = XLOG_STATE_COVER_NEED;
2102                         break;
2103
2104                 case XLOG_STATE_COVER_DONE2:
2105                         if (changed == 1)
2106                                 log->l_covered_state = XLOG_STATE_COVER_IDLE;
2107                         else
2108                                 log->l_covered_state = XLOG_STATE_COVER_NEED;
2109                         break;
2110
2111                 default:
2112                         ASSERT(0);
2113                 }
2114         }
2115 }       /* xlog_state_clean_log */
2116
2117 STATIC xfs_lsn_t
2118 xlog_get_lowest_lsn(
2119         xlog_t          *log)
2120 {
2121         xlog_in_core_t  *lsn_log;
2122         xfs_lsn_t       lowest_lsn, lsn;
2123
2124         lsn_log = log->l_iclog;
2125         lowest_lsn = 0;
2126         do {
2127             if (!(lsn_log->ic_state & (XLOG_STATE_ACTIVE|XLOG_STATE_DIRTY))) {
2128                 lsn = be64_to_cpu(lsn_log->ic_header.h_lsn);
2129                 if ((lsn && !lowest_lsn) ||
2130                     (XFS_LSN_CMP(lsn, lowest_lsn) < 0)) {
2131                         lowest_lsn = lsn;
2132                 }
2133             }
2134             lsn_log = lsn_log->ic_next;
2135         } while (lsn_log != log->l_iclog);
2136         return lowest_lsn;
2137 }
2138
2139
2140 STATIC void
2141 xlog_state_do_callback(
2142         xlog_t          *log,
2143         int             aborted,
2144         xlog_in_core_t  *ciclog)
2145 {
2146         xlog_in_core_t     *iclog;
2147         xlog_in_core_t     *first_iclog;        /* used to know when we've
2148                                                  * processed all iclogs once */
2149         xfs_log_callback_t *cb, *cb_next;
2150         int                flushcnt = 0;
2151         xfs_lsn_t          lowest_lsn;
2152         int                ioerrors;    /* counter: iclogs with errors */
2153         int                loopdidcallbacks; /* flag: inner loop did callbacks*/
2154         int                funcdidcallbacks; /* flag: function did callbacks */
2155         int                repeats;     /* for issuing console warnings if
2156                                          * looping too many times */
2157         int                wake = 0;
2158
2159         spin_lock(&log->l_icloglock);
2160         first_iclog = iclog = log->l_iclog;
2161         ioerrors = 0;
2162         funcdidcallbacks = 0;
2163         repeats = 0;
2164
2165         do {
2166                 /*
2167                  * Scan all iclogs starting with the one pointed to by the
2168                  * log.  Reset this starting point each time the log is
2169                  * unlocked (during callbacks).
2170                  *
2171                  * Keep looping through iclogs until one full pass is made
2172                  * without running any callbacks.
2173                  */
2174                 first_iclog = log->l_iclog;
2175                 iclog = log->l_iclog;
2176                 loopdidcallbacks = 0;
2177                 repeats++;
2178
2179                 do {
2180
2181                         /* skip all iclogs in the ACTIVE & DIRTY states */
2182                         if (iclog->ic_state &
2183                             (XLOG_STATE_ACTIVE|XLOG_STATE_DIRTY)) {
2184                                 iclog = iclog->ic_next;
2185                                 continue;
2186                         }
2187
2188                         /*
2189                          * Between marking a filesystem SHUTDOWN and stopping
2190                          * the log, we do flush all iclogs to disk (if there
2191                          * wasn't a log I/O error). So, we do want things to
2192                          * go smoothly in case of just a SHUTDOWN  w/o a
2193                          * LOG_IO_ERROR.
2194                          */
2195                         if (!(iclog->ic_state & XLOG_STATE_IOERROR)) {
2196                                 /*
2197                                  * Can only perform callbacks in order.  Since
2198                                  * this iclog is not in the DONE_SYNC/
2199                                  * DO_CALLBACK state, we skip the rest and
2200                                  * just try to clean up.  If we set our iclog
2201                                  * to DO_CALLBACK, we will not process it when
2202                                  * we retry since a previous iclog is in the
2203                                  * CALLBACK and the state cannot change since
2204                                  * we are holding the l_icloglock.
2205                                  */
2206                                 if (!(iclog->ic_state &
2207                                         (XLOG_STATE_DONE_SYNC |
2208                                                  XLOG_STATE_DO_CALLBACK))) {
2209                                         if (ciclog && (ciclog->ic_state ==
2210                                                         XLOG_STATE_DONE_SYNC)) {
2211                                                 ciclog->ic_state = XLOG_STATE_DO_CALLBACK;
2212                                         }
2213                                         break;
2214                                 }
2215                                 /*
2216                                  * We now have an iclog that is in either the
2217                                  * DO_CALLBACK or DONE_SYNC states. The other
2218                                  * states (WANT_SYNC, SYNCING, or CALLBACK were
2219                                  * caught by the above if and are going to
2220                                  * clean (i.e. we aren't doing their callbacks)
2221                                  * see the above if.
2222                                  */
2223
2224                                 /*
2225                                  * We will do one more check here to see if we
2226                                  * have chased our tail around.
2227                                  */
2228
2229                                 lowest_lsn = xlog_get_lowest_lsn(log);
2230                                 if (lowest_lsn &&
2231                                     XFS_LSN_CMP(lowest_lsn,
2232                                                 be64_to_cpu(iclog->ic_header.h_lsn)) < 0) {
2233                                         iclog = iclog->ic_next;
2234                                         continue; /* Leave this iclog for
2235                                                    * another thread */
2236                                 }
2237
2238                                 iclog->ic_state = XLOG_STATE_CALLBACK;
2239
2240                                 spin_unlock(&log->l_icloglock);
2241
2242                                 /* l_last_sync_lsn field protected by
2243                                  * l_grant_lock. Don't worry about iclog's lsn.
2244                                  * No one else can be here except us.
2245                                  */
2246                                 spin_lock(&log->l_grant_lock);
2247                                 ASSERT(XFS_LSN_CMP(log->l_last_sync_lsn,
2248                                        be64_to_cpu(iclog->ic_header.h_lsn)) <= 0);
2249                                 log->l_last_sync_lsn =
2250                                         be64_to_cpu(iclog->ic_header.h_lsn);
2251                                 spin_unlock(&log->l_grant_lock);
2252
2253                         } else {
2254                                 spin_unlock(&log->l_icloglock);
2255                                 ioerrors++;
2256                         }
2257
2258                         /*
2259                          * Keep processing entries in the callback list until
2260                          * we come around and it is empty.  We need to
2261                          * atomically see that the list is empty and change the
2262                          * state to DIRTY so that we don't miss any more
2263                          * callbacks being added.
2264                          */
2265                         spin_lock(&iclog->ic_callback_lock);
2266                         cb = iclog->ic_callback;
2267                         while (cb) {
2268                                 iclog->ic_callback_tail = &(iclog->ic_callback);
2269                                 iclog->ic_callback = NULL;
2270                                 spin_unlock(&iclog->ic_callback_lock);
2271
2272                                 /* perform callbacks in the order given */
2273                                 for (; cb; cb = cb_next) {
2274                                         cb_next = cb->cb_next;
2275                                         cb->cb_func(cb->cb_arg, aborted);
2276                                 }
2277                                 spin_lock(&iclog->ic_callback_lock);
2278                                 cb = iclog->ic_callback;
2279                         }
2280
2281                         loopdidcallbacks++;
2282                         funcdidcallbacks++;
2283
2284                         spin_lock(&log->l_icloglock);
2285                         ASSERT(iclog->ic_callback == NULL);
2286                         spin_unlock(&iclog->ic_callback_lock);
2287                         if (!(iclog->ic_state & XLOG_STATE_IOERROR))
2288                                 iclog->ic_state = XLOG_STATE_DIRTY;
2289
2290                         /*
2291                          * Transition from DIRTY to ACTIVE if applicable.
2292                          * NOP if STATE_IOERROR.
2293                          */
2294                         xlog_state_clean_log(log);
2295
2296                         /* wake up threads waiting in xfs_log_force() */
2297                         sv_broadcast(&iclog->ic_force_wait);
2298
2299                         iclog = iclog->ic_next;
2300                 } while (first_iclog != iclog);
2301
2302                 if (repeats > 5000) {
2303                         flushcnt += repeats;
2304                         repeats = 0;
2305                         xfs_fs_cmn_err(CE_WARN, log->l_mp,
2306                                 "%s: possible infinite loop (%d iterations)",
2307                                 __func__, flushcnt);
2308                 }
2309         } while (!ioerrors && loopdidcallbacks);
2310
2311         /*
2312          * make one last gasp attempt to see if iclogs are being left in
2313          * limbo..
2314          */
2315 #ifdef DEBUG
2316         if (funcdidcallbacks) {
2317                 first_iclog = iclog = log->l_iclog;
2318                 do {
2319                         ASSERT(iclog->ic_state != XLOG_STATE_DO_CALLBACK);
2320                         /*
2321                          * Terminate the loop if iclogs are found in states
2322                          * which will cause other threads to clean up iclogs.
2323                          *
2324                          * SYNCING - i/o completion will go through logs
2325                          * DONE_SYNC - interrupt thread should be waiting for
2326                          *              l_icloglock
2327                          * IOERROR - give up hope all ye who enter here
2328                          */
2329                         if (iclog->ic_state == XLOG_STATE_WANT_SYNC ||
2330                             iclog->ic_state == XLOG_STATE_SYNCING ||
2331                             iclog->ic_state == XLOG_STATE_DONE_SYNC ||
2332                             iclog->ic_state == XLOG_STATE_IOERROR )
2333                                 break;
2334                         iclog = iclog->ic_next;
2335                 } while (first_iclog != iclog);
2336         }
2337 #endif
2338
2339         if (log->l_iclog->ic_state & (XLOG_STATE_ACTIVE|XLOG_STATE_IOERROR))
2340                 wake = 1;
2341         spin_unlock(&log->l_icloglock);
2342
2343         if (wake)
2344                 sv_broadcast(&log->l_flush_wait);
2345 }
2346
2347
2348 /*
2349  * Finish transitioning this iclog to the dirty state.
2350  *
2351  * Make sure that we completely execute this routine only when this is
2352  * the last call to the iclog.  There is a good chance that iclog flushes,
2353  * when we reach the end of the physical log, get turned into 2 separate
2354  * calls to bwrite.  Hence, one iclog flush could generate two calls to this
2355  * routine.  By using the reference count bwritecnt, we guarantee that only
2356  * the second completion goes through.
2357  *
2358  * Callbacks could take time, so they are done outside the scope of the
2359  * global state machine log lock.
2360  */
2361 STATIC void
2362 xlog_state_done_syncing(
2363         xlog_in_core_t  *iclog,
2364         int             aborted)
2365 {
2366         xlog_t             *log = iclog->ic_log;
2367
2368         spin_lock(&log->l_icloglock);
2369
2370         ASSERT(iclog->ic_state == XLOG_STATE_SYNCING ||
2371                iclog->ic_state == XLOG_STATE_IOERROR);
2372         ASSERT(atomic_read(&iclog->ic_refcnt) == 0);
2373         ASSERT(iclog->ic_bwritecnt == 1 || iclog->ic_bwritecnt == 2);
2374
2375
2376         /*
2377          * If we got an error, either on the first buffer, or in the case of
2378          * split log writes, on the second, we mark ALL iclogs STATE_IOERROR,
2379          * and none should ever be attempted to be written to disk
2380          * again.
2381          */
2382         if (iclog->ic_state != XLOG_STATE_IOERROR) {
2383                 if (--iclog->ic_bwritecnt == 1) {
2384                         spin_unlock(&log->l_icloglock);
2385                         return;
2386                 }
2387                 iclog->ic_state = XLOG_STATE_DONE_SYNC;
2388         }
2389
2390         /*
2391          * Someone could be sleeping prior to writing out the next
2392          * iclog buffer, we wake them all, one will get to do the
2393          * I/O, the others get to wait for the result.
2394          */
2395         sv_broadcast(&iclog->ic_write_wait);
2396         spin_unlock(&log->l_icloglock);
2397         xlog_state_do_callback(log, aborted, iclog);    /* also cleans log */
2398 }       /* xlog_state_done_syncing */
2399
2400
2401 /*
2402  * If the head of the in-core log ring is not (ACTIVE or DIRTY), then we must
2403  * sleep.  We wait on the flush queue on the head iclog as that should be
2404  * the first iclog to complete flushing. Hence if all iclogs are syncing,
2405  * we will wait here and all new writes will sleep until a sync completes.
2406  *
2407  * The in-core logs are used in a circular fashion. They are not used
2408  * out-of-order even when an iclog past the head is free.
2409  *
2410  * return:
2411  *      * log_offset where xlog_write() can start writing into the in-core
2412  *              log's data space.
2413  *      * in-core log pointer to which xlog_write() should write.
2414  *      * boolean indicating this is a continued write to an in-core log.
2415  *              If this is the last write, then the in-core log's offset field
2416  *              needs to be incremented, depending on the amount of data which
2417  *              is copied.
2418  */
2419 STATIC int
2420 xlog_state_get_iclog_space(xlog_t         *log,
2421                            int            len,
2422                            xlog_in_core_t **iclogp,
2423                            xlog_ticket_t  *ticket,
2424                            int            *continued_write,
2425                            int            *logoffsetp)
2426 {
2427         int               log_offset;
2428         xlog_rec_header_t *head;
2429         xlog_in_core_t    *iclog;
2430         int               error;
2431
2432 restart:
2433         spin_lock(&log->l_icloglock);
2434         if (XLOG_FORCED_SHUTDOWN(log)) {
2435                 spin_unlock(&log->l_icloglock);
2436                 return XFS_ERROR(EIO);
2437         }
2438
2439         iclog = log->l_iclog;
2440         if (iclog->ic_state != XLOG_STATE_ACTIVE) {
2441                 XFS_STATS_INC(xs_log_noiclogs);
2442
2443                 /* Wait for log writes to have flushed */
2444                 sv_wait(&log->l_flush_wait, 0, &log->l_icloglock, 0);
2445                 goto restart;
2446         }
2447
2448         head = &iclog->ic_header;
2449
2450         atomic_inc(&iclog->ic_refcnt);  /* prevents sync */
2451         log_offset = iclog->ic_offset;
2452
2453         /* On the 1st write to an iclog, figure out lsn.  This works
2454          * if iclogs marked XLOG_STATE_WANT_SYNC always write out what they are
2455          * committing to.  If the offset is set, that's how many blocks
2456          * must be written.
2457          */
2458         if (log_offset == 0) {
2459                 ticket->t_curr_res -= log->l_iclog_hsize;
2460                 xlog_tic_add_region(ticket,
2461                                     log->l_iclog_hsize,
2462                                     XLOG_REG_TYPE_LRHEADER);
2463                 head->h_cycle = cpu_to_be32(log->l_curr_cycle);
2464                 head->h_lsn = cpu_to_be64(
2465                         xlog_assign_lsn(log->l_curr_cycle, log->l_curr_block));
2466                 ASSERT(log->l_curr_block >= 0);
2467         }
2468
2469         /* If there is enough room to write everything, then do it.  Otherwise,
2470          * claim the rest of the region and make sure the XLOG_STATE_WANT_SYNC
2471          * bit is on, so this will get flushed out.  Don't update ic_offset
2472          * until you know exactly how many bytes get copied.  Therefore, wait
2473          * until later to update ic_offset.
2474          *
2475          * xlog_write() algorithm assumes that at least 2 xlog_op_header_t's
2476          * can fit into remaining data section.
2477          */
2478         if (iclog->ic_size - iclog->ic_offset < 2*sizeof(xlog_op_header_t)) {
2479                 xlog_state_switch_iclogs(log, iclog, iclog->ic_size);
2480
2481                 /*
2482                  * If I'm the only one writing to this iclog, sync it to disk.
2483                  * We need to do an atomic compare and decrement here to avoid
2484                  * racing with concurrent atomic_dec_and_lock() calls in
2485                  * xlog_state_release_iclog() when there is more than one
2486                  * reference to the iclog.
2487                  */
2488                 if (!atomic_add_unless(&iclog->ic_refcnt, -1, 1)) {
2489                         /* we are the only one */
2490                         spin_unlock(&log->l_icloglock);
2491                         error = xlog_state_release_iclog(log, iclog);
2492                         if (error)
2493                                 return error;
2494                 } else {
2495                         spin_unlock(&log->l_icloglock);
2496                 }
2497                 goto restart;
2498         }
2499
2500         /* Do we have enough room to write the full amount in the remainder
2501          * of this iclog?  Or must we continue a write on the next iclog and
2502          * mark this iclog as completely taken?  In the case where we switch
2503          * iclogs (to mark it taken), this particular iclog will release/sync
2504          * to disk in xlog_write().
2505          */
2506         if (len <= iclog->ic_size - iclog->ic_offset) {
2507                 *continued_write = 0;
2508                 iclog->ic_offset += len;
2509         } else {
2510                 *continued_write = 1;
2511                 xlog_state_switch_iclogs(log, iclog, iclog->ic_size);
2512         }
2513         *iclogp = iclog;
2514
2515         ASSERT(iclog->ic_offset <= iclog->ic_size);
2516         spin_unlock(&log->l_icloglock);
2517
2518         *logoffsetp = log_offset;
2519         return 0;
2520 }       /* xlog_state_get_iclog_space */
2521
2522 /*
2523  * Atomically get the log space required for a log ticket.
2524  *
2525  * Once a ticket gets put onto the reserveq, it will only return after
2526  * the needed reservation is satisfied.
2527  */
2528 STATIC int
2529 xlog_grant_log_space(xlog_t        *log,
2530                      xlog_ticket_t *tic)
2531 {
2532         int              free_bytes;
2533         int              need_bytes;
2534 #ifdef DEBUG
2535         xfs_lsn_t        tail_lsn;
2536 #endif
2537
2538
2539 #ifdef DEBUG
2540         if (log->l_flags & XLOG_ACTIVE_RECOVERY)
2541                 panic("grant Recovery problem");
2542 #endif
2543
2544         /* Is there space or do we need to sleep? */
2545         spin_lock(&log->l_grant_lock);
2546
2547         trace_xfs_log_grant_enter(log, tic);
2548
2549         /* something is already sleeping; insert new transaction at end */
2550         if (log->l_reserve_headq) {
2551                 xlog_ins_ticketq(&log->l_reserve_headq, tic);
2552
2553                 trace_xfs_log_grant_sleep1(log, tic);
2554
2555                 /*
2556                  * Gotta check this before going to sleep, while we're
2557                  * holding the grant lock.
2558                  */
2559                 if (XLOG_FORCED_SHUTDOWN(log))
2560                         goto error_return;
2561
2562                 XFS_STATS_INC(xs_sleep_logspace);
2563                 sv_wait(&tic->t_wait, PINOD|PLTWAIT, &log->l_grant_lock, s);
2564                 /*
2565                  * If we got an error, and the filesystem is shutting down,
2566                  * we'll catch it down below. So just continue...
2567                  */
2568                 trace_xfs_log_grant_wake1(log, tic);
2569                 spin_lock(&log->l_grant_lock);
2570         }
2571         if (tic->t_flags & XFS_LOG_PERM_RESERV)
2572                 need_bytes = tic->t_unit_res*tic->t_ocnt;
2573         else
2574                 need_bytes = tic->t_unit_res;
2575
2576 redo:
2577         if (XLOG_FORCED_SHUTDOWN(log))
2578                 goto error_return;
2579
2580         free_bytes = xlog_space_left(log, log->l_grant_reserve_cycle,
2581                                      log->l_grant_reserve_bytes);
2582         if (free_bytes < need_bytes) {
2583                 if ((tic->t_flags & XLOG_TIC_IN_Q) == 0)
2584                         xlog_ins_ticketq(&log->l_reserve_headq, tic);
2585
2586                 trace_xfs_log_grant_sleep2(log, tic);
2587
2588                 spin_unlock(&log->l_grant_lock);
2589                 xlog_grant_push_ail(log->l_mp, need_bytes);
2590                 spin_lock(&log->l_grant_lock);
2591
2592                 XFS_STATS_INC(xs_sleep_logspace);
2593                 sv_wait(&tic->t_wait, PINOD|PLTWAIT, &log->l_grant_lock, s);
2594
2595                 spin_lock(&log->l_grant_lock);
2596                 if (XLOG_FORCED_SHUTDOWN(log))
2597                         goto error_return;
2598
2599                 trace_xfs_log_grant_wake2(log, tic);
2600
2601                 goto redo;
2602         } else if (tic->t_flags & XLOG_TIC_IN_Q)
2603                 xlog_del_ticketq(&log->l_reserve_headq, tic);
2604
2605         /* we've got enough space */
2606         xlog_grant_add_space(log, need_bytes);
2607 #ifdef DEBUG
2608         tail_lsn = log->l_tail_lsn;
2609         /*
2610          * Check to make sure the grant write head didn't just over lap the
2611          * tail.  If the cycles are the same, we can't be overlapping.
2612          * Otherwise, make sure that the cycles differ by exactly one and
2613          * check the byte count.
2614          */
2615         if (CYCLE_LSN(tail_lsn) != log->l_grant_write_cycle) {
2616                 ASSERT(log->l_grant_write_cycle-1 == CYCLE_LSN(tail_lsn));
2617                 ASSERT(log->l_grant_write_bytes <= BBTOB(BLOCK_LSN(tail_lsn)));
2618         }
2619 #endif
2620         trace_xfs_log_grant_exit(log, tic);
2621         xlog_verify_grant_head(log, 1);
2622         spin_unlock(&log->l_grant_lock);
2623         return 0;
2624
2625  error_return:
2626         if (tic->t_flags & XLOG_TIC_IN_Q)
2627                 xlog_del_ticketq(&log->l_reserve_headq, tic);
2628
2629         trace_xfs_log_grant_error(log, tic);
2630
2631         /*
2632          * If we are failing, make sure the ticket doesn't have any
2633          * current reservations. We don't want to add this back when
2634          * the ticket/transaction gets cancelled.
2635          */
2636         tic->t_curr_res = 0;
2637         tic->t_cnt = 0; /* ungrant will give back unit_res * t_cnt. */
2638         spin_unlock(&log->l_grant_lock);
2639         return XFS_ERROR(EIO);
2640 }       /* xlog_grant_log_space */
2641
2642
2643 /*
2644  * Replenish the byte reservation required by moving the grant write head.
2645  *
2646  *
2647  */
2648 STATIC int
2649 xlog_regrant_write_log_space(xlog_t        *log,
2650                              xlog_ticket_t *tic)
2651 {
2652         int             free_bytes, need_bytes;
2653         xlog_ticket_t   *ntic;
2654 #ifdef DEBUG
2655         xfs_lsn_t       tail_lsn;
2656 #endif
2657
2658         tic->t_curr_res = tic->t_unit_res;
2659         xlog_tic_reset_res(tic);
2660
2661         if (tic->t_cnt > 0)
2662                 return 0;
2663
2664 #ifdef DEBUG
2665         if (log->l_flags & XLOG_ACTIVE_RECOVERY)
2666                 panic("regrant Recovery problem");
2667 #endif
2668
2669         spin_lock(&log->l_grant_lock);
2670
2671         trace_xfs_log_regrant_write_enter(log, tic);
2672
2673         if (XLOG_FORCED_SHUTDOWN(log))
2674                 goto error_return;
2675
2676         /* If there are other waiters on the queue then give them a
2677          * chance at logspace before us. Wake up the first waiters,
2678          * if we do not wake up all the waiters then go to sleep waiting
2679          * for more free space, otherwise try to get some space for
2680          * this transaction.
2681          */
2682         need_bytes = tic->t_unit_res;
2683         if ((ntic = log->l_write_headq)) {
2684                 free_bytes = xlog_space_left(log, log->l_grant_write_cycle,
2685                                              log->l_grant_write_bytes);
2686                 do {
2687                         ASSERT(ntic->t_flags & XLOG_TIC_PERM_RESERV);
2688
2689                         if (free_bytes < ntic->t_unit_res)
2690                                 break;
2691                         free_bytes -= ntic->t_unit_res;
2692                         sv_signal(&ntic->t_wait);
2693                         ntic = ntic->t_next;
2694                 } while (ntic != log->l_write_headq);
2695
2696                 if (ntic != log->l_write_headq) {
2697                         if ((tic->t_flags & XLOG_TIC_IN_Q) == 0)
2698                                 xlog_ins_ticketq(&log->l_write_headq, tic);
2699
2700                         trace_xfs_log_regrant_write_sleep1(log, tic);
2701
2702                         spin_unlock(&log->l_grant_lock);
2703                         xlog_grant_push_ail(log->l_mp, need_bytes);
2704                         spin_lock(&log->l_grant_lock);
2705
2706                         XFS_STATS_INC(xs_sleep_logspace);
2707                         sv_wait(&tic->t_wait, PINOD|PLTWAIT,
2708                                 &log->l_grant_lock, s);
2709
2710                         /* If we're shutting down, this tic is already
2711                          * off the queue */
2712                         spin_lock(&log->l_grant_lock);
2713                         if (XLOG_FORCED_SHUTDOWN(log))
2714                                 goto error_return;
2715
2716                         trace_xfs_log_regrant_write_wake1(log, tic);
2717                 }
2718         }
2719
2720 redo:
2721         if (XLOG_FORCED_SHUTDOWN(log))
2722                 goto error_return;
2723
2724         free_bytes = xlog_space_left(log, log->l_grant_write_cycle,
2725                                      log->l_grant_write_bytes);
2726         if (free_bytes < need_bytes) {
2727                 if ((tic->t_flags & XLOG_TIC_IN_Q) == 0)
2728                         xlog_ins_ticketq(&log->l_write_headq, tic);
2729                 spin_unlock(&log->l_grant_lock);
2730                 xlog_grant_push_ail(log->l_mp, need_bytes);
2731                 spin_lock(&log->l_grant_lock);
2732
2733                 XFS_STATS_INC(xs_sleep_logspace);
2734                 trace_xfs_log_regrant_write_sleep2(log, tic);
2735
2736                 sv_wait(&tic->t_wait, PINOD|PLTWAIT, &log->l_grant_lock, s);
2737
2738                 /* If we're shutting down, this tic is already off the queue */
2739                 spin_lock(&log->l_grant_lock);
2740                 if (XLOG_FORCED_SHUTDOWN(log))
2741                         goto error_return;
2742
2743                 trace_xfs_log_regrant_write_wake2(log, tic);
2744                 goto redo;
2745         } else if (tic->t_flags & XLOG_TIC_IN_Q)
2746                 xlog_del_ticketq(&log->l_write_headq, tic);
2747
2748         /* we've got enough space */
2749         xlog_grant_add_space_write(log, need_bytes);
2750 #ifdef DEBUG
2751         tail_lsn = log->l_tail_lsn;
2752         if (CYCLE_LSN(tail_lsn) != log->l_grant_write_cycle) {
2753                 ASSERT(log->l_grant_write_cycle-1 == CYCLE_LSN(tail_lsn));
2754                 ASSERT(log->l_grant_write_bytes <= BBTOB(BLOCK_LSN(tail_lsn)));
2755         }
2756 #endif
2757
2758         trace_xfs_log_regrant_write_exit(log, tic);
2759
2760         xlog_verify_grant_head(log, 1);
2761         spin_unlock(&log->l_grant_lock);
2762         return 0;
2763
2764
2765  error_return:
2766         if (tic->t_flags & XLOG_TIC_IN_Q)
2767                 xlog_del_ticketq(&log->l_reserve_headq, tic);
2768
2769         trace_xfs_log_regrant_write_error(log, tic);
2770
2771         /*
2772          * If we are failing, make sure the ticket doesn't have any
2773          * current reservations. We don't want to add this back when
2774          * the ticket/transaction gets cancelled.
2775          */
2776         tic->t_curr_res = 0;
2777         tic->t_cnt = 0; /* ungrant will give back unit_res * t_cnt. */
2778         spin_unlock(&log->l_grant_lock);
2779         return XFS_ERROR(EIO);
2780 }       /* xlog_regrant_write_log_space */
2781
2782
2783 /* The first cnt-1 times through here we don't need to
2784  * move the grant write head because the permanent
2785  * reservation has reserved cnt times the unit amount.
2786  * Release part of current permanent unit reservation and
2787  * reset current reservation to be one units worth.  Also
2788  * move grant reservation head forward.
2789  */
2790 STATIC void
2791 xlog_regrant_reserve_log_space(xlog_t        *log,
2792                                xlog_ticket_t *ticket)
2793 {
2794         trace_xfs_log_regrant_reserve_enter(log, ticket);
2795
2796         if (ticket->t_cnt > 0)
2797                 ticket->t_cnt--;
2798
2799         spin_lock(&log->l_grant_lock);
2800         xlog_grant_sub_space(log, ticket->t_curr_res);
2801         ticket->t_curr_res = ticket->t_unit_res;
2802         xlog_tic_reset_res(ticket);
2803
2804         trace_xfs_log_regrant_reserve_sub(log, ticket);
2805
2806         xlog_verify_grant_head(log, 1);
2807
2808         /* just return if we still have some of the pre-reserved space */
2809         if (ticket->t_cnt > 0) {
2810                 spin_unlock(&log->l_grant_lock);
2811                 return;
2812         }
2813
2814         xlog_grant_add_space_reserve(log, ticket->t_unit_res);
2815
2816         trace_xfs_log_regrant_reserve_exit(log, ticket);
2817
2818         xlog_verify_grant_head(log, 0);
2819         spin_unlock(&log->l_grant_lock);
2820         ticket->t_curr_res = ticket->t_unit_res;
2821         xlog_tic_reset_res(ticket);
2822 }       /* xlog_regrant_reserve_log_space */
2823
2824
2825 /*
2826  * Give back the space left from a reservation.
2827  *
2828  * All the information we need to make a correct determination of space left
2829  * is present.  For non-permanent reservations, things are quite easy.  The
2830  * count should have been decremented to zero.  We only need to deal with the
2831  * space remaining in the current reservation part of the ticket.  If the
2832  * ticket contains a permanent reservation, there may be left over space which
2833  * needs to be released.  A count of N means that N-1 refills of the current
2834  * reservation can be done before we need to ask for more space.  The first
2835  * one goes to fill up the first current reservation.  Once we run out of
2836  * space, the count will stay at zero and the only space remaining will be
2837  * in the current reservation field.
2838  */
2839 STATIC void
2840 xlog_ungrant_log_space(xlog_t        *log,
2841                        xlog_ticket_t *ticket)
2842 {
2843         if (ticket->t_cnt > 0)
2844                 ticket->t_cnt--;
2845
2846         spin_lock(&log->l_grant_lock);
2847         trace_xfs_log_ungrant_enter(log, ticket);
2848
2849         xlog_grant_sub_space(log, ticket->t_curr_res);
2850
2851         trace_xfs_log_ungrant_sub(log, ticket);
2852
2853         /* If this is a permanent reservation ticket, we may be able to free
2854          * up more space based on the remaining count.
2855          */
2856         if (ticket->t_cnt > 0) {
2857                 ASSERT(ticket->t_flags & XLOG_TIC_PERM_RESERV);
2858                 xlog_grant_sub_space(log, ticket->t_unit_res*ticket->t_cnt);
2859         }
2860
2861         trace_xfs_log_ungrant_exit(log, ticket);
2862
2863         xlog_verify_grant_head(log, 1);
2864         spin_unlock(&log->l_grant_lock);
2865         xfs_log_move_tail(log->l_mp, 1);
2866 }       /* xlog_ungrant_log_space */
2867
2868
2869 /*
2870  * Flush iclog to disk if this is the last reference to the given iclog and
2871  * the WANT_SYNC bit is set.
2872  *
2873  * When this function is entered, the iclog is not necessarily in the
2874  * WANT_SYNC state.  It may be sitting around waiting to get filled.
2875  *
2876  *
2877  */
2878 STATIC int
2879 xlog_state_release_iclog(
2880         xlog_t          *log,
2881         xlog_in_core_t  *iclog)
2882 {
2883         int             sync = 0;       /* do we sync? */
2884
2885         if (iclog->ic_state & XLOG_STATE_IOERROR)
2886                 return XFS_ERROR(EIO);
2887
2888         ASSERT(atomic_read(&iclog->ic_refcnt) > 0);
2889         if (!atomic_dec_and_lock(&iclog->ic_refcnt, &log->l_icloglock))
2890                 return 0;
2891
2892         if (iclog->ic_state & XLOG_STATE_IOERROR) {
2893                 spin_unlock(&log->l_icloglock);
2894                 return XFS_ERROR(EIO);
2895         }
2896         ASSERT(iclog->ic_state == XLOG_STATE_ACTIVE ||
2897                iclog->ic_state == XLOG_STATE_WANT_SYNC);
2898
2899         if (iclog->ic_state == XLOG_STATE_WANT_SYNC) {
2900                 /* update tail before writing to iclog */
2901                 xlog_assign_tail_lsn(log->l_mp);
2902                 sync++;
2903                 iclog->ic_state = XLOG_STATE_SYNCING;
2904                 iclog->ic_header.h_tail_lsn = cpu_to_be64(log->l_tail_lsn);
2905                 xlog_verify_tail_lsn(log, iclog, log->l_tail_lsn);
2906                 /* cycle incremented when incrementing curr_block */
2907         }
2908         spin_unlock(&log->l_icloglock);
2909
2910         /*
2911          * We let the log lock go, so it's possible that we hit a log I/O
2912          * error or some other SHUTDOWN condition that marks the iclog
2913          * as XLOG_STATE_IOERROR before the bwrite. However, we know that
2914          * this iclog has consistent data, so we ignore IOERROR
2915          * flags after this point.
2916          */
2917         if (sync)
2918                 return xlog_sync(log, iclog);
2919         return 0;
2920 }       /* xlog_state_release_iclog */
2921
2922
2923 /*
2924  * This routine will mark the current iclog in the ring as WANT_SYNC
2925  * and move the current iclog pointer to the next iclog in the ring.
2926  * When this routine is called from xlog_state_get_iclog_space(), the
2927  * exact size of the iclog has not yet been determined.  All we know is
2928  * that every data block.  We have run out of space in this log record.
2929  */
2930 STATIC void
2931 xlog_state_switch_iclogs(xlog_t         *log,
2932                          xlog_in_core_t *iclog,
2933                          int            eventual_size)
2934 {
2935         ASSERT(iclog->ic_state == XLOG_STATE_ACTIVE);
2936         if (!eventual_size)
2937                 eventual_size = iclog->ic_offset;
2938         iclog->ic_state = XLOG_STATE_WANT_SYNC;
2939         iclog->ic_header.h_prev_block = cpu_to_be32(log->l_prev_block);
2940         log->l_prev_block = log->l_curr_block;
2941         log->l_prev_cycle = log->l_curr_cycle;
2942
2943         /* roll log?: ic_offset changed later */
2944         log->l_curr_block += BTOBB(eventual_size)+BTOBB(log->l_iclog_hsize);
2945
2946         /* Round up to next log-sunit */
2947         if (xfs_sb_version_haslogv2(&log->l_mp->m_sb) &&
2948             log->l_mp->m_sb.sb_logsunit > 1) {
2949                 __uint32_t sunit_bb = BTOBB(log->l_mp->m_sb.sb_logsunit);
2950                 log->l_curr_block = roundup(log->l_curr_block, sunit_bb);
2951         }
2952
2953         if (log->l_curr_block >= log->l_logBBsize) {
2954                 log->l_curr_cycle++;
2955                 if (log->l_curr_cycle == XLOG_HEADER_MAGIC_NUM)
2956                         log->l_curr_cycle++;
2957                 log->l_curr_block -= log->l_logBBsize;
2958                 ASSERT(log->l_curr_block >= 0);
2959         }
2960         ASSERT(iclog == log->l_iclog);
2961         log->l_iclog = iclog->ic_next;
2962 }       /* xlog_state_switch_iclogs */
2963
2964 /*
2965  * Write out all data in the in-core log as of this exact moment in time.
2966  *
2967  * Data may be written to the in-core log during this call.  However,
2968  * we don't guarantee this data will be written out.  A change from past
2969  * implementation means this routine will *not* write out zero length LRs.
2970  *
2971  * Basically, we try and perform an intelligent scan of the in-core logs.
2972  * If we determine there is no flushable data, we just return.  There is no
2973  * flushable data if:
2974  *
2975  *      1. the current iclog is active and has no data; the previous iclog
2976  *              is in the active or dirty state.
2977  *      2. the current iclog is drity, and the previous iclog is in the
2978  *              active or dirty state.
2979  *
2980  * We may sleep if:
2981  *
2982  *      1. the current iclog is not in the active nor dirty state.
2983  *      2. the current iclog dirty, and the previous iclog is not in the
2984  *              active nor dirty state.
2985  *      3. the current iclog is active, and there is another thread writing
2986  *              to this particular iclog.
2987  *      4. a) the current iclog is active and has no other writers
2988  *         b) when we return from flushing out this iclog, it is still
2989  *              not in the active nor dirty state.
2990  */
2991 int
2992 _xfs_log_force(
2993         struct xfs_mount        *mp,
2994         uint                    flags,
2995         int                     *log_flushed)
2996 {
2997         struct log              *log = mp->m_log;
2998         struct xlog_in_core     *iclog;
2999         xfs_lsn_t               lsn;
3000
3001         XFS_STATS_INC(xs_log_force);
3002
3003         spin_lock(&log->l_icloglock);
3004
3005         iclog = log->l_iclog;
3006         if (iclog->ic_state & XLOG_STATE_IOERROR) {
3007                 spin_unlock(&log->l_icloglock);
3008                 return XFS_ERROR(EIO);
3009         }
3010
3011         /* If the head iclog is not active nor dirty, we just attach
3012          * ourselves to the head and go to sleep.
3013          */
3014         if (iclog->ic_state == XLOG_STATE_ACTIVE ||
3015             iclog->ic_state == XLOG_STATE_DIRTY) {
3016                 /*
3017                  * If the head is dirty or (active and empty), then
3018                  * we need to look at the previous iclog.  If the previous
3019                  * iclog is active or dirty we are done.  There is nothing
3020                  * to sync out.  Otherwise, we attach ourselves to the
3021                  * previous iclog and go to sleep.
3022                  */
3023                 if (iclog->ic_state == XLOG_STATE_DIRTY ||
3024                     (atomic_read(&iclog->ic_refcnt) == 0
3025                      && iclog->ic_offset == 0)) {
3026                         iclog = iclog->ic_prev;
3027                         if (iclog->ic_state == XLOG_STATE_ACTIVE ||
3028                             iclog->ic_state == XLOG_STATE_DIRTY)
3029                                 goto no_sleep;
3030                         else
3031                                 goto maybe_sleep;
3032                 } else {
3033                         if (atomic_read(&iclog->ic_refcnt) == 0) {
3034                                 /* We are the only one with access to this
3035                                  * iclog.  Flush it out now.  There should
3036                                  * be a roundoff of zero to show that someone
3037                                  * has already taken care of the roundoff from
3038                                  * the previous sync.
3039                                  */
3040                                 atomic_inc(&iclog->ic_refcnt);
3041                                 lsn = be64_to_cpu(iclog->ic_header.h_lsn);
3042                                 xlog_state_switch_iclogs(log, iclog, 0);
3043                                 spin_unlock(&log->l_icloglock);
3044
3045                                 if (xlog_state_release_iclog(log, iclog))
3046                                         return XFS_ERROR(EIO);
3047
3048                                 if (log_flushed)
3049                                         *log_flushed = 1;
3050                                 spin_lock(&log->l_icloglock);
3051                                 if (be64_to_cpu(iclog->ic_header.h_lsn) == lsn &&
3052                                     iclog->ic_state != XLOG_STATE_DIRTY)
3053                                         goto maybe_sleep;
3054                                 else
3055                                         goto no_sleep;
3056                         } else {
3057                                 /* Someone else is writing to this iclog.
3058                                  * Use its call to flush out the data.  However,
3059                                  * the other thread may not force out this LR,
3060                                  * so we mark it WANT_SYNC.
3061                                  */
3062                                 xlog_state_switch_iclogs(log, iclog, 0);
3063                                 goto maybe_sleep;
3064                         }
3065                 }
3066         }
3067
3068         /* By the time we come around again, the iclog could've been filled
3069          * which would give it another lsn.  If we have a new lsn, just
3070          * return because the relevant data has been flushed.
3071          */
3072 maybe_sleep:
3073         if (flags & XFS_LOG_SYNC) {
3074                 /*
3075                  * We must check if we're shutting down here, before
3076                  * we wait, while we're holding the l_icloglock.
3077                  * Then we check again after waking up, in case our
3078                  * sleep was disturbed by a bad news.
3079                  */
3080                 if (iclog->ic_state & XLOG_STATE_IOERROR) {
3081                         spin_unlock(&log->l_icloglock);
3082                         return XFS_ERROR(EIO);
3083                 }
3084                 XFS_STATS_INC(xs_log_force_sleep);
3085                 sv_wait(&iclog->ic_force_wait, PINOD, &log->l_icloglock, s);
3086                 /*