source: src/linux/universal/linux-3.18/fs/xfs/xfs_buf.c @ 31885

Last change on this file since 31885 was 31885, checked in by brainslayer, 5 weeks ago

update

File size: 43.7 KB
Line 
1/*
2 * Copyright (c) 2000-2006 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 <linux/stddef.h>
20#include <linux/errno.h>
21#include <linux/gfp.h>
22#include <linux/pagemap.h>
23#include <linux/init.h>
24#include <linux/vmalloc.h>
25#include <linux/bio.h>
26#include <linux/sysctl.h>
27#include <linux/proc_fs.h>
28#include <linux/workqueue.h>
29#include <linux/percpu.h>
30#include <linux/blkdev.h>
31#include <linux/hash.h>
32#include <linux/kthread.h>
33#include <linux/migrate.h>
34#include <linux/backing-dev.h>
35#include <linux/freezer.h>
36
37#include "xfs_log_format.h"
38#include "xfs_trans_resv.h"
39#include "xfs_sb.h"
40#include "xfs_ag.h"
41#include "xfs_mount.h"
42#include "xfs_trace.h"
43#include "xfs_log.h"
44
45static kmem_zone_t *xfs_buf_zone;
46
47static struct workqueue_struct *xfslogd_workqueue;
48
49#ifdef XFS_BUF_LOCK_TRACKING
50# define XB_SET_OWNER(bp)       ((bp)->b_last_holder = current->pid)
51# define XB_CLEAR_OWNER(bp)     ((bp)->b_last_holder = -1)
52# define XB_GET_OWNER(bp)       ((bp)->b_last_holder)
53#else
54# define XB_SET_OWNER(bp)       do { } while (0)
55# define XB_CLEAR_OWNER(bp)     do { } while (0)
56# define XB_GET_OWNER(bp)       do { } while (0)
57#endif
58
59#define xb_to_gfp(flags) \
60        ((((flags) & XBF_READ_AHEAD) ? __GFP_NORETRY : GFP_NOFS) | __GFP_NOWARN)
61
62
63static inline int
64xfs_buf_is_vmapped(
65        struct xfs_buf  *bp)
66{
67        /*
68         * Return true if the buffer is vmapped.
69         *
70         * b_addr is null if the buffer is not mapped, but the code is clever
71         * enough to know it doesn't have to map a single page, so the check has
72         * to be both for b_addr and bp->b_page_count > 1.
73         */
74        return bp->b_addr && bp->b_page_count > 1;
75}
76
77static inline int
78xfs_buf_vmap_len(
79        struct xfs_buf  *bp)
80{
81        return (bp->b_page_count * PAGE_SIZE) - bp->b_offset;
82}
83
84/*
85 * When we mark a buffer stale, we remove the buffer from the LRU and clear the
86 * b_lru_ref count so that the buffer is freed immediately when the buffer
87 * reference count falls to zero. If the buffer is already on the LRU, we need
88 * to remove the reference that LRU holds on the buffer.
89 *
90 * This prevents build-up of stale buffers on the LRU.
91 */
92void
93xfs_buf_stale(
94        struct xfs_buf  *bp)
95{
96        ASSERT(xfs_buf_islocked(bp));
97
98        bp->b_flags |= XBF_STALE;
99
100        /*
101         * Clear the delwri status so that a delwri queue walker will not
102         * flush this buffer to disk now that it is stale. The delwri queue has
103         * a reference to the buffer, so this is safe to do.
104         */
105        bp->b_flags &= ~_XBF_DELWRI_Q;
106
107        spin_lock(&bp->b_lock);
108        atomic_set(&bp->b_lru_ref, 0);
109        if (!(bp->b_state & XFS_BSTATE_DISPOSE) &&
110            (list_lru_del(&bp->b_target->bt_lru, &bp->b_lru)))
111                atomic_dec(&bp->b_hold);
112
113        ASSERT(atomic_read(&bp->b_hold) >= 1);
114        spin_unlock(&bp->b_lock);
115}
116
117static int
118xfs_buf_get_maps(
119        struct xfs_buf          *bp,
120        int                     map_count)
121{
122        ASSERT(bp->b_maps == NULL);
123        bp->b_map_count = map_count;
124
125        if (map_count == 1) {
126                bp->b_maps = &bp->__b_map;
127                return 0;
128        }
129
130        bp->b_maps = kmem_zalloc(map_count * sizeof(struct xfs_buf_map),
131                                KM_NOFS);
132        if (!bp->b_maps)
133                return -ENOMEM;
134        return 0;
135}
136
137/*
138 *      Frees b_pages if it was allocated.
139 */
140static void
141xfs_buf_free_maps(
142        struct xfs_buf  *bp)
143{
144        if (bp->b_maps != &bp->__b_map) {
145                kmem_free(bp->b_maps);
146                bp->b_maps = NULL;
147        }
148}
149
150struct xfs_buf *
151_xfs_buf_alloc(
152        struct xfs_buftarg      *target,
153        struct xfs_buf_map      *map,
154        int                     nmaps,
155        xfs_buf_flags_t         flags)
156{
157        struct xfs_buf          *bp;
158        int                     error;
159        int                     i;
160
161        bp = kmem_zone_zalloc(xfs_buf_zone, KM_NOFS);
162        if (unlikely(!bp))
163                return NULL;
164
165        /*
166         * We don't want certain flags to appear in b_flags unless they are
167         * specifically set by later operations on the buffer.
168         */
169        flags &= ~(XBF_UNMAPPED | XBF_TRYLOCK | XBF_ASYNC | XBF_READ_AHEAD);
170
171        atomic_set(&bp->b_hold, 1);
172        atomic_set(&bp->b_lru_ref, 1);
173        init_completion(&bp->b_iowait);
174        INIT_LIST_HEAD(&bp->b_lru);
175        INIT_LIST_HEAD(&bp->b_list);
176        RB_CLEAR_NODE(&bp->b_rbnode);
177        sema_init(&bp->b_sema, 0); /* held, no waiters */
178        spin_lock_init(&bp->b_lock);
179        XB_SET_OWNER(bp);
180        bp->b_target = target;
181        bp->b_flags = flags;
182
183        /*
184         * Set length and io_length to the same value initially.
185         * I/O routines should use io_length, which will be the same in
186         * most cases but may be reset (e.g. XFS recovery).
187         */
188        error = xfs_buf_get_maps(bp, nmaps);
189        if (error)  {
190                kmem_zone_free(xfs_buf_zone, bp);
191                return NULL;
192        }
193
194        bp->b_bn = map[0].bm_bn;
195        bp->b_length = 0;
196        for (i = 0; i < nmaps; i++) {
197                bp->b_maps[i].bm_bn = map[i].bm_bn;
198                bp->b_maps[i].bm_len = map[i].bm_len;
199                bp->b_length += map[i].bm_len;
200        }
201        bp->b_io_length = bp->b_length;
202
203        atomic_set(&bp->b_pin_count, 0);
204        init_waitqueue_head(&bp->b_waiters);
205
206        XFS_STATS_INC(xb_create);
207        trace_xfs_buf_init(bp, _RET_IP_);
208
209        return bp;
210}
211
212/*
213 *      Allocate a page array capable of holding a specified number
214 *      of pages, and point the page buf at it.
215 */
216STATIC int
217_xfs_buf_get_pages(
218        xfs_buf_t               *bp,
219        int                     page_count)
220{
221        /* Make sure that we have a page list */
222        if (bp->b_pages == NULL) {
223                bp->b_page_count = page_count;
224                if (page_count <= XB_PAGES) {
225                        bp->b_pages = bp->b_page_array;
226                } else {
227                        bp->b_pages = kmem_alloc(sizeof(struct page *) *
228                                                 page_count, KM_NOFS);
229                        if (bp->b_pages == NULL)
230                                return -ENOMEM;
231                }
232                memset(bp->b_pages, 0, sizeof(struct page *) * page_count);
233        }
234        return 0;
235}
236
237/*
238 *      Frees b_pages if it was allocated.
239 */
240STATIC void
241_xfs_buf_free_pages(
242        xfs_buf_t       *bp)
243{
244        if (bp->b_pages != bp->b_page_array) {
245                kmem_free(bp->b_pages);
246                bp->b_pages = NULL;
247        }
248}
249
250/*
251 *      Releases the specified buffer.
252 *
253 *      The modification state of any associated pages is left unchanged.
254 *      The buffer must not be on any hash - use xfs_buf_rele instead for
255 *      hashed and refcounted buffers
256 */
257void
258xfs_buf_free(
259        xfs_buf_t               *bp)
260{
261        trace_xfs_buf_free(bp, _RET_IP_);
262
263        ASSERT(list_empty(&bp->b_lru));
264
265        if (bp->b_flags & _XBF_PAGES) {
266                uint            i;
267
268                if (xfs_buf_is_vmapped(bp))
269                        vm_unmap_ram(bp->b_addr - bp->b_offset,
270                                        bp->b_page_count);
271
272                for (i = 0; i < bp->b_page_count; i++) {
273                        struct page     *page = bp->b_pages[i];
274
275                        __free_page(page);
276                }
277        } else if (bp->b_flags & _XBF_KMEM)
278                kmem_free(bp->b_addr);
279        _xfs_buf_free_pages(bp);
280        xfs_buf_free_maps(bp);
281        kmem_zone_free(xfs_buf_zone, bp);
282}
283
284/*
285 * Allocates all the pages for buffer in question and builds it's page list.
286 */
287STATIC int
288xfs_buf_allocate_memory(
289        xfs_buf_t               *bp,
290        uint                    flags)
291{
292        size_t                  size;
293        size_t                  nbytes, offset;
294        gfp_t                   gfp_mask = xb_to_gfp(flags);
295        unsigned short          page_count, i;
296        xfs_off_t               start, end;
297        int                     error;
298
299        /*
300         * for buffers that are contained within a single page, just allocate
301         * the memory from the heap - there's no need for the complexity of
302         * page arrays to keep allocation down to order 0.
303         */
304        size = BBTOB(bp->b_length);
305        if (size < PAGE_SIZE) {
306                bp->b_addr = kmem_alloc(size, KM_NOFS);
307                if (!bp->b_addr) {
308                        /* low memory - use alloc_page loop instead */
309                        goto use_alloc_page;
310                }
311
312                if (((unsigned long)(bp->b_addr + size - 1) & PAGE_MASK) !=
313                    ((unsigned long)bp->b_addr & PAGE_MASK)) {
314                        /* b_addr spans two pages - use alloc_page instead */
315                        kmem_free(bp->b_addr);
316                        bp->b_addr = NULL;
317                        goto use_alloc_page;
318                }
319                bp->b_offset = offset_in_page(bp->b_addr);
320                bp->b_pages = bp->b_page_array;
321                bp->b_pages[0] = virt_to_page(bp->b_addr);
322                bp->b_page_count = 1;
323                bp->b_flags |= _XBF_KMEM;
324                return 0;
325        }
326
327use_alloc_page:
328        start = BBTOB(bp->b_maps[0].bm_bn) >> PAGE_SHIFT;
329        end = (BBTOB(bp->b_maps[0].bm_bn + bp->b_length) + PAGE_SIZE - 1)
330                                                                >> PAGE_SHIFT;
331        page_count = end - start;
332        error = _xfs_buf_get_pages(bp, page_count);
333        if (unlikely(error))
334                return error;
335
336        offset = bp->b_offset;
337        bp->b_flags |= _XBF_PAGES;
338
339        for (i = 0; i < bp->b_page_count; i++) {
340                struct page     *page;
341                uint            retries = 0;
342retry:
343                page = alloc_page(gfp_mask);
344                if (unlikely(page == NULL)) {
345                        if (flags & XBF_READ_AHEAD) {
346                                bp->b_page_count = i;
347                                error = -ENOMEM;
348                                goto out_free_pages;
349                        }
350
351                        /*
352                         * This could deadlock.
353                         *
354                         * But until all the XFS lowlevel code is revamped to
355                         * handle buffer allocation failures we can't do much.
356                         */
357                        if (!(++retries % 100))
358                                xfs_err(NULL,
359                "possible memory allocation deadlock in %s (mode:0x%x)",
360                                        __func__, gfp_mask);
361
362                        XFS_STATS_INC(xb_page_retries);
363                        congestion_wait(BLK_RW_ASYNC, HZ/50);
364                        goto retry;
365                }
366
367                XFS_STATS_INC(xb_page_found);
368
369                nbytes = min_t(size_t, size, PAGE_SIZE - offset);
370                size -= nbytes;
371                bp->b_pages[i] = page;
372                offset = 0;
373        }
374        return 0;
375
376out_free_pages:
377        for (i = 0; i < bp->b_page_count; i++)
378                __free_page(bp->b_pages[i]);
379        bp->b_flags &= ~_XBF_PAGES;
380        return error;
381}
382
383/*
384 *      Map buffer into kernel address-space if necessary.
385 */
386STATIC int
387_xfs_buf_map_pages(
388        xfs_buf_t               *bp,
389        uint                    flags)
390{
391        ASSERT(bp->b_flags & _XBF_PAGES);
392        if (bp->b_page_count == 1) {
393                /* A single page buffer is always mappable */
394                bp->b_addr = page_address(bp->b_pages[0]) + bp->b_offset;
395        } else if (flags & XBF_UNMAPPED) {
396                bp->b_addr = NULL;
397        } else {
398                int retried = 0;
399                unsigned noio_flag;
400
401                /*
402                 * vm_map_ram() will allocate auxillary structures (e.g.
403                 * pagetables) with GFP_KERNEL, yet we are likely to be under
404                 * GFP_NOFS context here. Hence we need to tell memory reclaim
405                 * that we are in such a context via PF_MEMALLOC_NOIO to prevent
406                 * memory reclaim re-entering the filesystem here and
407                 * potentially deadlocking.
408                 */
409                noio_flag = memalloc_noio_save();
410                do {
411                        bp->b_addr = vm_map_ram(bp->b_pages, bp->b_page_count,
412                                                -1, PAGE_KERNEL);
413                        if (bp->b_addr)
414                                break;
415                        vm_unmap_aliases();
416                } while (retried++ <= 1);
417                memalloc_noio_restore(noio_flag);
418
419                if (!bp->b_addr)
420                        return -ENOMEM;
421                bp->b_addr += bp->b_offset;
422        }
423
424        return 0;
425}
426
427/*
428 *      Finding and Reading Buffers
429 */
430
431/*
432 *      Look up, and creates if absent, a lockable buffer for
433 *      a given range of an inode.  The buffer is returned
434 *      locked. No I/O is implied by this call.
435 */
436xfs_buf_t *
437_xfs_buf_find(
438        struct xfs_buftarg      *btp,
439        struct xfs_buf_map      *map,
440        int                     nmaps,
441        xfs_buf_flags_t         flags,
442        xfs_buf_t               *new_bp)
443{
444        size_t                  numbytes;
445        struct xfs_perag        *pag;
446        struct rb_node          **rbp;
447        struct rb_node          *parent;
448        xfs_buf_t               *bp;
449        xfs_daddr_t             blkno = map[0].bm_bn;
450        xfs_daddr_t             eofs;
451        int                     numblks = 0;
452        int                     i;
453
454        for (i = 0; i < nmaps; i++)
455                numblks += map[i].bm_len;
456        numbytes = BBTOB(numblks);
457
458        /* Check for IOs smaller than the sector size / not sector aligned */
459        ASSERT(!(numbytes < btp->bt_meta_sectorsize));
460        ASSERT(!(BBTOB(blkno) & (xfs_off_t)btp->bt_meta_sectormask));
461
462        /*
463         * Corrupted block numbers can get through to here, unfortunately, so we
464         * have to check that the buffer falls within the filesystem bounds.
465         */
466        eofs = XFS_FSB_TO_BB(btp->bt_mount, btp->bt_mount->m_sb.sb_dblocks);
467        if (blkno >= eofs) {
468                /*
469                 * XXX (dgc): we should really be returning -EFSCORRUPTED here,
470                 * but none of the higher level infrastructure supports
471                 * returning a specific error on buffer lookup failures.
472                 */
473                xfs_alert(btp->bt_mount,
474                          "%s: Block out of range: block 0x%llx, EOFS 0x%llx ",
475                          __func__, blkno, eofs);
476                WARN_ON(1);
477                return NULL;
478        }
479
480        /* get tree root */
481        pag = xfs_perag_get(btp->bt_mount,
482                                xfs_daddr_to_agno(btp->bt_mount, blkno));
483
484        /* walk tree */
485        spin_lock(&pag->pag_buf_lock);
486        rbp = &pag->pag_buf_tree.rb_node;
487        parent = NULL;
488        bp = NULL;
489        while (*rbp) {
490                parent = *rbp;
491                bp = rb_entry(parent, struct xfs_buf, b_rbnode);
492
493                if (blkno < bp->b_bn)
494                        rbp = &(*rbp)->rb_left;
495                else if (blkno > bp->b_bn)
496                        rbp = &(*rbp)->rb_right;
497                else {
498                        /*
499                         * found a block number match. If the range doesn't
500                         * match, the only way this is allowed is if the buffer
501                         * in the cache is stale and the transaction that made
502                         * it stale has not yet committed. i.e. we are
503                         * reallocating a busy extent. Skip this buffer and
504                         * continue searching to the right for an exact match.
505                         */
506                        if (bp->b_length != numblks) {
507                                ASSERT(bp->b_flags & XBF_STALE);
508                                rbp = &(*rbp)->rb_right;
509                                continue;
510                        }
511                        atomic_inc(&bp->b_hold);
512                        goto found;
513                }
514        }
515
516        /* No match found */
517        if (new_bp) {
518                rb_link_node(&new_bp->b_rbnode, parent, rbp);
519                rb_insert_color(&new_bp->b_rbnode, &pag->pag_buf_tree);
520                /* the buffer keeps the perag reference until it is freed */
521                new_bp->b_pag = pag;
522                spin_unlock(&pag->pag_buf_lock);
523        } else {
524                XFS_STATS_INC(xb_miss_locked);
525                spin_unlock(&pag->pag_buf_lock);
526                xfs_perag_put(pag);
527        }
528        return new_bp;
529
530found:
531        spin_unlock(&pag->pag_buf_lock);
532        xfs_perag_put(pag);
533
534        if (!xfs_buf_trylock(bp)) {
535                if (flags & XBF_TRYLOCK) {
536                        xfs_buf_rele(bp);
537                        XFS_STATS_INC(xb_busy_locked);
538                        return NULL;
539                }
540                xfs_buf_lock(bp);
541                XFS_STATS_INC(xb_get_locked_waited);
542        }
543
544        /*
545         * if the buffer is stale, clear all the external state associated with
546         * it. We need to keep flags such as how we allocated the buffer memory
547         * intact here.
548         */
549        if (bp->b_flags & XBF_STALE) {
550                ASSERT((bp->b_flags & _XBF_DELWRI_Q) == 0);
551                ASSERT(bp->b_iodone == NULL);
552                bp->b_flags &= _XBF_KMEM | _XBF_PAGES;
553                bp->b_ops = NULL;
554        }
555
556        trace_xfs_buf_find(bp, flags, _RET_IP_);
557        XFS_STATS_INC(xb_get_locked);
558        return bp;
559}
560
561/*
562 * Assembles a buffer covering the specified range. The code is optimised for
563 * cache hits, as metadata intensive workloads will see 3 orders of magnitude
564 * more hits than misses.
565 */
566struct xfs_buf *
567xfs_buf_get_map(
568        struct xfs_buftarg      *target,
569        struct xfs_buf_map      *map,
570        int                     nmaps,
571        xfs_buf_flags_t         flags)
572{
573        struct xfs_buf          *bp;
574        struct xfs_buf          *new_bp;
575        int                     error = 0;
576
577        bp = _xfs_buf_find(target, map, nmaps, flags, NULL);
578        if (likely(bp))
579                goto found;
580
581        new_bp = _xfs_buf_alloc(target, map, nmaps, flags);
582        if (unlikely(!new_bp))
583                return NULL;
584
585        error = xfs_buf_allocate_memory(new_bp, flags);
586        if (error) {
587                xfs_buf_free(new_bp);
588                return NULL;
589        }
590
591        bp = _xfs_buf_find(target, map, nmaps, flags, new_bp);
592        if (!bp) {
593                xfs_buf_free(new_bp);
594                return NULL;
595        }
596
597        if (bp != new_bp)
598                xfs_buf_free(new_bp);
599
600found:
601        if (!bp->b_addr) {
602                error = _xfs_buf_map_pages(bp, flags);
603                if (unlikely(error)) {
604                        xfs_warn(target->bt_mount,
605                                "%s: failed to map pagesn", __func__);
606                        xfs_buf_relse(bp);
607                        return NULL;
608                }
609        }
610
611        /*
612         * Clear b_error if this is a lookup from a caller that doesn't expect
613         * valid data to be found in the buffer.
614         */
615        if (!(flags & XBF_READ))
616                xfs_buf_ioerror(bp, 0);
617
618        XFS_STATS_INC(xb_get);
619        trace_xfs_buf_get(bp, flags, _RET_IP_);
620        return bp;
621}
622
623STATIC int
624_xfs_buf_read(
625        xfs_buf_t               *bp,
626        xfs_buf_flags_t         flags)
627{
628        ASSERT(!(flags & XBF_WRITE));
629        ASSERT(bp->b_maps[0].bm_bn != XFS_BUF_DADDR_NULL);
630
631        bp->b_flags &= ~(XBF_WRITE | XBF_ASYNC | XBF_READ_AHEAD);
632        bp->b_flags |= flags & (XBF_READ | XBF_ASYNC | XBF_READ_AHEAD);
633
634        if (flags & XBF_ASYNC) {
635                xfs_buf_submit(bp);
636                return 0;
637        }
638        return xfs_buf_submit_wait(bp);
639}
640
641xfs_buf_t *
642xfs_buf_read_map(
643        struct xfs_buftarg      *target,
644        struct xfs_buf_map      *map,
645        int                     nmaps,
646        xfs_buf_flags_t         flags,
647        const struct xfs_buf_ops *ops)
648{
649        struct xfs_buf          *bp;
650
651        flags |= XBF_READ;
652
653        bp = xfs_buf_get_map(target, map, nmaps, flags);
654        if (bp) {
655                trace_xfs_buf_read(bp, flags, _RET_IP_);
656
657                if (!XFS_BUF_ISDONE(bp)) {
658                        XFS_STATS_INC(xb_get_read);
659                        bp->b_ops = ops;
660                        _xfs_buf_read(bp, flags);
661                } else if (flags & XBF_ASYNC) {
662                        /*
663                         * Read ahead call which is already satisfied,
664                         * drop the buffer
665                         */
666                        xfs_buf_relse(bp);
667                        return NULL;
668                } else {
669                        /* We do not want read in the flags */
670                        bp->b_flags &= ~XBF_READ;
671                }
672        }
673
674        return bp;
675}
676
677/*
678 *      If we are not low on memory then do the readahead in a deadlock
679 *      safe manner.
680 */
681void
682xfs_buf_readahead_map(
683        struct xfs_buftarg      *target,
684        struct xfs_buf_map      *map,
685        int                     nmaps,
686        const struct xfs_buf_ops *ops)
687{
688        if (bdi_read_congested(target->bt_bdi))
689                return;
690
691        xfs_buf_read_map(target, map, nmaps,
692                     XBF_TRYLOCK|XBF_ASYNC|XBF_READ_AHEAD, ops);
693}
694
695/*
696 * Read an uncached buffer from disk. Allocates and returns a locked
697 * buffer containing the disk contents or nothing.
698 */
699int
700xfs_buf_read_uncached(
701        struct xfs_buftarg      *target,
702        xfs_daddr_t             daddr,
703        size_t                  numblks,
704        int                     flags,
705        struct xfs_buf          **bpp,
706        const struct xfs_buf_ops *ops)
707{
708        struct xfs_buf          *bp;
709
710        *bpp = NULL;
711
712        bp = xfs_buf_get_uncached(target, numblks, flags);
713        if (!bp)
714                return -ENOMEM;
715
716        /* set up the buffer for a read IO */
717        ASSERT(bp->b_map_count == 1);
718        bp->b_bn = XFS_BUF_DADDR_NULL;  /* always null for uncached buffers */
719        bp->b_maps[0].bm_bn = daddr;
720        bp->b_flags |= XBF_READ;
721        bp->b_ops = ops;
722
723        xfs_buf_submit_wait(bp);
724        if (bp->b_error) {
725                int     error = bp->b_error;
726                xfs_buf_relse(bp);
727                return error;
728        }
729
730        *bpp = bp;
731        return 0;
732}
733
734/*
735 * Return a buffer allocated as an empty buffer and associated to external
736 * memory via xfs_buf_associate_memory() back to it's empty state.
737 */
738void
739xfs_buf_set_empty(
740        struct xfs_buf          *bp,
741        size_t                  numblks)
742{
743        if (bp->b_pages)
744                _xfs_buf_free_pages(bp);
745
746        bp->b_pages = NULL;
747        bp->b_page_count = 0;
748        bp->b_addr = NULL;
749        bp->b_length = numblks;
750        bp->b_io_length = numblks;
751
752        ASSERT(bp->b_map_count == 1);
753        bp->b_bn = XFS_BUF_DADDR_NULL;
754        bp->b_maps[0].bm_bn = XFS_BUF_DADDR_NULL;
755        bp->b_maps[0].bm_len = bp->b_length;
756}
757
758static inline struct page *
759mem_to_page(
760        void                    *addr)
761{
762        if ((!is_vmalloc_addr(addr))) {
763                return virt_to_page(addr);
764        } else {
765                return vmalloc_to_page(addr);
766        }
767}
768
769int
770xfs_buf_associate_memory(
771        xfs_buf_t               *bp,
772        void                    *mem,
773        size_t                  len)
774{
775        int                     rval;
776        int                     i = 0;
777        unsigned long           pageaddr;
778        unsigned long           offset;
779        size_t                  buflen;
780        int                     page_count;
781
782        pageaddr = (unsigned long)mem & PAGE_MASK;
783        offset = (unsigned long)mem - pageaddr;
784        buflen = PAGE_ALIGN(len + offset);
785        page_count = buflen >> PAGE_SHIFT;
786
787        /* Free any previous set of page pointers */
788        if (bp->b_pages)
789                _xfs_buf_free_pages(bp);
790
791        bp->b_pages = NULL;
792        bp->b_addr = mem;
793
794        rval = _xfs_buf_get_pages(bp, page_count);
795        if (rval)
796                return rval;
797
798        bp->b_offset = offset;
799
800        for (i = 0; i < bp->b_page_count; i++) {
801                bp->b_pages[i] = mem_to_page((void *)pageaddr);
802                pageaddr += PAGE_SIZE;
803        }
804
805        bp->b_io_length = BTOBB(len);
806        bp->b_length = BTOBB(buflen);
807
808        return 0;
809}
810
811xfs_buf_t *
812xfs_buf_get_uncached(
813        struct xfs_buftarg      *target,
814        size_t                  numblks,
815        int                     flags)
816{
817        unsigned long           page_count;
818        int                     error, i;
819        struct xfs_buf          *bp;
820        DEFINE_SINGLE_BUF_MAP(map, XFS_BUF_DADDR_NULL, numblks);
821
822        bp = _xfs_buf_alloc(target, &map, 1, 0);
823        if (unlikely(bp == NULL))
824                goto fail;
825
826        page_count = PAGE_ALIGN(numblks << BBSHIFT) >> PAGE_SHIFT;
827        error = _xfs_buf_get_pages(bp, page_count);
828        if (error)
829                goto fail_free_buf;
830
831        for (i = 0; i < page_count; i++) {
832                bp->b_pages[i] = alloc_page(xb_to_gfp(flags));
833                if (!bp->b_pages[i])
834                        goto fail_free_mem;
835        }
836        bp->b_flags |= _XBF_PAGES;
837
838        error = _xfs_buf_map_pages(bp, 0);
839        if (unlikely(error)) {
840                xfs_warn(target->bt_mount,
841                        "%s: failed to map pages", __func__);
842                goto fail_free_mem;
843        }
844
845        trace_xfs_buf_get_uncached(bp, _RET_IP_);
846        return bp;
847
848 fail_free_mem:
849        while (--i >= 0)
850                __free_page(bp->b_pages[i]);
851        _xfs_buf_free_pages(bp);
852 fail_free_buf:
853        xfs_buf_free_maps(bp);
854        kmem_zone_free(xfs_buf_zone, bp);
855 fail:
856        return NULL;
857}
858
859/*
860 *      Increment reference count on buffer, to hold the buffer concurrently
861 *      with another thread which may release (free) the buffer asynchronously.
862 *      Must hold the buffer already to call this function.
863 */
864void
865xfs_buf_hold(
866        xfs_buf_t               *bp)
867{
868        trace_xfs_buf_hold(bp, _RET_IP_);
869        atomic_inc(&bp->b_hold);
870}
871
872/*
873 *      Releases a hold on the specified buffer.  If the
874 *      the hold count is 1, calls xfs_buf_free.
875 */
876void
877xfs_buf_rele(
878        xfs_buf_t               *bp)
879{
880        struct xfs_perag        *pag = bp->b_pag;
881
882        trace_xfs_buf_rele(bp, _RET_IP_);
883
884        if (!pag) {
885                ASSERT(list_empty(&bp->b_lru));
886                ASSERT(RB_EMPTY_NODE(&bp->b_rbnode));
887                if (atomic_dec_and_test(&bp->b_hold))
888                        xfs_buf_free(bp);
889                return;
890        }
891
892        ASSERT(!RB_EMPTY_NODE(&bp->b_rbnode));
893
894        ASSERT(atomic_read(&bp->b_hold) > 0);
895        if (atomic_dec_and_lock(&bp->b_hold, &pag->pag_buf_lock)) {
896                spin_lock(&bp->b_lock);
897                if (!(bp->b_flags & XBF_STALE) && atomic_read(&bp->b_lru_ref)) {
898                        /*
899                         * If the buffer is added to the LRU take a new
900                         * reference to the buffer for the LRU and clear the
901                         * (now stale) dispose list state flag
902                         */
903                        if (list_lru_add(&bp->b_target->bt_lru, &bp->b_lru)) {
904                                bp->b_state &= ~XFS_BSTATE_DISPOSE;
905                                atomic_inc(&bp->b_hold);
906                        }
907                        spin_unlock(&bp->b_lock);
908                        spin_unlock(&pag->pag_buf_lock);
909                } else {
910                        /*
911                         * most of the time buffers will already be removed from
912                         * the LRU, so optimise that case by checking for the
913                         * XFS_BSTATE_DISPOSE flag indicating the last list the
914                         * buffer was on was the disposal list
915                         */
916                        if (!(bp->b_state & XFS_BSTATE_DISPOSE)) {
917                                list_lru_del(&bp->b_target->bt_lru, &bp->b_lru);
918                        } else {
919                                ASSERT(list_empty(&bp->b_lru));
920                        }
921                        spin_unlock(&bp->b_lock);
922
923                        ASSERT(!(bp->b_flags & _XBF_DELWRI_Q));
924                        rb_erase(&bp->b_rbnode, &pag->pag_buf_tree);
925                        spin_unlock(&pag->pag_buf_lock);
926                        xfs_perag_put(pag);
927                        xfs_buf_free(bp);
928                }
929        }
930}
931
932
933/*
934 *      Lock a buffer object, if it is not already locked.
935 *
936 *      If we come across a stale, pinned, locked buffer, we know that we are
937 *      being asked to lock a buffer that has been reallocated. Because it is
938 *      pinned, we know that the log has not been pushed to disk and hence it
939 *      will still be locked.  Rather than continuing to have trylock attempts
940 *      fail until someone else pushes the log, push it ourselves before
941 *      returning.  This means that the xfsaild will not get stuck trying
942 *      to push on stale inode buffers.
943 */
944int
945xfs_buf_trylock(
946        struct xfs_buf          *bp)
947{
948        int                     locked;
949
950        locked = down_trylock(&bp->b_sema) == 0;
951        if (locked)
952                XB_SET_OWNER(bp);
953
954        trace_xfs_buf_trylock(bp, _RET_IP_);
955        return locked;
956}
957
958/*
959 *      Lock a buffer object.
960 *
961 *      If we come across a stale, pinned, locked buffer, we know that we
962 *      are being asked to lock a buffer that has been reallocated. Because
963 *      it is pinned, we know that the log has not been pushed to disk and
964 *      hence it will still be locked. Rather than sleeping until someone
965 *      else pushes the log, push it ourselves before trying to get the lock.
966 */
967void
968xfs_buf_lock(
969        struct xfs_buf          *bp)
970{
971        trace_xfs_buf_lock(bp, _RET_IP_);
972
973        if (atomic_read(&bp->b_pin_count) && (bp->b_flags & XBF_STALE))
974                xfs_log_force(bp->b_target->bt_mount, 0);
975        down(&bp->b_sema);
976        XB_SET_OWNER(bp);
977
978        trace_xfs_buf_lock_done(bp, _RET_IP_);
979}
980
981void
982xfs_buf_unlock(
983        struct xfs_buf          *bp)
984{
985        XB_CLEAR_OWNER(bp);
986        up(&bp->b_sema);
987
988        trace_xfs_buf_unlock(bp, _RET_IP_);
989}
990
991STATIC void
992xfs_buf_wait_unpin(
993        xfs_buf_t               *bp)
994{
995        DECLARE_WAITQUEUE       (wait, current);
996
997        if (atomic_read(&bp->b_pin_count) == 0)
998                return;
999
1000        add_wait_queue(&bp->b_waiters, &wait);
1001        for (;;) {
1002                set_current_state(TASK_UNINTERRUPTIBLE);
1003                if (atomic_read(&bp->b_pin_count) == 0)
1004                        break;
1005                io_schedule();
1006        }
1007        remove_wait_queue(&bp->b_waiters, &wait);
1008        set_current_state(TASK_RUNNING);
1009}
1010
1011/*
1012 *      Buffer Utility Routines
1013 */
1014
1015void
1016xfs_buf_ioend(
1017        struct xfs_buf  *bp)
1018{
1019        bool            read = bp->b_flags & XBF_READ;
1020
1021        trace_xfs_buf_iodone(bp, _RET_IP_);
1022
1023        bp->b_flags &= ~(XBF_READ | XBF_WRITE | XBF_READ_AHEAD);
1024
1025        /*
1026         * Pull in IO completion errors now. We are guaranteed to be running
1027         * single threaded, so we don't need the lock to read b_io_error.
1028         */
1029        if (!bp->b_error && bp->b_io_error)
1030                xfs_buf_ioerror(bp, bp->b_io_error);
1031
1032        /* Only validate buffers that were read without errors */
1033        if (read && !bp->b_error && bp->b_ops) {
1034                ASSERT(!bp->b_iodone);
1035                bp->b_ops->verify_read(bp);
1036        }
1037
1038        if (!bp->b_error)
1039                bp->b_flags |= XBF_DONE;
1040
1041        if (bp->b_iodone)
1042                (*(bp->b_iodone))(bp);
1043        else if (bp->b_flags & XBF_ASYNC)
1044                xfs_buf_relse(bp);
1045        else
1046                complete(&bp->b_iowait);
1047}
1048
1049static void
1050xfs_buf_ioend_work(
1051        struct work_struct      *work)
1052{
1053        struct xfs_buf          *bp =
1054                container_of(work, xfs_buf_t, b_iodone_work);
1055
1056        xfs_buf_ioend(bp);
1057}
1058
1059void
1060xfs_buf_ioend_async(
1061        struct xfs_buf  *bp)
1062{
1063        INIT_WORK(&bp->b_iodone_work, xfs_buf_ioend_work);
1064        queue_work(xfslogd_workqueue, &bp->b_iodone_work);
1065}
1066
1067void
1068xfs_buf_ioerror(
1069        xfs_buf_t               *bp,
1070        int                     error)
1071{
1072        ASSERT(error <= 0 && error >= -1000);
1073        bp->b_error = error;
1074        trace_xfs_buf_ioerror(bp, error, _RET_IP_);
1075}
1076
1077void
1078xfs_buf_ioerror_alert(
1079        struct xfs_buf          *bp,
1080        const char              *func)
1081{
1082        xfs_alert(bp->b_target->bt_mount,
1083"metadata I/O error: block 0x%llx (\"%s\") error %d numblks %d",
1084                (__uint64_t)XFS_BUF_ADDR(bp), func, -bp->b_error, bp->b_length);
1085}
1086
1087int
1088xfs_bwrite(
1089        struct xfs_buf          *bp)
1090{
1091        int                     error;
1092
1093        ASSERT(xfs_buf_islocked(bp));
1094
1095        bp->b_flags |= XBF_WRITE;
1096        bp->b_flags &= ~(XBF_ASYNC | XBF_READ | _XBF_DELWRI_Q |
1097                         XBF_WRITE_FAIL | XBF_DONE);
1098
1099        error = xfs_buf_submit_wait(bp);
1100        if (error) {
1101                xfs_force_shutdown(bp->b_target->bt_mount,
1102                                   SHUTDOWN_META_IO_ERROR);
1103        }
1104        return error;
1105}
1106
1107STATIC void
1108xfs_buf_bio_end_io(
1109        struct bio              *bio,
1110        int                     error)
1111{
1112        xfs_buf_t               *bp = (xfs_buf_t *)bio->bi_private;
1113
1114        /*
1115         * don't overwrite existing errors - otherwise we can lose errors on
1116         * buffers that require multiple bios to complete.
1117         */
1118        if (error) {
1119                spin_lock(&bp->b_lock);
1120                if (!bp->b_io_error)
1121                        bp->b_io_error = error;
1122                spin_unlock(&bp->b_lock);
1123        }
1124
1125        if (!bp->b_error && xfs_buf_is_vmapped(bp) && (bp->b_flags & XBF_READ))
1126                invalidate_kernel_vmap_range(bp->b_addr, xfs_buf_vmap_len(bp));
1127
1128        if (atomic_dec_and_test(&bp->b_io_remaining) == 1)
1129                xfs_buf_ioend_async(bp);
1130        bio_put(bio);
1131}
1132
1133static void
1134xfs_buf_ioapply_map(
1135        struct xfs_buf  *bp,
1136        int             map,
1137        int             *buf_offset,
1138        int             *count,
1139        int             rw)
1140{
1141        int             page_index;
1142        int             total_nr_pages = bp->b_page_count;
1143        int             nr_pages;
1144        struct bio      *bio;
1145        sector_t        sector =  bp->b_maps[map].bm_bn;
1146        int             size;
1147        int             offset;
1148
1149        total_nr_pages = bp->b_page_count;
1150
1151        /* skip the pages in the buffer before the start offset */
1152        page_index = 0;
1153        offset = *buf_offset;
1154        while (offset >= PAGE_SIZE) {
1155                page_index++;
1156                offset -= PAGE_SIZE;
1157        }
1158
1159        /*
1160         * Limit the IO size to the length of the current vector, and update the
1161         * remaining IO count for the next time around.
1162         */
1163        size = min_t(int, BBTOB(bp->b_maps[map].bm_len), *count);
1164        *count -= size;
1165        *buf_offset += size;
1166
1167next_chunk:
1168        atomic_inc(&bp->b_io_remaining);
1169        nr_pages = BIO_MAX_SECTORS >> (PAGE_SHIFT - BBSHIFT);
1170        if (nr_pages > total_nr_pages)
1171                nr_pages = total_nr_pages;
1172
1173        bio = bio_alloc(GFP_NOIO, nr_pages);
1174        bio->bi_bdev = bp->b_target->bt_bdev;
1175        bio->bi_iter.bi_sector = sector;
1176        bio->bi_end_io = xfs_buf_bio_end_io;
1177        bio->bi_private = bp;
1178
1179
1180        for (; size && nr_pages; nr_pages--, page_index++) {
1181                int     rbytes, nbytes = PAGE_SIZE - offset;
1182
1183                if (nbytes > size)
1184                        nbytes = size;
1185
1186                rbytes = bio_add_page(bio, bp->b_pages[page_index], nbytes,
1187                                      offset);
1188                if (rbytes < nbytes)
1189                        break;
1190
1191                offset = 0;
1192                sector += BTOBB(nbytes);
1193                size -= nbytes;
1194                total_nr_pages--;
1195        }
1196
1197        if (likely(bio->bi_iter.bi_size)) {
1198                if (xfs_buf_is_vmapped(bp)) {
1199                        flush_kernel_vmap_range(bp->b_addr,
1200                                                xfs_buf_vmap_len(bp));
1201                }
1202                submit_bio(rw, bio);
1203                if (size)
1204                        goto next_chunk;
1205        } else {
1206                /*
1207                 * This is guaranteed not to be the last io reference count
1208                 * because the caller (xfs_buf_submit) holds a count itself.
1209                 */
1210                atomic_dec(&bp->b_io_remaining);
1211                xfs_buf_ioerror(bp, -EIO);
1212                bio_put(bio);
1213        }
1214
1215}
1216
1217STATIC void
1218_xfs_buf_ioapply(
1219        struct xfs_buf  *bp)
1220{
1221        struct blk_plug plug;
1222        int             rw;
1223        int             offset;
1224        int             size;
1225        int             i;
1226
1227        /*
1228         * Make sure we capture only current IO errors rather than stale errors
1229         * left over from previous use of the buffer (e.g. failed readahead).
1230         */
1231        bp->b_error = 0;
1232
1233        if (bp->b_flags & XBF_WRITE) {
1234                if (bp->b_flags & XBF_SYNCIO)
1235                        rw = WRITE_SYNC;
1236                else
1237                        rw = WRITE;
1238                if (bp->b_flags & XBF_FUA)
1239                        rw |= REQ_FUA;
1240                if (bp->b_flags & XBF_FLUSH)
1241                        rw |= REQ_FLUSH;
1242
1243                /*
1244                 * Run the write verifier callback function if it exists. If
1245                 * this function fails it will mark the buffer with an error and
1246                 * the IO should not be dispatched.
1247                 */
1248                if (bp->b_ops) {
1249                        bp->b_ops->verify_write(bp);
1250                        if (bp->b_error) {
1251                                xfs_force_shutdown(bp->b_target->bt_mount,
1252                                                   SHUTDOWN_CORRUPT_INCORE);
1253                                return;
1254                        }
1255                } else if (bp->b_bn != XFS_BUF_DADDR_NULL) {
1256                        struct xfs_mount *mp = bp->b_target->bt_mount;
1257
1258                        /*
1259                         * non-crc filesystems don't attach verifiers during
1260                         * log recovery, so don't warn for such filesystems.
1261                         */
1262                        if (xfs_sb_version_hascrc(&mp->m_sb)) {
1263                                xfs_warn(mp,
1264                                        "%s: no ops on block 0x%llx/0x%x",
1265                                        __func__, bp->b_bn, bp->b_length);
1266                                xfs_hex_dump(bp->b_addr, 64);
1267                                dump_stack();
1268                        }
1269                }
1270        } else if (bp->b_flags & XBF_READ_AHEAD) {
1271                rw = READA;
1272        } else {
1273                rw = READ;
1274        }
1275
1276        /* we only use the buffer cache for meta-data */
1277        rw |= REQ_META;
1278
1279        /*
1280         * Walk all the vectors issuing IO on them. Set up the initial offset
1281         * into the buffer and the desired IO size before we start -
1282         * _xfs_buf_ioapply_vec() will modify them appropriately for each
1283         * subsequent call.
1284         */
1285        offset = bp->b_offset;
1286        size = BBTOB(bp->b_io_length);
1287        blk_start_plug(&plug);
1288        for (i = 0; i < bp->b_map_count; i++) {
1289                xfs_buf_ioapply_map(bp, i, &offset, &size, rw);
1290                if (bp->b_error)
1291                        break;
1292                if (size <= 0)
1293                        break;  /* all done */
1294        }
1295        blk_finish_plug(&plug);
1296}
1297
1298/*
1299 * Asynchronous IO submission path. This transfers the buffer lock ownership and
1300 * the current reference to the IO. It is not safe to reference the buffer after
1301 * a call to this function unless the caller holds an additional reference
1302 * itself.
1303 */
1304void
1305xfs_buf_submit(
1306        struct xfs_buf  *bp)
1307{
1308        trace_xfs_buf_submit(bp, _RET_IP_);
1309
1310        ASSERT(!(bp->b_flags & _XBF_DELWRI_Q));
1311        ASSERT(bp->b_flags & XBF_ASYNC);
1312
1313        /* on shutdown we stale and complete the buffer immediately */
1314        if (XFS_FORCED_SHUTDOWN(bp->b_target->bt_mount)) {
1315                xfs_buf_ioerror(bp, -EIO);
1316                bp->b_flags &= ~XBF_DONE;
1317                xfs_buf_stale(bp);
1318                xfs_buf_ioend(bp);
1319                return;
1320        }
1321
1322        if (bp->b_flags & XBF_WRITE)
1323                xfs_buf_wait_unpin(bp);
1324
1325        /* clear the internal error state to avoid spurious errors */
1326        bp->b_io_error = 0;
1327
1328        /*
1329         * The caller's reference is released during I/O completion.
1330         * This occurs some time after the last b_io_remaining reference is
1331         * released, so after we drop our Io reference we have to have some
1332         * other reference to ensure the buffer doesn't go away from underneath
1333         * us. Take a direct reference to ensure we have safe access to the
1334         * buffer until we are finished with it.
1335         */
1336        xfs_buf_hold(bp);
1337
1338        /*
1339         * Set the count to 1 initially, this will stop an I/O completion
1340         * callout which happens before we have started all the I/O from calling
1341         * xfs_buf_ioend too early.
1342         */
1343        atomic_set(&bp->b_io_remaining, 1);
1344        _xfs_buf_ioapply(bp);
1345
1346        /*
1347         * If _xfs_buf_ioapply failed, we can get back here with only the IO
1348         * reference we took above. If we drop it to zero, run completion so
1349         * that we don't return to the caller with completion still pending.
1350         */
1351        if (atomic_dec_and_test(&bp->b_io_remaining) == 1) {
1352                if (bp->b_error)
1353                        xfs_buf_ioend(bp);
1354                else
1355                        xfs_buf_ioend_async(bp);
1356        }
1357
1358        xfs_buf_rele(bp);
1359        /* Note: it is not safe to reference bp now we've dropped our ref */
1360}
1361
1362/*
1363 * Synchronous buffer IO submission path, read or write.
1364 */
1365int
1366xfs_buf_submit_wait(
1367        struct xfs_buf  *bp)
1368{
1369        int             error;
1370
1371        trace_xfs_buf_submit_wait(bp, _RET_IP_);
1372
1373        ASSERT(!(bp->b_flags & (_XBF_DELWRI_Q | XBF_ASYNC)));
1374
1375        if (XFS_FORCED_SHUTDOWN(bp->b_target->bt_mount)) {
1376                xfs_buf_ioerror(bp, -EIO);
1377                xfs_buf_stale(bp);
1378                bp->b_flags &= ~XBF_DONE;
1379                return -EIO;
1380        }
1381
1382        if (bp->b_flags & XBF_WRITE)
1383                xfs_buf_wait_unpin(bp);
1384
1385        /* clear the internal error state to avoid spurious errors */
1386        bp->b_io_error = 0;
1387
1388        /*
1389         * For synchronous IO, the IO does not inherit the submitters reference
1390         * count, nor the buffer lock. Hence we cannot release the reference we
1391         * are about to take until we've waited for all IO completion to occur,
1392         * including any xfs_buf_ioend_async() work that may be pending.
1393         */
1394        xfs_buf_hold(bp);
1395
1396        /*
1397         * Set the count to 1 initially, this will stop an I/O completion
1398         * callout which happens before we have started all the I/O from calling
1399         * xfs_buf_ioend too early.
1400         */
1401        atomic_set(&bp->b_io_remaining, 1);
1402        _xfs_buf_ioapply(bp);
1403
1404        /*
1405         * make sure we run completion synchronously if it raced with us and is
1406         * already complete.
1407         */
1408        if (atomic_dec_and_test(&bp->b_io_remaining) == 1)
1409                xfs_buf_ioend(bp);
1410
1411        /* wait for completion before gathering the error from the buffer */
1412        trace_xfs_buf_iowait(bp, _RET_IP_);
1413        wait_for_completion(&bp->b_iowait);
1414        trace_xfs_buf_iowait_done(bp, _RET_IP_);
1415        error = bp->b_error;
1416
1417        /*
1418         * all done now, we can release the hold that keeps the buffer
1419         * referenced for the entire IO.
1420         */
1421        xfs_buf_rele(bp);
1422        return error;
1423}
1424
1425xfs_caddr_t
1426xfs_buf_offset(
1427        xfs_buf_t               *bp,
1428        size_t                  offset)
1429{
1430        struct page             *page;
1431
1432        if (bp->b_addr)
1433                return bp->b_addr + offset;
1434
1435        offset += bp->b_offset;
1436        page = bp->b_pages[offset >> PAGE_SHIFT];
1437        return (xfs_caddr_t)page_address(page) + (offset & (PAGE_SIZE-1));
1438}
1439
1440/*
1441 *      Move data into or out of a buffer.
1442 */
1443void
1444xfs_buf_iomove(
1445        xfs_buf_t               *bp,    /* buffer to process            */
1446        size_t                  boff,   /* starting buffer offset       */
1447        size_t                  bsize,  /* length to copy               */
1448        void                    *data,  /* data address                 */
1449        xfs_buf_rw_t            mode)   /* read/write/zero flag         */
1450{
1451        size_t                  bend;
1452
1453        bend = boff + bsize;
1454        while (boff < bend) {
1455                struct page     *page;
1456                int             page_index, page_offset, csize;
1457
1458                page_index = (boff + bp->b_offset) >> PAGE_SHIFT;
1459                page_offset = (boff + bp->b_offset) & ~PAGE_MASK;
1460                page = bp->b_pages[page_index];
1461                csize = min_t(size_t, PAGE_SIZE - page_offset,
1462                                      BBTOB(bp->b_io_length) - boff);
1463
1464                ASSERT((csize + page_offset) <= PAGE_SIZE);
1465
1466                switch (mode) {
1467                case XBRW_ZERO:
1468                        memset(page_address(page) + page_offset, 0, csize);
1469                        break;
1470                case XBRW_READ:
1471                        memcpy(data, page_address(page) + page_offset, csize);
1472                        break;
1473                case XBRW_WRITE:
1474                        memcpy(page_address(page) + page_offset, data, csize);
1475                }
1476
1477                boff += csize;
1478                data += csize;
1479        }
1480}
1481
1482/*
1483 *      Handling of buffer targets (buftargs).
1484 */
1485
1486/*
1487 * Wait for any bufs with callbacks that have been submitted but have not yet
1488 * returned. These buffers will have an elevated hold count, so wait on those
1489 * while freeing all the buffers only held by the LRU.
1490 */
1491static enum lru_status
1492xfs_buftarg_wait_rele(
1493        struct list_head        *item,
1494        spinlock_t              *lru_lock,
1495        void                    *arg)
1496
1497{
1498        struct xfs_buf          *bp = container_of(item, struct xfs_buf, b_lru);
1499        struct list_head        *dispose = arg;
1500
1501        if (atomic_read(&bp->b_hold) > 1) {
1502                /* need to wait, so skip it this pass */
1503                trace_xfs_buf_wait_buftarg(bp, _RET_IP_);
1504                return LRU_SKIP;
1505        }
1506        if (!spin_trylock(&bp->b_lock))
1507                return LRU_SKIP;
1508
1509        /*
1510         * clear the LRU reference count so the buffer doesn't get
1511         * ignored in xfs_buf_rele().
1512         */
1513        atomic_set(&bp->b_lru_ref, 0);
1514        bp->b_state |= XFS_BSTATE_DISPOSE;
1515        list_move(item, dispose);
1516        spin_unlock(&bp->b_lock);
1517        return LRU_REMOVED;
1518}
1519
1520void
1521xfs_wait_buftarg(
1522        struct xfs_buftarg      *btp)
1523{
1524        LIST_HEAD(dispose);
1525        int loop = 0;
1526
1527        /* loop until there is nothing left on the lru list. */
1528        while (list_lru_count(&btp->bt_lru)) {
1529                list_lru_walk(&btp->bt_lru, xfs_buftarg_wait_rele,
1530                              &dispose, LONG_MAX);
1531
1532                while (!list_empty(&dispose)) {
1533                        struct xfs_buf *bp;
1534                        bp = list_first_entry(&dispose, struct xfs_buf, b_lru);
1535                        list_del_init(&bp->b_lru);
1536                        if (bp->b_flags & XBF_WRITE_FAIL) {
1537                                xfs_alert(btp->bt_mount,
1538"Corruption Alert: Buffer at block 0x%llx had permanent write failures!\n"
1539"Please run xfs_repair to determine the extent of the problem.",
1540                                        (long long)bp->b_bn);
1541                        }
1542                        xfs_buf_rele(bp);
1543                }
1544                if (loop++ != 0)
1545                        delay(100);
1546        }
1547}
1548
1549static enum lru_status
1550xfs_buftarg_isolate(
1551        struct list_head        *item,
1552        spinlock_t              *lru_lock,
1553        void                    *arg)
1554{
1555        struct xfs_buf          *bp = container_of(item, struct xfs_buf, b_lru);
1556        struct list_head        *dispose = arg;
1557
1558        /*
1559         * we are inverting the lru lock/bp->b_lock here, so use a trylock.
1560         * If we fail to get the lock, just skip it.
1561         */
1562        if (!spin_trylock(&bp->b_lock))
1563                return LRU_SKIP;
1564        /*
1565         * Decrement the b_lru_ref count unless the value is already
1566         * zero. If the value is already zero, we need to reclaim the
1567         * buffer, otherwise it gets another trip through the LRU.
1568         */
1569        if (!atomic_add_unless(&bp->b_lru_ref, -1, 0)) {
1570                spin_unlock(&bp->b_lock);
1571                return LRU_ROTATE;
1572        }
1573
1574        bp->b_state |= XFS_BSTATE_DISPOSE;
1575        list_move(item, dispose);
1576        spin_unlock(&bp->b_lock);
1577        return LRU_REMOVED;
1578}
1579
1580static unsigned long
1581xfs_buftarg_shrink_scan(
1582        struct shrinker         *shrink,
1583        struct shrink_control   *sc)
1584{
1585        struct xfs_buftarg      *btp = container_of(shrink,
1586                                        struct xfs_buftarg, bt_shrinker);
1587        LIST_HEAD(dispose);
1588        unsigned long           freed;
1589        unsigned long           nr_to_scan = sc->nr_to_scan;
1590
1591        freed = list_lru_walk_node(&btp->bt_lru, sc->nid, xfs_buftarg_isolate,
1592                                       &dispose, &nr_to_scan);
1593
1594        while (!list_empty(&dispose)) {
1595                struct xfs_buf *bp;
1596                bp = list_first_entry(&dispose, struct xfs_buf, b_lru);
1597                list_del_init(&bp->b_lru);
1598                xfs_buf_rele(bp);
1599        }
1600
1601        return freed;
1602}
1603
1604static unsigned long
1605xfs_buftarg_shrink_count(
1606        struct shrinker         *shrink,
1607        struct shrink_control   *sc)
1608{
1609        struct xfs_buftarg      *btp = container_of(shrink,
1610                                        struct xfs_buftarg, bt_shrinker);
1611        return list_lru_count_node(&btp->bt_lru, sc->nid);
1612}
1613
1614void
1615xfs_free_buftarg(
1616        struct xfs_mount        *mp,
1617        struct xfs_buftarg      *btp)
1618{
1619        unregister_shrinker(&btp->bt_shrinker);
1620        list_lru_destroy(&btp->bt_lru);
1621
1622        if (mp->m_flags & XFS_MOUNT_BARRIER)
1623                xfs_blkdev_issue_flush(btp);
1624
1625        kmem_free(btp);
1626}
1627
1628int
1629xfs_setsize_buftarg(
1630        xfs_buftarg_t           *btp,
1631        unsigned int            sectorsize)
1632{
1633        /* Set up metadata sector size info */
1634        btp->bt_meta_sectorsize = sectorsize;
1635        btp->bt_meta_sectormask = sectorsize - 1;
1636
1637        if (set_blocksize(btp->bt_bdev, sectorsize)) {
1638                char name[BDEVNAME_SIZE];
1639
1640                bdevname(btp->bt_bdev, name);
1641
1642                xfs_warn(btp->bt_mount,
1643                        "Cannot set_blocksize to %u on device %s",
1644                        sectorsize, name);
1645                return -EINVAL;
1646        }
1647
1648        /* Set up device logical sector size mask */
1649        btp->bt_logical_sectorsize = bdev_logical_block_size(btp->bt_bdev);
1650        btp->bt_logical_sectormask = bdev_logical_block_size(btp->bt_bdev) - 1;
1651
1652        return 0;
1653}
1654
1655/*
1656 * When allocating the initial buffer target we have not yet
1657 * read in the superblock, so don't know what sized sectors
1658 * are being used at this early stage.  Play safe.
1659 */
1660STATIC int
1661xfs_setsize_buftarg_early(
1662        xfs_buftarg_t           *btp,
1663        struct block_device     *bdev)
1664{
1665        return xfs_setsize_buftarg(btp, bdev_logical_block_size(bdev));
1666}
1667
1668xfs_buftarg_t *
1669xfs_alloc_buftarg(
1670        struct xfs_mount        *mp,
1671        struct block_device     *bdev)
1672{
1673        xfs_buftarg_t           *btp;
1674
1675        btp = kmem_zalloc(sizeof(*btp), KM_SLEEP | KM_NOFS);
1676
1677        btp->bt_mount = mp;
1678        btp->bt_dev =  bdev->bd_dev;
1679        btp->bt_bdev = bdev;
1680        btp->bt_bdi = blk_get_backing_dev_info(bdev);
1681
1682        if (xfs_setsize_buftarg_early(btp, bdev))
1683                goto error;
1684
1685        if (list_lru_init(&btp->bt_lru))
1686                goto error;
1687
1688        btp->bt_shrinker.count_objects = xfs_buftarg_shrink_count;
1689        btp->bt_shrinker.scan_objects = xfs_buftarg_shrink_scan;
1690        btp->bt_shrinker.seeks = DEFAULT_SEEKS;
1691        btp->bt_shrinker.flags = SHRINKER_NUMA_AWARE;
1692        register_shrinker(&btp->bt_shrinker);
1693        return btp;
1694
1695error:
1696        kmem_free(btp);
1697        return NULL;
1698}
1699
1700/*
1701 * Add a buffer to the delayed write list.
1702 *
1703 * This queues a buffer for writeout if it hasn't already been.  Note that
1704 * neither this routine nor the buffer list submission functions perform
1705 * any internal synchronization.  It is expected that the lists are thread-local
1706 * to the callers.
1707 *
1708 * Returns true if we queued up the buffer, or false if it already had
1709 * been on the buffer list.
1710 */
1711bool
1712xfs_buf_delwri_queue(
1713        struct xfs_buf          *bp,
1714        struct list_head        *list)
1715{
1716        ASSERT(xfs_buf_islocked(bp));
1717        ASSERT(!(bp->b_flags & XBF_READ));
1718
1719        /*
1720         * If the buffer is already marked delwri it already is queued up
1721         * by someone else for imediate writeout.  Just ignore it in that
1722         * case.
1723         */
1724        if (bp->b_flags & _XBF_DELWRI_Q) {
1725                trace_xfs_buf_delwri_queued(bp, _RET_IP_);
1726                return false;
1727        }
1728
1729        trace_xfs_buf_delwri_queue(bp, _RET_IP_);
1730
1731        /*
1732         * If a buffer gets written out synchronously or marked stale while it
1733         * is on a delwri list we lazily remove it. To do this, the other party
1734         * clears the  _XBF_DELWRI_Q flag but otherwise leaves the buffer alone.
1735         * It remains referenced and on the list.  In a rare corner case it
1736         * might get readded to a delwri list after the synchronous writeout, in
1737         * which case we need just need to re-add the flag here.
1738         */
1739        bp->b_flags |= _XBF_DELWRI_Q;
1740        if (list_empty(&bp->b_list)) {
1741                atomic_inc(&bp->b_hold);
1742                list_add_tail(&bp->b_list, list);
1743        }
1744
1745        return true;
1746}
1747
1748/*
1749 * Compare function is more complex than it needs to be because
1750 * the return value is only 32 bits and we are doing comparisons
1751 * on 64 bit values
1752 */
1753static int
1754xfs_buf_cmp(
1755        void            *priv,
1756        struct list_head *a,
1757        struct list_head *b)
1758{
1759        struct xfs_buf  *ap = container_of(a, struct xfs_buf, b_list);
1760        struct xfs_buf  *bp = container_of(b, struct xfs_buf, b_list);
1761        xfs_daddr_t             diff;
1762
1763        diff = ap->b_maps[0].bm_bn - bp->b_maps[0].bm_bn;
1764        if (diff < 0)
1765                return -1;
1766        if (diff > 0)
1767                return 1;
1768        return 0;
1769}
1770
1771static int
1772__xfs_buf_delwri_submit(
1773        struct list_head        *buffer_list,
1774        struct list_head        *io_list,
1775        bool                    wait)
1776{
1777        struct blk_plug         plug;
1778        struct xfs_buf          *bp, *n;
1779        int                     pinned = 0;
1780
1781        list_for_each_entry_safe(bp, n, buffer_list, b_list) {
1782                if (!wait) {
1783                        if (xfs_buf_ispinned(bp)) {
1784                                pinned++;
1785                                continue;
1786                        }
1787                        if (!xfs_buf_trylock(bp))
1788                                continue;
1789                } else {
1790                        xfs_buf_lock(bp);
1791                }
1792
1793                /*
1794                 * Someone else might have written the buffer synchronously or
1795                 * marked it stale in the meantime.  In that case only the
1796                 * _XBF_DELWRI_Q flag got cleared, and we have to drop the
1797                 * reference and remove it from the list here.
1798                 */
1799                if (!(bp->b_flags & _XBF_DELWRI_Q)) {
1800                        list_del_init(&bp->b_list);
1801                        xfs_buf_relse(bp);
1802                        continue;
1803                }
1804
1805                list_move_tail(&bp->b_list, io_list);
1806                trace_xfs_buf_delwri_split(bp, _RET_IP_);
1807        }
1808
1809        list_sort(NULL, io_list, xfs_buf_cmp);
1810
1811        blk_start_plug(&plug);
1812        list_for_each_entry_safe(bp, n, io_list, b_list) {
1813                bp->b_flags &= ~(_XBF_DELWRI_Q | XBF_ASYNC | XBF_WRITE_FAIL);
1814                bp->b_flags |= XBF_WRITE | XBF_ASYNC;
1815
1816                /*
1817                 * we do all Io submission async. This means if we need to wait
1818                 * for IO completion we need to take an extra reference so the
1819                 * buffer is still valid on the other side.
1820                 */
1821                if (wait)
1822                        xfs_buf_hold(bp);
1823                else
1824                        list_del_init(&bp->b_list);
1825
1826                xfs_buf_submit(bp);
1827        }
1828        blk_finish_plug(&plug);
1829
1830        return pinned;
1831}
1832
1833/*
1834 * Write out a buffer list asynchronously.
1835 *
1836 * This will take the @buffer_list, write all non-locked and non-pinned buffers
1837 * out and not wait for I/O completion on any of the buffers.  This interface
1838 * is only safely useable for callers that can track I/O completion by higher
1839 * level means, e.g. AIL pushing as the @buffer_list is consumed in this
1840 * function.
1841 */
1842int
1843xfs_buf_delwri_submit_nowait(
1844        struct list_head        *buffer_list)
1845{
1846        LIST_HEAD               (io_list);
1847        return __xfs_buf_delwri_submit(buffer_list, &io_list, false);
1848}
1849
1850/*
1851 * Write out a buffer list synchronously.
1852 *
1853 * This will take the @buffer_list, write all buffers out and wait for I/O
1854 * completion on all of the buffers. @buffer_list is consumed by the function,
1855 * so callers must have some other way of tracking buffers if they require such
1856 * functionality.
1857 */
1858int
1859xfs_buf_delwri_submit(
1860        struct list_head        *buffer_list)
1861{
1862        LIST_HEAD               (io_list);
1863        int                     error = 0, error2;
1864        struct xfs_buf          *bp;
1865
1866        __xfs_buf_delwri_submit(buffer_list, &io_list, true);
1867
1868        /* Wait for IO to complete. */
1869        while (!list_empty(&io_list)) {
1870                bp = list_first_entry(&io_list, struct xfs_buf, b_list);
1871
1872                list_del_init(&bp->b_list);
1873
1874                /* locking the buffer will wait for async IO completion. */
1875                xfs_buf_lock(bp);
1876                error2 = bp->b_error;
1877                xfs_buf_relse(bp);
1878                if (!error)
1879                        error = error2;
1880        }
1881
1882        return error;
1883}
1884
1885int __init
1886xfs_buf_init(void)
1887{
1888        xfs_buf_zone = kmem_zone_init_flags(sizeof(xfs_buf_t), "xfs_buf",
1889                                                KM_ZONE_HWALIGN, NULL);
1890        if (!xfs_buf_zone)
1891                goto out;
1892
1893        xfslogd_workqueue = alloc_workqueue("xfslogd",
1894                                WQ_MEM_RECLAIM | WQ_HIGHPRI | WQ_FREEZABLE, 1);
1895        if (!xfslogd_workqueue)
1896                goto out_free_buf_zone;
1897
1898        return 0;
1899
1900 out_free_buf_zone:
1901        kmem_zone_destroy(xfs_buf_zone);
1902 out:
1903        return -ENOMEM;
1904}
1905
1906void
1907xfs_buf_terminate(void)
1908{
1909        destroy_workqueue(xfslogd_workqueue);
1910        kmem_zone_destroy(xfs_buf_zone);
1911}
Note: See TracBrowser for help on using the repository browser.