[BRIDGE]: fix locking and memory leak in br_add_bridge
[linux-2.6] / fs / xfs / xfs_buf_item.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_dir.h"
27 #include "xfs_dmapi.h"
28 #include "xfs_mount.h"
29 #include "xfs_buf_item.h"
30 #include "xfs_trans_priv.h"
31 #include "xfs_error.h"
32
33
34 kmem_zone_t     *xfs_buf_item_zone;
35
36 #ifdef XFS_TRANS_DEBUG
37 /*
38  * This function uses an alternate strategy for tracking the bytes
39  * that the user requests to be logged.  This can then be used
40  * in conjunction with the bli_orig array in the buf log item to
41  * catch bugs in our callers' code.
42  *
43  * We also double check the bits set in xfs_buf_item_log using a
44  * simple algorithm to check that every byte is accounted for.
45  */
46 STATIC void
47 xfs_buf_item_log_debug(
48         xfs_buf_log_item_t      *bip,
49         uint                    first,
50         uint                    last)
51 {
52         uint    x;
53         uint    byte;
54         uint    nbytes;
55         uint    chunk_num;
56         uint    word_num;
57         uint    bit_num;
58         uint    bit_set;
59         uint    *wordp;
60
61         ASSERT(bip->bli_logged != NULL);
62         byte = first;
63         nbytes = last - first + 1;
64         bfset(bip->bli_logged, first, nbytes);
65         for (x = 0; x < nbytes; x++) {
66                 chunk_num = byte >> XFS_BLI_SHIFT;
67                 word_num = chunk_num >> BIT_TO_WORD_SHIFT;
68                 bit_num = chunk_num & (NBWORD - 1);
69                 wordp = &(bip->bli_format.blf_data_map[word_num]);
70                 bit_set = *wordp & (1 << bit_num);
71                 ASSERT(bit_set);
72                 byte++;
73         }
74 }
75
76 /*
77  * This function is called when we flush something into a buffer without
78  * logging it.  This happens for things like inodes which are logged
79  * separately from the buffer.
80  */
81 void
82 xfs_buf_item_flush_log_debug(
83         xfs_buf_t       *bp,
84         uint            first,
85         uint            last)
86 {
87         xfs_buf_log_item_t      *bip;
88         uint                    nbytes;
89
90         bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t*);
91         if ((bip == NULL) || (bip->bli_item.li_type != XFS_LI_BUF)) {
92                 return;
93         }
94
95         ASSERT(bip->bli_logged != NULL);
96         nbytes = last - first + 1;
97         bfset(bip->bli_logged, first, nbytes);
98 }
99
100 /*
101  * This function is called to verify that our callers have logged
102  * all the bytes that they changed.
103  *
104  * It does this by comparing the original copy of the buffer stored in
105  * the buf log item's bli_orig array to the current copy of the buffer
106  * and ensuring that all bytes which mismatch are set in the bli_logged
107  * array of the buf log item.
108  */
109 STATIC void
110 xfs_buf_item_log_check(
111         xfs_buf_log_item_t      *bip)
112 {
113         char            *orig;
114         char            *buffer;
115         int             x;
116         xfs_buf_t       *bp;
117
118         ASSERT(bip->bli_orig != NULL);
119         ASSERT(bip->bli_logged != NULL);
120
121         bp = bip->bli_buf;
122         ASSERT(XFS_BUF_COUNT(bp) > 0);
123         ASSERT(XFS_BUF_PTR(bp) != NULL);
124         orig = bip->bli_orig;
125         buffer = XFS_BUF_PTR(bp);
126         for (x = 0; x < XFS_BUF_COUNT(bp); x++) {
127                 if (orig[x] != buffer[x] && !btst(bip->bli_logged, x))
128                         cmn_err(CE_PANIC,
129         "xfs_buf_item_log_check bip %x buffer %x orig %x index %d",
130                                 bip, bp, orig, x);
131         }
132 }
133 #else
134 #define         xfs_buf_item_log_debug(x,y,z)
135 #define         xfs_buf_item_log_check(x)
136 #endif
137
138 STATIC void     xfs_buf_error_relse(xfs_buf_t *bp);
139 STATIC void     xfs_buf_do_callbacks(xfs_buf_t *bp, xfs_log_item_t *lip);
140
141 /*
142  * This returns the number of log iovecs needed to log the
143  * given buf log item.
144  *
145  * It calculates this as 1 iovec for the buf log format structure
146  * and 1 for each stretch of non-contiguous chunks to be logged.
147  * Contiguous chunks are logged in a single iovec.
148  *
149  * If the XFS_BLI_STALE flag has been set, then log nothing.
150  */
151 STATIC uint
152 xfs_buf_item_size(
153         xfs_buf_log_item_t      *bip)
154 {
155         uint            nvecs;
156         int             next_bit;
157         int             last_bit;
158         xfs_buf_t       *bp;
159
160         ASSERT(atomic_read(&bip->bli_refcount) > 0);
161         if (bip->bli_flags & XFS_BLI_STALE) {
162                 /*
163                  * The buffer is stale, so all we need to log
164                  * is the buf log format structure with the
165                  * cancel flag in it.
166                  */
167                 xfs_buf_item_trace("SIZE STALE", bip);
168                 ASSERT(bip->bli_format.blf_flags & XFS_BLI_CANCEL);
169                 return 1;
170         }
171
172         bp = bip->bli_buf;
173         ASSERT(bip->bli_flags & XFS_BLI_LOGGED);
174         nvecs = 1;
175         last_bit = xfs_next_bit(bip->bli_format.blf_data_map,
176                                          bip->bli_format.blf_map_size, 0);
177         ASSERT(last_bit != -1);
178         nvecs++;
179         while (last_bit != -1) {
180                 /*
181                  * This takes the bit number to start looking from and
182                  * returns the next set bit from there.  It returns -1
183                  * if there are no more bits set or the start bit is
184                  * beyond the end of the bitmap.
185                  */
186                 next_bit = xfs_next_bit(bip->bli_format.blf_data_map,
187                                                  bip->bli_format.blf_map_size,
188                                                  last_bit + 1);
189                 /*
190                  * If we run out of bits, leave the loop,
191                  * else if we find a new set of bits bump the number of vecs,
192                  * else keep scanning the current set of bits.
193                  */
194                 if (next_bit == -1) {
195                         last_bit = -1;
196                 } else if (next_bit != last_bit + 1) {
197                         last_bit = next_bit;
198                         nvecs++;
199                 } else if (xfs_buf_offset(bp, next_bit * XFS_BLI_CHUNK) !=
200                            (xfs_buf_offset(bp, last_bit * XFS_BLI_CHUNK) +
201                             XFS_BLI_CHUNK)) {
202                         last_bit = next_bit;
203                         nvecs++;
204                 } else {
205                         last_bit++;
206                 }
207         }
208
209         xfs_buf_item_trace("SIZE NORM", bip);
210         return nvecs;
211 }
212
213 /*
214  * This is called to fill in the vector of log iovecs for the
215  * given log buf item.  It fills the first entry with a buf log
216  * format structure, and the rest point to contiguous chunks
217  * within the buffer.
218  */
219 STATIC void
220 xfs_buf_item_format(
221         xfs_buf_log_item_t      *bip,
222         xfs_log_iovec_t         *log_vector)
223 {
224         uint            base_size;
225         uint            nvecs;
226         xfs_log_iovec_t *vecp;
227         xfs_buf_t       *bp;
228         int             first_bit;
229         int             last_bit;
230         int             next_bit;
231         uint            nbits;
232         uint            buffer_offset;
233
234         ASSERT(atomic_read(&bip->bli_refcount) > 0);
235         ASSERT((bip->bli_flags & XFS_BLI_LOGGED) ||
236                (bip->bli_flags & XFS_BLI_STALE));
237         bp = bip->bli_buf;
238         ASSERT(XFS_BUF_BP_ISMAPPED(bp));
239         vecp = log_vector;
240
241         /*
242          * The size of the base structure is the size of the
243          * declared structure plus the space for the extra words
244          * of the bitmap.  We subtract one from the map size, because
245          * the first element of the bitmap is accounted for in the
246          * size of the base structure.
247          */
248         base_size =
249                 (uint)(sizeof(xfs_buf_log_format_t) +
250                        ((bip->bli_format.blf_map_size - 1) * sizeof(uint)));
251         vecp->i_addr = (xfs_caddr_t)&bip->bli_format;
252         vecp->i_len = base_size;
253         XLOG_VEC_SET_TYPE(vecp, XLOG_REG_TYPE_BFORMAT);
254         vecp++;
255         nvecs = 1;
256
257         if (bip->bli_flags & XFS_BLI_STALE) {
258                 /*
259                  * The buffer is stale, so all we need to log
260                  * is the buf log format structure with the
261                  * cancel flag in it.
262                  */
263                 xfs_buf_item_trace("FORMAT STALE", bip);
264                 ASSERT(bip->bli_format.blf_flags & XFS_BLI_CANCEL);
265                 bip->bli_format.blf_size = nvecs;
266                 return;
267         }
268
269         /*
270          * Fill in an iovec for each set of contiguous chunks.
271          */
272         first_bit = xfs_next_bit(bip->bli_format.blf_data_map,
273                                          bip->bli_format.blf_map_size, 0);
274         ASSERT(first_bit != -1);
275         last_bit = first_bit;
276         nbits = 1;
277         for (;;) {
278                 /*
279                  * This takes the bit number to start looking from and
280                  * returns the next set bit from there.  It returns -1
281                  * if there are no more bits set or the start bit is
282                  * beyond the end of the bitmap.
283                  */
284                 next_bit = xfs_next_bit(bip->bli_format.blf_data_map,
285                                                  bip->bli_format.blf_map_size,
286                                                  (uint)last_bit + 1);
287                 /*
288                  * If we run out of bits fill in the last iovec and get
289                  * out of the loop.
290                  * Else if we start a new set of bits then fill in the
291                  * iovec for the series we were looking at and start
292                  * counting the bits in the new one.
293                  * Else we're still in the same set of bits so just
294                  * keep counting and scanning.
295                  */
296                 if (next_bit == -1) {
297                         buffer_offset = first_bit * XFS_BLI_CHUNK;
298                         vecp->i_addr = xfs_buf_offset(bp, buffer_offset);
299                         vecp->i_len = nbits * XFS_BLI_CHUNK;
300                         XLOG_VEC_SET_TYPE(vecp, XLOG_REG_TYPE_BCHUNK);
301                         nvecs++;
302                         break;
303                 } else if (next_bit != last_bit + 1) {
304                         buffer_offset = first_bit * XFS_BLI_CHUNK;
305                         vecp->i_addr = xfs_buf_offset(bp, buffer_offset);
306                         vecp->i_len = nbits * XFS_BLI_CHUNK;
307                         XLOG_VEC_SET_TYPE(vecp, XLOG_REG_TYPE_BCHUNK);
308                         nvecs++;
309                         vecp++;
310                         first_bit = next_bit;
311                         last_bit = next_bit;
312                         nbits = 1;
313                 } else if (xfs_buf_offset(bp, next_bit << XFS_BLI_SHIFT) !=
314                            (xfs_buf_offset(bp, last_bit << XFS_BLI_SHIFT) +
315                             XFS_BLI_CHUNK)) {
316                         buffer_offset = first_bit * XFS_BLI_CHUNK;
317                         vecp->i_addr = xfs_buf_offset(bp, buffer_offset);
318                         vecp->i_len = nbits * XFS_BLI_CHUNK;
319                         XLOG_VEC_SET_TYPE(vecp, XLOG_REG_TYPE_BCHUNK);
320 /* You would think we need to bump the nvecs here too, but we do not
321  * this number is used by recovery, and it gets confused by the boundary
322  * split here
323  *                      nvecs++;
324  */
325                         vecp++;
326                         first_bit = next_bit;
327                         last_bit = next_bit;
328                         nbits = 1;
329                 } else {
330                         last_bit++;
331                         nbits++;
332                 }
333         }
334         bip->bli_format.blf_size = nvecs;
335
336         /*
337          * Check to make sure everything is consistent.
338          */
339         xfs_buf_item_trace("FORMAT NORM", bip);
340         xfs_buf_item_log_check(bip);
341 }
342
343 /*
344  * This is called to pin the buffer associated with the buf log
345  * item in memory so it cannot be written out.  Simply call bpin()
346  * on the buffer to do this.
347  */
348 STATIC void
349 xfs_buf_item_pin(
350         xfs_buf_log_item_t      *bip)
351 {
352         xfs_buf_t       *bp;
353
354         bp = bip->bli_buf;
355         ASSERT(XFS_BUF_ISBUSY(bp));
356         ASSERT(atomic_read(&bip->bli_refcount) > 0);
357         ASSERT((bip->bli_flags & XFS_BLI_LOGGED) ||
358                (bip->bli_flags & XFS_BLI_STALE));
359         xfs_buf_item_trace("PIN", bip);
360         xfs_buftrace("XFS_PIN", bp);
361         xfs_bpin(bp);
362 }
363
364
365 /*
366  * This is called to unpin the buffer associated with the buf log
367  * item which was previously pinned with a call to xfs_buf_item_pin().
368  * Just call bunpin() on the buffer to do this.
369  *
370  * Also drop the reference to the buf item for the current transaction.
371  * If the XFS_BLI_STALE flag is set and we are the last reference,
372  * then free up the buf log item and unlock the buffer.
373  */
374 STATIC void
375 xfs_buf_item_unpin(
376         xfs_buf_log_item_t      *bip,
377         int                     stale)
378 {
379         xfs_mount_t     *mp;
380         xfs_buf_t       *bp;
381         int             freed;
382         SPLDECL(s);
383
384         bp = bip->bli_buf;
385         ASSERT(bp != NULL);
386         ASSERT(XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t *) == bip);
387         ASSERT(atomic_read(&bip->bli_refcount) > 0);
388         xfs_buf_item_trace("UNPIN", bip);
389         xfs_buftrace("XFS_UNPIN", bp);
390
391         freed = atomic_dec_and_test(&bip->bli_refcount);
392         mp = bip->bli_item.li_mountp;
393         xfs_bunpin(bp);
394         if (freed && stale) {
395                 ASSERT(bip->bli_flags & XFS_BLI_STALE);
396                 ASSERT(XFS_BUF_VALUSEMA(bp) <= 0);
397                 ASSERT(!(XFS_BUF_ISDELAYWRITE(bp)));
398                 ASSERT(XFS_BUF_ISSTALE(bp));
399                 ASSERT(bip->bli_format.blf_flags & XFS_BLI_CANCEL);
400                 xfs_buf_item_trace("UNPIN STALE", bip);
401                 xfs_buftrace("XFS_UNPIN STALE", bp);
402                 /*
403                  * If we get called here because of an IO error, we may
404                  * or may not have the item on the AIL. xfs_trans_delete_ail()
405                  * will take care of that situation.
406                  * xfs_trans_delete_ail() drops the AIL lock.
407                  */
408                 if (bip->bli_flags & XFS_BLI_STALE_INODE) {
409                         xfs_buf_do_callbacks(bp, (xfs_log_item_t *)bip);
410                         XFS_BUF_SET_FSPRIVATE(bp, NULL);
411                         XFS_BUF_CLR_IODONE_FUNC(bp);
412                 } else {
413                         AIL_LOCK(mp,s);
414                         xfs_trans_delete_ail(mp, (xfs_log_item_t *)bip, s);
415                         xfs_buf_item_relse(bp);
416                         ASSERT(XFS_BUF_FSPRIVATE(bp, void *) == NULL);
417                 }
418                 xfs_buf_relse(bp);
419         }
420 }
421
422 /*
423  * this is called from uncommit in the forced-shutdown path.
424  * we need to check to see if the reference count on the log item
425  * is going to drop to zero.  If so, unpin will free the log item
426  * so we need to free the item's descriptor (that points to the item)
427  * in the transaction.
428  */
429 STATIC void
430 xfs_buf_item_unpin_remove(
431         xfs_buf_log_item_t      *bip,
432         xfs_trans_t             *tp)
433 {
434         xfs_buf_t               *bp;
435         xfs_log_item_desc_t     *lidp;
436         int                     stale = 0;
437
438         bp = bip->bli_buf;
439         /*
440          * will xfs_buf_item_unpin() call xfs_buf_item_relse()?
441          */
442         if ((atomic_read(&bip->bli_refcount) == 1) &&
443             (bip->bli_flags & XFS_BLI_STALE)) {
444                 ASSERT(XFS_BUF_VALUSEMA(bip->bli_buf) <= 0);
445                 xfs_buf_item_trace("UNPIN REMOVE", bip);
446                 xfs_buftrace("XFS_UNPIN_REMOVE", bp);
447                 /*
448                  * yes -- clear the xaction descriptor in-use flag
449                  * and free the chunk if required.  We can safely
450                  * do some work here and then call buf_item_unpin
451                  * to do the rest because if the if is true, then
452                  * we are holding the buffer locked so no one else
453                  * will be able to bump up the refcount.
454                  */
455                 lidp = xfs_trans_find_item(tp, (xfs_log_item_t *) bip);
456                 stale = lidp->lid_flags & XFS_LID_BUF_STALE;
457                 xfs_trans_free_item(tp, lidp);
458                 /*
459                  * Since the transaction no longer refers to the buffer,
460                  * the buffer should no longer refer to the transaction.
461                  */
462                 XFS_BUF_SET_FSPRIVATE2(bp, NULL);
463         }
464
465         xfs_buf_item_unpin(bip, stale);
466
467         return;
468 }
469
470 /*
471  * This is called to attempt to lock the buffer associated with this
472  * buf log item.  Don't sleep on the buffer lock.  If we can't get
473  * the lock right away, return 0.  If we can get the lock, pull the
474  * buffer from the free list, mark it busy, and return 1.
475  */
476 STATIC uint
477 xfs_buf_item_trylock(
478         xfs_buf_log_item_t      *bip)
479 {
480         xfs_buf_t       *bp;
481
482         bp = bip->bli_buf;
483
484         if (XFS_BUF_ISPINNED(bp)) {
485                 return XFS_ITEM_PINNED;
486         }
487
488         if (!XFS_BUF_CPSEMA(bp)) {
489                 return XFS_ITEM_LOCKED;
490         }
491
492         /*
493          * Remove the buffer from the free list.  Only do this
494          * if it's on the free list.  Private buffers like the
495          * superblock buffer are not.
496          */
497         XFS_BUF_HOLD(bp);
498
499         ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
500         xfs_buf_item_trace("TRYLOCK SUCCESS", bip);
501         return XFS_ITEM_SUCCESS;
502 }
503
504 /*
505  * Release the buffer associated with the buf log item.
506  * If there is no dirty logged data associated with the
507  * buffer recorded in the buf log item, then free the
508  * buf log item and remove the reference to it in the
509  * buffer.
510  *
511  * This call ignores the recursion count.  It is only called
512  * when the buffer should REALLY be unlocked, regardless
513  * of the recursion count.
514  *
515  * If the XFS_BLI_HOLD flag is set in the buf log item, then
516  * free the log item if necessary but do not unlock the buffer.
517  * This is for support of xfs_trans_bhold(). Make sure the
518  * XFS_BLI_HOLD field is cleared if we don't free the item.
519  */
520 STATIC void
521 xfs_buf_item_unlock(
522         xfs_buf_log_item_t      *bip)
523 {
524         int             aborted;
525         xfs_buf_t       *bp;
526         uint            hold;
527
528         bp = bip->bli_buf;
529         xfs_buftrace("XFS_UNLOCK", bp);
530
531         /*
532          * Clear the buffer's association with this transaction.
533          */
534         XFS_BUF_SET_FSPRIVATE2(bp, NULL);
535
536         /*
537          * If this is a transaction abort, don't return early.
538          * Instead, allow the brelse to happen.
539          * Normally it would be done for stale (cancelled) buffers
540          * at unpin time, but we'll never go through the pin/unpin
541          * cycle if we abort inside commit.
542          */
543         aborted = (bip->bli_item.li_flags & XFS_LI_ABORTED) != 0;
544
545         /*
546          * If the buf item is marked stale, then don't do anything.
547          * We'll unlock the buffer and free the buf item when the
548          * buffer is unpinned for the last time.
549          */
550         if (bip->bli_flags & XFS_BLI_STALE) {
551                 bip->bli_flags &= ~XFS_BLI_LOGGED;
552                 xfs_buf_item_trace("UNLOCK STALE", bip);
553                 ASSERT(bip->bli_format.blf_flags & XFS_BLI_CANCEL);
554                 if (!aborted)
555                         return;
556         }
557
558         /*
559          * Drop the transaction's reference to the log item if
560          * it was not logged as part of the transaction.  Otherwise
561          * we'll drop the reference in xfs_buf_item_unpin() when
562          * the transaction is really through with the buffer.
563          */
564         if (!(bip->bli_flags & XFS_BLI_LOGGED)) {
565                 atomic_dec(&bip->bli_refcount);
566         } else {
567                 /*
568                  * Clear the logged flag since this is per
569                  * transaction state.
570                  */
571                 bip->bli_flags &= ~XFS_BLI_LOGGED;
572         }
573
574         /*
575          * Before possibly freeing the buf item, determine if we should
576          * release the buffer at the end of this routine.
577          */
578         hold = bip->bli_flags & XFS_BLI_HOLD;
579         xfs_buf_item_trace("UNLOCK", bip);
580
581         /*
582          * If the buf item isn't tracking any data, free it.
583          * Otherwise, if XFS_BLI_HOLD is set clear it.
584          */
585         if (xfs_count_bits(bip->bli_format.blf_data_map,
586                               bip->bli_format.blf_map_size, 0) == 0) {
587                 xfs_buf_item_relse(bp);
588         } else if (hold) {
589                 bip->bli_flags &= ~XFS_BLI_HOLD;
590         }
591
592         /*
593          * Release the buffer if XFS_BLI_HOLD was not set.
594          */
595         if (!hold) {
596                 xfs_buf_relse(bp);
597         }
598 }
599
600 /*
601  * This is called to find out where the oldest active copy of the
602  * buf log item in the on disk log resides now that the last log
603  * write of it completed at the given lsn.
604  * We always re-log all the dirty data in a buffer, so usually the
605  * latest copy in the on disk log is the only one that matters.  For
606  * those cases we simply return the given lsn.
607  *
608  * The one exception to this is for buffers full of newly allocated
609  * inodes.  These buffers are only relogged with the XFS_BLI_INODE_BUF
610  * flag set, indicating that only the di_next_unlinked fields from the
611  * inodes in the buffers will be replayed during recovery.  If the
612  * original newly allocated inode images have not yet been flushed
613  * when the buffer is so relogged, then we need to make sure that we
614  * keep the old images in the 'active' portion of the log.  We do this
615  * by returning the original lsn of that transaction here rather than
616  * the current one.
617  */
618 STATIC xfs_lsn_t
619 xfs_buf_item_committed(
620         xfs_buf_log_item_t      *bip,
621         xfs_lsn_t               lsn)
622 {
623         xfs_buf_item_trace("COMMITTED", bip);
624         if ((bip->bli_flags & XFS_BLI_INODE_ALLOC_BUF) &&
625             (bip->bli_item.li_lsn != 0)) {
626                 return bip->bli_item.li_lsn;
627         }
628         return (lsn);
629 }
630
631 /*
632  * This is called when the transaction holding the buffer is aborted.
633  * Just behave as if the transaction had been cancelled. If we're shutting down
634  * and have aborted this transaction, we'll trap this buffer when it tries to
635  * get written out.
636  */
637 STATIC void
638 xfs_buf_item_abort(
639         xfs_buf_log_item_t      *bip)
640 {
641         xfs_buf_t       *bp;
642
643         bp = bip->bli_buf;
644         xfs_buftrace("XFS_ABORT", bp);
645         XFS_BUF_SUPER_STALE(bp);
646         xfs_buf_item_unlock(bip);
647         return;
648 }
649
650 /*
651  * This is called to asynchronously write the buffer associated with this
652  * buf log item out to disk. The buffer will already have been locked by
653  * a successful call to xfs_buf_item_trylock().  If the buffer still has
654  * B_DELWRI set, then get it going out to disk with a call to bawrite().
655  * If not, then just release the buffer.
656  */
657 STATIC void
658 xfs_buf_item_push(
659         xfs_buf_log_item_t      *bip)
660 {
661         xfs_buf_t       *bp;
662
663         ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
664         xfs_buf_item_trace("PUSH", bip);
665
666         bp = bip->bli_buf;
667
668         if (XFS_BUF_ISDELAYWRITE(bp)) {
669                 xfs_bawrite(bip->bli_item.li_mountp, bp);
670         } else {
671                 xfs_buf_relse(bp);
672         }
673 }
674
675 /* ARGSUSED */
676 STATIC void
677 xfs_buf_item_committing(xfs_buf_log_item_t *bip, xfs_lsn_t commit_lsn)
678 {
679 }
680
681 /*
682  * This is the ops vector shared by all buf log items.
683  */
684 STATIC struct xfs_item_ops xfs_buf_item_ops = {
685         .iop_size       = (uint(*)(xfs_log_item_t*))xfs_buf_item_size,
686         .iop_format     = (void(*)(xfs_log_item_t*, xfs_log_iovec_t*))
687                                         xfs_buf_item_format,
688         .iop_pin        = (void(*)(xfs_log_item_t*))xfs_buf_item_pin,
689         .iop_unpin      = (void(*)(xfs_log_item_t*, int))xfs_buf_item_unpin,
690         .iop_unpin_remove = (void(*)(xfs_log_item_t*, xfs_trans_t *))
691                                         xfs_buf_item_unpin_remove,
692         .iop_trylock    = (uint(*)(xfs_log_item_t*))xfs_buf_item_trylock,
693         .iop_unlock     = (void(*)(xfs_log_item_t*))xfs_buf_item_unlock,
694         .iop_committed  = (xfs_lsn_t(*)(xfs_log_item_t*, xfs_lsn_t))
695                                         xfs_buf_item_committed,
696         .iop_push       = (void(*)(xfs_log_item_t*))xfs_buf_item_push,
697         .iop_abort      = (void(*)(xfs_log_item_t*))xfs_buf_item_abort,
698         .iop_pushbuf    = NULL,
699         .iop_committing = (void(*)(xfs_log_item_t*, xfs_lsn_t))
700                                         xfs_buf_item_committing
701 };
702
703
704 /*
705  * Allocate a new buf log item to go with the given buffer.
706  * Set the buffer's b_fsprivate field to point to the new
707  * buf log item.  If there are other item's attached to the
708  * buffer (see xfs_buf_attach_iodone() below), then put the
709  * buf log item at the front.
710  */
711 void
712 xfs_buf_item_init(
713         xfs_buf_t       *bp,
714         xfs_mount_t     *mp)
715 {
716         xfs_log_item_t          *lip;
717         xfs_buf_log_item_t      *bip;
718         int                     chunks;
719         int                     map_size;
720
721         /*
722          * Check to see if there is already a buf log item for
723          * this buffer.  If there is, it is guaranteed to be
724          * the first.  If we do already have one, there is
725          * nothing to do here so return.
726          */
727         if (XFS_BUF_FSPRIVATE3(bp, xfs_mount_t *) != mp)
728                 XFS_BUF_SET_FSPRIVATE3(bp, mp);
729         XFS_BUF_SET_BDSTRAT_FUNC(bp, xfs_bdstrat_cb);
730         if (XFS_BUF_FSPRIVATE(bp, void *) != NULL) {
731                 lip = XFS_BUF_FSPRIVATE(bp, xfs_log_item_t *);
732                 if (lip->li_type == XFS_LI_BUF) {
733                         return;
734                 }
735         }
736
737         /*
738          * chunks is the number of XFS_BLI_CHUNK size pieces
739          * the buffer can be divided into. Make sure not to
740          * truncate any pieces.  map_size is the size of the
741          * bitmap needed to describe the chunks of the buffer.
742          */
743         chunks = (int)((XFS_BUF_COUNT(bp) + (XFS_BLI_CHUNK - 1)) >> XFS_BLI_SHIFT);
744         map_size = (int)((chunks + NBWORD) >> BIT_TO_WORD_SHIFT);
745
746         bip = (xfs_buf_log_item_t*)kmem_zone_zalloc(xfs_buf_item_zone,
747                                                     KM_SLEEP);
748         bip->bli_item.li_type = XFS_LI_BUF;
749         bip->bli_item.li_ops = &xfs_buf_item_ops;
750         bip->bli_item.li_mountp = mp;
751         bip->bli_buf = bp;
752         bip->bli_format.blf_type = XFS_LI_BUF;
753         bip->bli_format.blf_blkno = (__int64_t)XFS_BUF_ADDR(bp);
754         bip->bli_format.blf_len = (ushort)BTOBB(XFS_BUF_COUNT(bp));
755         bip->bli_format.blf_map_size = map_size;
756 #ifdef XFS_BLI_TRACE
757         bip->bli_trace = ktrace_alloc(XFS_BLI_TRACE_SIZE, KM_SLEEP);
758 #endif
759
760 #ifdef XFS_TRANS_DEBUG
761         /*
762          * Allocate the arrays for tracking what needs to be logged
763          * and what our callers request to be logged.  bli_orig
764          * holds a copy of the original, clean buffer for comparison
765          * against, and bli_logged keeps a 1 bit flag per byte in
766          * the buffer to indicate which bytes the callers have asked
767          * to have logged.
768          */
769         bip->bli_orig = (char *)kmem_alloc(XFS_BUF_COUNT(bp), KM_SLEEP);
770         memcpy(bip->bli_orig, XFS_BUF_PTR(bp), XFS_BUF_COUNT(bp));
771         bip->bli_logged = (char *)kmem_zalloc(XFS_BUF_COUNT(bp) / NBBY, KM_SLEEP);
772 #endif
773
774         /*
775          * Put the buf item into the list of items attached to the
776          * buffer at the front.
777          */
778         if (XFS_BUF_FSPRIVATE(bp, void *) != NULL) {
779                 bip->bli_item.li_bio_list =
780                                 XFS_BUF_FSPRIVATE(bp, xfs_log_item_t *);
781         }
782         XFS_BUF_SET_FSPRIVATE(bp, bip);
783 }
784
785
786 /*
787  * Mark bytes first through last inclusive as dirty in the buf
788  * item's bitmap.
789  */
790 void
791 xfs_buf_item_log(
792         xfs_buf_log_item_t      *bip,
793         uint                    first,
794         uint                    last)
795 {
796         uint            first_bit;
797         uint            last_bit;
798         uint            bits_to_set;
799         uint            bits_set;
800         uint            word_num;
801         uint            *wordp;
802         uint            bit;
803         uint            end_bit;
804         uint            mask;
805
806         /*
807          * Mark the item as having some dirty data for
808          * quick reference in xfs_buf_item_dirty.
809          */
810         bip->bli_flags |= XFS_BLI_DIRTY;
811
812         /*
813          * Convert byte offsets to bit numbers.
814          */
815         first_bit = first >> XFS_BLI_SHIFT;
816         last_bit = last >> XFS_BLI_SHIFT;
817
818         /*
819          * Calculate the total number of bits to be set.
820          */
821         bits_to_set = last_bit - first_bit + 1;
822
823         /*
824          * Get a pointer to the first word in the bitmap
825          * to set a bit in.
826          */
827         word_num = first_bit >> BIT_TO_WORD_SHIFT;
828         wordp = &(bip->bli_format.blf_data_map[word_num]);
829
830         /*
831          * Calculate the starting bit in the first word.
832          */
833         bit = first_bit & (uint)(NBWORD - 1);
834
835         /*
836          * First set any bits in the first word of our range.
837          * If it starts at bit 0 of the word, it will be
838          * set below rather than here.  That is what the variable
839          * bit tells us. The variable bits_set tracks the number
840          * of bits that have been set so far.  End_bit is the number
841          * of the last bit to be set in this word plus one.
842          */
843         if (bit) {
844                 end_bit = MIN(bit + bits_to_set, (uint)NBWORD);
845                 mask = ((1 << (end_bit - bit)) - 1) << bit;
846                 *wordp |= mask;
847                 wordp++;
848                 bits_set = end_bit - bit;
849         } else {
850                 bits_set = 0;
851         }
852
853         /*
854          * Now set bits a whole word at a time that are between
855          * first_bit and last_bit.
856          */
857         while ((bits_to_set - bits_set) >= NBWORD) {
858                 *wordp |= 0xffffffff;
859                 bits_set += NBWORD;
860                 wordp++;
861         }
862
863         /*
864          * Finally, set any bits left to be set in one last partial word.
865          */
866         end_bit = bits_to_set - bits_set;
867         if (end_bit) {
868                 mask = (1 << end_bit) - 1;
869                 *wordp |= mask;
870         }
871
872         xfs_buf_item_log_debug(bip, first, last);
873 }
874
875
876 /*
877  * Return 1 if the buffer has some data that has been logged (at any
878  * point, not just the current transaction) and 0 if not.
879  */
880 uint
881 xfs_buf_item_dirty(
882         xfs_buf_log_item_t      *bip)
883 {
884         return (bip->bli_flags & XFS_BLI_DIRTY);
885 }
886
887 /*
888  * This is called when the buf log item is no longer needed.  It should
889  * free the buf log item associated with the given buffer and clear
890  * the buffer's pointer to the buf log item.  If there are no more
891  * items in the list, clear the b_iodone field of the buffer (see
892  * xfs_buf_attach_iodone() below).
893  */
894 void
895 xfs_buf_item_relse(
896         xfs_buf_t       *bp)
897 {
898         xfs_buf_log_item_t      *bip;
899
900         xfs_buftrace("XFS_RELSE", bp);
901         bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t*);
902         XFS_BUF_SET_FSPRIVATE(bp, bip->bli_item.li_bio_list);
903         if ((XFS_BUF_FSPRIVATE(bp, void *) == NULL) &&
904             (XFS_BUF_IODONE_FUNC(bp) != NULL)) {
905                 ASSERT((XFS_BUF_ISUNINITIAL(bp)) == 0);
906                 XFS_BUF_CLR_IODONE_FUNC(bp);
907         }
908
909 #ifdef XFS_TRANS_DEBUG
910         kmem_free(bip->bli_orig, XFS_BUF_COUNT(bp));
911         bip->bli_orig = NULL;
912         kmem_free(bip->bli_logged, XFS_BUF_COUNT(bp) / NBBY);
913         bip->bli_logged = NULL;
914 #endif /* XFS_TRANS_DEBUG */
915
916 #ifdef XFS_BLI_TRACE
917         ktrace_free(bip->bli_trace);
918 #endif
919         kmem_zone_free(xfs_buf_item_zone, bip);
920 }
921
922
923 /*
924  * Add the given log item with its callback to the list of callbacks
925  * to be called when the buffer's I/O completes.  If it is not set
926  * already, set the buffer's b_iodone() routine to be
927  * xfs_buf_iodone_callbacks() and link the log item into the list of
928  * items rooted at b_fsprivate.  Items are always added as the second
929  * entry in the list if there is a first, because the buf item code
930  * assumes that the buf log item is first.
931  */
932 void
933 xfs_buf_attach_iodone(
934         xfs_buf_t       *bp,
935         void            (*cb)(xfs_buf_t *, xfs_log_item_t *),
936         xfs_log_item_t  *lip)
937 {
938         xfs_log_item_t  *head_lip;
939
940         ASSERT(XFS_BUF_ISBUSY(bp));
941         ASSERT(XFS_BUF_VALUSEMA(bp) <= 0);
942
943         lip->li_cb = cb;
944         if (XFS_BUF_FSPRIVATE(bp, void *) != NULL) {
945                 head_lip = XFS_BUF_FSPRIVATE(bp, xfs_log_item_t *);
946                 lip->li_bio_list = head_lip->li_bio_list;
947                 head_lip->li_bio_list = lip;
948         } else {
949                 XFS_BUF_SET_FSPRIVATE(bp, lip);
950         }
951
952         ASSERT((XFS_BUF_IODONE_FUNC(bp) == xfs_buf_iodone_callbacks) ||
953                (XFS_BUF_IODONE_FUNC(bp) == NULL));
954         XFS_BUF_SET_IODONE_FUNC(bp, xfs_buf_iodone_callbacks);
955 }
956
957 STATIC void
958 xfs_buf_do_callbacks(
959         xfs_buf_t       *bp,
960         xfs_log_item_t  *lip)
961 {
962         xfs_log_item_t  *nlip;
963
964         while (lip != NULL) {
965                 nlip = lip->li_bio_list;
966                 ASSERT(lip->li_cb != NULL);
967                 /*
968                  * Clear the next pointer so we don't have any
969                  * confusion if the item is added to another buf.
970                  * Don't touch the log item after calling its
971                  * callback, because it could have freed itself.
972                  */
973                 lip->li_bio_list = NULL;
974                 lip->li_cb(bp, lip);
975                 lip = nlip;
976         }
977 }
978
979 /*
980  * This is the iodone() function for buffers which have had callbacks
981  * attached to them by xfs_buf_attach_iodone().  It should remove each
982  * log item from the buffer's list and call the callback of each in turn.
983  * When done, the buffer's fsprivate field is set to NULL and the buffer
984  * is unlocked with a call to iodone().
985  */
986 void
987 xfs_buf_iodone_callbacks(
988         xfs_buf_t       *bp)
989 {
990         xfs_log_item_t  *lip;
991         static ulong    lasttime;
992         static xfs_buftarg_t *lasttarg;
993         xfs_mount_t     *mp;
994
995         ASSERT(XFS_BUF_FSPRIVATE(bp, void *) != NULL);
996         lip = XFS_BUF_FSPRIVATE(bp, xfs_log_item_t *);
997
998         if (XFS_BUF_GETERROR(bp) != 0) {
999                 /*
1000                  * If we've already decided to shutdown the filesystem
1001                  * because of IO errors, there's no point in giving this
1002                  * a retry.
1003                  */
1004                 mp = lip->li_mountp;
1005                 if (XFS_FORCED_SHUTDOWN(mp)) {
1006                         ASSERT(XFS_BUF_TARGET(bp) == mp->m_ddev_targp);
1007                         XFS_BUF_SUPER_STALE(bp);
1008                         xfs_buftrace("BUF_IODONE_CB", bp);
1009                         xfs_buf_do_callbacks(bp, lip);
1010                         XFS_BUF_SET_FSPRIVATE(bp, NULL);
1011                         XFS_BUF_CLR_IODONE_FUNC(bp);
1012
1013                         /*
1014                          * XFS_SHUT flag gets set when we go thru the
1015                          * entire buffer cache and deliberately start
1016                          * throwing away delayed write buffers.
1017                          * Since there's no biowait done on those,
1018                          * we should just brelse them.
1019                          */
1020                         if (XFS_BUF_ISSHUT(bp)) {
1021                             XFS_BUF_UNSHUT(bp);
1022                                 xfs_buf_relse(bp);
1023                         } else {
1024                                 xfs_biodone(bp);
1025                         }
1026
1027                         return;
1028                 }
1029
1030                 if ((XFS_BUF_TARGET(bp) != lasttarg) ||
1031                     (time_after(jiffies, (lasttime + 5*HZ)))) {
1032                         lasttime = jiffies;
1033                         prdev("XFS write error in file system meta-data "
1034                               "block 0x%llx in %s",
1035                               XFS_BUF_TARGET(bp),
1036                               (__uint64_t)XFS_BUF_ADDR(bp), mp->m_fsname);
1037                 }
1038                 lasttarg = XFS_BUF_TARGET(bp);
1039
1040                 if (XFS_BUF_ISASYNC(bp)) {
1041                         /*
1042                          * If the write was asynchronous then noone will be
1043                          * looking for the error.  Clear the error state
1044                          * and write the buffer out again delayed write.
1045                          *
1046                          * XXXsup This is OK, so long as we catch these
1047                          * before we start the umount; we don't want these
1048                          * DELWRI metadata bufs to be hanging around.
1049                          */
1050                         XFS_BUF_ERROR(bp,0); /* errno of 0 unsets the flag */
1051
1052                         if (!(XFS_BUF_ISSTALE(bp))) {
1053                                 XFS_BUF_DELAYWRITE(bp);
1054                                 XFS_BUF_DONE(bp);
1055                                 XFS_BUF_SET_START(bp);
1056                         }
1057                         ASSERT(XFS_BUF_IODONE_FUNC(bp));
1058                         xfs_buftrace("BUF_IODONE ASYNC", bp);
1059                         xfs_buf_relse(bp);
1060                 } else {
1061                         /*
1062                          * If the write of the buffer was not asynchronous,
1063                          * then we want to make sure to return the error
1064                          * to the caller of bwrite().  Because of this we
1065                          * cannot clear the B_ERROR state at this point.
1066                          * Instead we install a callback function that
1067                          * will be called when the buffer is released, and
1068                          * that routine will clear the error state and
1069                          * set the buffer to be written out again after
1070                          * some delay.
1071                          */
1072                         /* We actually overwrite the existing b-relse
1073                            function at times, but we're gonna be shutting down
1074                            anyway. */
1075                         XFS_BUF_SET_BRELSE_FUNC(bp,xfs_buf_error_relse);
1076                         XFS_BUF_DONE(bp);
1077                         XFS_BUF_V_IODONESEMA(bp);
1078                 }
1079                 return;
1080         }
1081 #ifdef XFSERRORDEBUG
1082         xfs_buftrace("XFS BUFCB NOERR", bp);
1083 #endif
1084         xfs_buf_do_callbacks(bp, lip);
1085         XFS_BUF_SET_FSPRIVATE(bp, NULL);
1086         XFS_BUF_CLR_IODONE_FUNC(bp);
1087         xfs_biodone(bp);
1088 }
1089
1090 /*
1091  * This is a callback routine attached to a buffer which gets an error
1092  * when being written out synchronously.
1093  */
1094 STATIC void
1095 xfs_buf_error_relse(
1096         xfs_buf_t       *bp)
1097 {
1098         xfs_log_item_t  *lip;
1099         xfs_mount_t     *mp;
1100
1101         lip = XFS_BUF_FSPRIVATE(bp, xfs_log_item_t *);
1102         mp = (xfs_mount_t *)lip->li_mountp;
1103         ASSERT(XFS_BUF_TARGET(bp) == mp->m_ddev_targp);
1104
1105         XFS_BUF_STALE(bp);
1106         XFS_BUF_DONE(bp);
1107         XFS_BUF_UNDELAYWRITE(bp);
1108         XFS_BUF_ERROR(bp,0);
1109         xfs_buftrace("BUF_ERROR_RELSE", bp);
1110         if (! XFS_FORCED_SHUTDOWN(mp))
1111                 xfs_force_shutdown(mp, XFS_METADATA_IO_ERROR);
1112         /*
1113          * We have to unpin the pinned buffers so do the
1114          * callbacks.
1115          */
1116         xfs_buf_do_callbacks(bp, lip);
1117         XFS_BUF_SET_FSPRIVATE(bp, NULL);
1118         XFS_BUF_CLR_IODONE_FUNC(bp);
1119         XFS_BUF_SET_BRELSE_FUNC(bp,NULL);
1120         xfs_buf_relse(bp);
1121 }
1122
1123
1124 /*
1125  * This is the iodone() function for buffers which have been
1126  * logged.  It is called when they are eventually flushed out.
1127  * It should remove the buf item from the AIL, and free the buf item.
1128  * It is called by xfs_buf_iodone_callbacks() above which will take
1129  * care of cleaning up the buffer itself.
1130  */
1131 /* ARGSUSED */
1132 void
1133 xfs_buf_iodone(
1134         xfs_buf_t               *bp,
1135         xfs_buf_log_item_t      *bip)
1136 {
1137         struct xfs_mount        *mp;
1138         SPLDECL(s);
1139
1140         ASSERT(bip->bli_buf == bp);
1141
1142         mp = bip->bli_item.li_mountp;
1143
1144         /*
1145          * If we are forcibly shutting down, this may well be
1146          * off the AIL already. That's because we simulate the
1147          * log-committed callbacks to unpin these buffers. Or we may never
1148          * have put this item on AIL because of the transaction was
1149          * aborted forcibly. xfs_trans_delete_ail() takes care of these.
1150          *
1151          * Either way, AIL is useless if we're forcing a shutdown.
1152          */
1153         AIL_LOCK(mp,s);
1154         /*
1155          * xfs_trans_delete_ail() drops the AIL lock.
1156          */
1157         xfs_trans_delete_ail(mp, (xfs_log_item_t *)bip, s);
1158
1159 #ifdef XFS_TRANS_DEBUG
1160         kmem_free(bip->bli_orig, XFS_BUF_COUNT(bp));
1161         bip->bli_orig = NULL;
1162         kmem_free(bip->bli_logged, XFS_BUF_COUNT(bp) / NBBY);
1163         bip->bli_logged = NULL;
1164 #endif /* XFS_TRANS_DEBUG */
1165
1166 #ifdef XFS_BLI_TRACE
1167         ktrace_free(bip->bli_trace);
1168 #endif
1169         kmem_zone_free(xfs_buf_item_zone, bip);
1170 }
1171
1172 #if defined(XFS_BLI_TRACE)
1173 void
1174 xfs_buf_item_trace(
1175         char                    *id,
1176         xfs_buf_log_item_t      *bip)
1177 {
1178         xfs_buf_t               *bp;
1179         ASSERT(bip->bli_trace != NULL);
1180
1181         bp = bip->bli_buf;
1182         ktrace_enter(bip->bli_trace,
1183                      (void *)id,
1184                      (void *)bip->bli_buf,
1185                      (void *)((unsigned long)bip->bli_flags),
1186                      (void *)((unsigned long)bip->bli_recur),
1187                      (void *)((unsigned long)atomic_read(&bip->bli_refcount)),
1188                      (void *)((unsigned long)
1189                                 (0xFFFFFFFF & XFS_BUF_ADDR(bp) >> 32)),
1190                      (void *)((unsigned long)(0xFFFFFFFF & XFS_BUF_ADDR(bp))),
1191                      (void *)((unsigned long)XFS_BUF_COUNT(bp)),
1192                      (void *)((unsigned long)XFS_BUF_BFLAGS(bp)),
1193                      XFS_BUF_FSPRIVATE(bp, void *),
1194                      XFS_BUF_FSPRIVATE2(bp, void *),
1195                      (void *)(unsigned long)XFS_BUF_ISPINNED(bp),
1196                      (void *)XFS_BUF_IODONE_FUNC(bp),
1197                      (void *)((unsigned long)(XFS_BUF_VALUSEMA(bp))),
1198                      (void *)bip->bli_item.li_desc,
1199                      (void *)((unsigned long)bip->bli_item.li_flags));
1200 }
1201 #endif /* XFS_BLI_TRACE */