blob: d7a67d7fbc7f9cb6627f859a629568c5afe0bb97 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Nathan Scottf07c2252006-09-28 10:52:15 +10002 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
Nathan Scott7b718762005-11-02 14:58:39 +11003 * All Rights Reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
Nathan Scott7b718762005-11-02 14:58:39 +11005 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * published by the Free Software Foundation.
8 *
Nathan Scott7b718762005-11-02 14:58:39 +11009 * 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.
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 *
Nathan Scott7b718762005-11-02 14:58:39 +110014 * 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 */
Vlad Apostolov93c189c2006-11-11 18:03:49 +110018#include "xfs.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <linux/stddef.h>
20#include <linux/errno.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090021#include <linux/gfp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#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>
Christoph Hellwig4df08c52005-09-05 08:34:18 +100032#include <linux/kthread.h>
Christoph Lameterb20a3502006-03-22 00:09:12 -080033#include <linux/migrate.h>
Andrew Morton3fcfab12006-10-19 23:28:16 -070034#include <linux/backing-dev.h>
Nigel Cunningham7dfb7102006-12-06 20:34:23 -080035#include <linux/freezer.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070036
Christoph Hellwig4fb6e8a2014-11-28 14:25:04 +110037#include "xfs_format.h"
Dave Chinner239880e2013-10-23 10:50:10 +110038#include "xfs_log_format.h"
Dave Chinner7fd36c42013-08-12 20:49:32 +100039#include "xfs_trans_resv.h"
Dave Chinner239880e2013-10-23 10:50:10 +110040#include "xfs_sb.h"
Christoph Hellwigb7963132009-03-03 14:48:37 -050041#include "xfs_mount.h"
Christoph Hellwig0b1b2132009-12-14 23:14:59 +000042#include "xfs_trace.h"
Dave Chinner239880e2013-10-23 10:50:10 +110043#include "xfs_log.h"
Christoph Hellwigb7963132009-03-03 14:48:37 -050044
David Chinner7989cb82007-02-10 18:34:56 +110045static kmem_zone_t *xfs_buf_zone;
Christoph Hellwig23ea4032005-06-21 15:14:01 +100046
Nathan Scottce8e9222006-01-11 15:39:08 +110047#ifdef XFS_BUF_LOCK_TRACKING
48# define XB_SET_OWNER(bp) ((bp)->b_last_holder = current->pid)
49# define XB_CLEAR_OWNER(bp) ((bp)->b_last_holder = -1)
50# define XB_GET_OWNER(bp) ((bp)->b_last_holder)
Linus Torvalds1da177e2005-04-16 15:20:36 -070051#else
Nathan Scottce8e9222006-01-11 15:39:08 +110052# define XB_SET_OWNER(bp) do { } while (0)
53# define XB_CLEAR_OWNER(bp) do { } while (0)
54# define XB_GET_OWNER(bp) do { } while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -070055#endif
56
Nathan Scottce8e9222006-01-11 15:39:08 +110057#define xb_to_gfp(flags) \
Dave Chinneraa5c1582012-04-23 15:58:56 +100058 ((((flags) & XBF_READ_AHEAD) ? __GFP_NORETRY : GFP_NOFS) | __GFP_NOWARN)
Linus Torvalds1da177e2005-04-16 15:20:36 -070059
Linus Torvalds1da177e2005-04-16 15:20:36 -070060
James Bottomley73c77e22010-01-25 11:42:24 -060061static inline int
62xfs_buf_is_vmapped(
63 struct xfs_buf *bp)
64{
65 /*
66 * Return true if the buffer is vmapped.
67 *
Dave Chinner611c9942012-04-23 15:59:07 +100068 * b_addr is null if the buffer is not mapped, but the code is clever
69 * enough to know it doesn't have to map a single page, so the check has
70 * to be both for b_addr and bp->b_page_count > 1.
James Bottomley73c77e22010-01-25 11:42:24 -060071 */
Dave Chinner611c9942012-04-23 15:59:07 +100072 return bp->b_addr && bp->b_page_count > 1;
James Bottomley73c77e22010-01-25 11:42:24 -060073}
74
75static inline int
76xfs_buf_vmap_len(
77 struct xfs_buf *bp)
78{
79 return (bp->b_page_count * PAGE_SIZE) - bp->b_offset;
80}
81
Linus Torvalds1da177e2005-04-16 15:20:36 -070082/*
Brian Foster9c7504a2016-07-20 11:15:28 +100083 * Bump the I/O in flight count on the buftarg if we haven't yet done so for
84 * this buffer. The count is incremented once per buffer (per hold cycle)
85 * because the corresponding decrement is deferred to buffer release. Buffers
86 * can undergo I/O multiple times in a hold-release cycle and per buffer I/O
87 * tracking adds unnecessary overhead. This is used for sychronization purposes
88 * with unmount (see xfs_wait_buftarg()), so all we really need is a count of
89 * in-flight buffers.
90 *
91 * Buffers that are never released (e.g., superblock, iclog buffers) must set
92 * the XBF_NO_IOACCT flag before I/O submission. Otherwise, the buftarg count
93 * never reaches zero and unmount hangs indefinitely.
94 */
95static inline void
96xfs_buf_ioacct_inc(
97 struct xfs_buf *bp)
98{
99 if (bp->b_flags & (XBF_NO_IOACCT|_XBF_IN_FLIGHT))
100 return;
101
102 ASSERT(bp->b_flags & XBF_ASYNC);
103 bp->b_flags |= _XBF_IN_FLIGHT;
104 percpu_counter_inc(&bp->b_target->bt_io_count);
105}
106
107/*
108 * Clear the in-flight state on a buffer about to be released to the LRU or
109 * freed and unaccount from the buftarg.
110 */
111static inline void
112xfs_buf_ioacct_dec(
113 struct xfs_buf *bp)
114{
115 if (!(bp->b_flags & _XBF_IN_FLIGHT))
116 return;
117
Brian Foster9c7504a2016-07-20 11:15:28 +1000118 bp->b_flags &= ~_XBF_IN_FLIGHT;
119 percpu_counter_dec(&bp->b_target->bt_io_count);
120}
121
122/*
Dave Chinner430cbeb2010-12-02 16:30:55 +1100123 * When we mark a buffer stale, we remove the buffer from the LRU and clear the
124 * b_lru_ref count so that the buffer is freed immediately when the buffer
125 * reference count falls to zero. If the buffer is already on the LRU, we need
126 * to remove the reference that LRU holds on the buffer.
127 *
128 * This prevents build-up of stale buffers on the LRU.
129 */
130void
131xfs_buf_stale(
132 struct xfs_buf *bp)
133{
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000134 ASSERT(xfs_buf_islocked(bp));
135
Dave Chinner430cbeb2010-12-02 16:30:55 +1100136 bp->b_flags |= XBF_STALE;
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000137
138 /*
139 * Clear the delwri status so that a delwri queue walker will not
140 * flush this buffer to disk now that it is stale. The delwri queue has
141 * a reference to the buffer, so this is safe to do.
142 */
143 bp->b_flags &= ~_XBF_DELWRI_Q;
144
Brian Foster9c7504a2016-07-20 11:15:28 +1000145 /*
146 * Once the buffer is marked stale and unlocked, a subsequent lookup
147 * could reset b_flags. There is no guarantee that the buffer is
148 * unaccounted (released to LRU) before that occurs. Drop in-flight
149 * status now to preserve accounting consistency.
150 */
151 xfs_buf_ioacct_dec(bp);
152
Dave Chinnera4082352013-08-28 10:18:06 +1000153 spin_lock(&bp->b_lock);
154 atomic_set(&bp->b_lru_ref, 0);
155 if (!(bp->b_state & XFS_BSTATE_DISPOSE) &&
Dave Chinnere80dfa12013-08-28 10:18:05 +1000156 (list_lru_del(&bp->b_target->bt_lru, &bp->b_lru)))
157 atomic_dec(&bp->b_hold);
Dave Chinner430cbeb2010-12-02 16:30:55 +1100158
Dave Chinner430cbeb2010-12-02 16:30:55 +1100159 ASSERT(atomic_read(&bp->b_hold) >= 1);
Dave Chinnera4082352013-08-28 10:18:06 +1000160 spin_unlock(&bp->b_lock);
Dave Chinner430cbeb2010-12-02 16:30:55 +1100161}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162
Dave Chinner3e85c862012-06-22 18:50:09 +1000163static int
164xfs_buf_get_maps(
165 struct xfs_buf *bp,
166 int map_count)
167{
168 ASSERT(bp->b_maps == NULL);
169 bp->b_map_count = map_count;
170
171 if (map_count == 1) {
Mark Tinguelyf4b42422012-12-04 17:18:02 -0600172 bp->b_maps = &bp->__b_map;
Dave Chinner3e85c862012-06-22 18:50:09 +1000173 return 0;
174 }
175
176 bp->b_maps = kmem_zalloc(map_count * sizeof(struct xfs_buf_map),
177 KM_NOFS);
178 if (!bp->b_maps)
Dave Chinner24513372014-06-25 14:58:08 +1000179 return -ENOMEM;
Dave Chinner3e85c862012-06-22 18:50:09 +1000180 return 0;
181}
182
183/*
184 * Frees b_pages if it was allocated.
185 */
186static void
187xfs_buf_free_maps(
188 struct xfs_buf *bp)
189{
Mark Tinguelyf4b42422012-12-04 17:18:02 -0600190 if (bp->b_maps != &bp->__b_map) {
Dave Chinner3e85c862012-06-22 18:50:09 +1000191 kmem_free(bp->b_maps);
192 bp->b_maps = NULL;
193 }
194}
195
Christoph Hellwig4347b9d2011-10-10 16:52:48 +0000196struct xfs_buf *
Dave Chinner3e85c862012-06-22 18:50:09 +1000197_xfs_buf_alloc(
Christoph Hellwig4347b9d2011-10-10 16:52:48 +0000198 struct xfs_buftarg *target,
Dave Chinner3e85c862012-06-22 18:50:09 +1000199 struct xfs_buf_map *map,
200 int nmaps,
Nathan Scottce8e9222006-01-11 15:39:08 +1100201 xfs_buf_flags_t flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202{
Christoph Hellwig4347b9d2011-10-10 16:52:48 +0000203 struct xfs_buf *bp;
Dave Chinner3e85c862012-06-22 18:50:09 +1000204 int error;
205 int i;
Christoph Hellwig4347b9d2011-10-10 16:52:48 +0000206
Dave Chinneraa5c1582012-04-23 15:58:56 +1000207 bp = kmem_zone_zalloc(xfs_buf_zone, KM_NOFS);
Christoph Hellwig4347b9d2011-10-10 16:52:48 +0000208 if (unlikely(!bp))
209 return NULL;
210
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 /*
Dave Chinner12bcb3f2012-04-23 15:59:05 +1000212 * We don't want certain flags to appear in b_flags unless they are
213 * specifically set by later operations on the buffer.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 */
Dave Chinner611c9942012-04-23 15:59:07 +1000215 flags &= ~(XBF_UNMAPPED | XBF_TRYLOCK | XBF_ASYNC | XBF_READ_AHEAD);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216
Nathan Scottce8e9222006-01-11 15:39:08 +1100217 atomic_set(&bp->b_hold, 1);
Dave Chinner430cbeb2010-12-02 16:30:55 +1100218 atomic_set(&bp->b_lru_ref, 1);
David Chinnerb4dd3302008-08-13 16:36:11 +1000219 init_completion(&bp->b_iowait);
Dave Chinner430cbeb2010-12-02 16:30:55 +1100220 INIT_LIST_HEAD(&bp->b_lru);
Nathan Scottce8e9222006-01-11 15:39:08 +1100221 INIT_LIST_HEAD(&bp->b_list);
Dave Chinner74f75a02010-09-24 19:59:04 +1000222 RB_CLEAR_NODE(&bp->b_rbnode);
Thomas Gleixnera731cd12010-09-07 14:33:15 +0000223 sema_init(&bp->b_sema, 0); /* held, no waiters */
Dave Chinnera4082352013-08-28 10:18:06 +1000224 spin_lock_init(&bp->b_lock);
Nathan Scottce8e9222006-01-11 15:39:08 +1100225 XB_SET_OWNER(bp);
226 bp->b_target = target;
Dave Chinner3e85c862012-06-22 18:50:09 +1000227 bp->b_flags = flags;
Dave Chinnerde1cbee2012-04-23 15:58:50 +1000228
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 /*
Dave Chinneraa0e8832012-04-23 15:58:52 +1000230 * Set length and io_length to the same value initially.
231 * I/O routines should use io_length, which will be the same in
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 * most cases but may be reset (e.g. XFS recovery).
233 */
Dave Chinner3e85c862012-06-22 18:50:09 +1000234 error = xfs_buf_get_maps(bp, nmaps);
235 if (error) {
236 kmem_zone_free(xfs_buf_zone, bp);
237 return NULL;
238 }
239
240 bp->b_bn = map[0].bm_bn;
241 bp->b_length = 0;
242 for (i = 0; i < nmaps; i++) {
243 bp->b_maps[i].bm_bn = map[i].bm_bn;
244 bp->b_maps[i].bm_len = map[i].bm_len;
245 bp->b_length += map[i].bm_len;
246 }
247 bp->b_io_length = bp->b_length;
248
Nathan Scottce8e9222006-01-11 15:39:08 +1100249 atomic_set(&bp->b_pin_count, 0);
250 init_waitqueue_head(&bp->b_waiters);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251
Bill O'Donnellff6d6af2015-10-12 18:21:22 +1100252 XFS_STATS_INC(target->bt_mount, xb_create);
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000253 trace_xfs_buf_init(bp, _RET_IP_);
Christoph Hellwig4347b9d2011-10-10 16:52:48 +0000254
255 return bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256}
257
258/*
Nathan Scottce8e9222006-01-11 15:39:08 +1100259 * Allocate a page array capable of holding a specified number
260 * of pages, and point the page buf at it.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 */
262STATIC int
Nathan Scottce8e9222006-01-11 15:39:08 +1100263_xfs_buf_get_pages(
264 xfs_buf_t *bp,
Eric Sandeen87937bf2014-04-14 19:01:20 +1000265 int page_count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266{
267 /* Make sure that we have a page list */
Nathan Scottce8e9222006-01-11 15:39:08 +1100268 if (bp->b_pages == NULL) {
Nathan Scottce8e9222006-01-11 15:39:08 +1100269 bp->b_page_count = page_count;
270 if (page_count <= XB_PAGES) {
271 bp->b_pages = bp->b_page_array;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 } else {
Nathan Scottce8e9222006-01-11 15:39:08 +1100273 bp->b_pages = kmem_alloc(sizeof(struct page *) *
Dave Chinneraa5c1582012-04-23 15:58:56 +1000274 page_count, KM_NOFS);
Nathan Scottce8e9222006-01-11 15:39:08 +1100275 if (bp->b_pages == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 return -ENOMEM;
277 }
Nathan Scottce8e9222006-01-11 15:39:08 +1100278 memset(bp->b_pages, 0, sizeof(struct page *) * page_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 }
280 return 0;
281}
282
283/*
Nathan Scottce8e9222006-01-11 15:39:08 +1100284 * Frees b_pages if it was allocated.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 */
286STATIC void
Nathan Scottce8e9222006-01-11 15:39:08 +1100287_xfs_buf_free_pages(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 xfs_buf_t *bp)
289{
Nathan Scottce8e9222006-01-11 15:39:08 +1100290 if (bp->b_pages != bp->b_page_array) {
Denys Vlasenkof0e2d932008-05-19 16:31:57 +1000291 kmem_free(bp->b_pages);
Dave Chinner3fc98b12009-12-14 23:11:57 +0000292 bp->b_pages = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 }
294}
295
296/*
297 * Releases the specified buffer.
298 *
299 * The modification state of any associated pages is left unchanged.
Zhi Yong Wub46fe822013-08-07 10:10:59 +0000300 * The buffer must not be on any hash - use xfs_buf_rele instead for
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 * hashed and refcounted buffers
302 */
303void
Nathan Scottce8e9222006-01-11 15:39:08 +1100304xfs_buf_free(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 xfs_buf_t *bp)
306{
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000307 trace_xfs_buf_free(bp, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308
Dave Chinner430cbeb2010-12-02 16:30:55 +1100309 ASSERT(list_empty(&bp->b_lru));
310
Dave Chinner0e6e8472011-03-26 09:16:45 +1100311 if (bp->b_flags & _XBF_PAGES) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 uint i;
313
James Bottomley73c77e22010-01-25 11:42:24 -0600314 if (xfs_buf_is_vmapped(bp))
Alex Elder8a262e52010-03-16 18:55:56 +0000315 vm_unmap_ram(bp->b_addr - bp->b_offset,
316 bp->b_page_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317
Nathan Scott948ecdb2006-09-28 11:03:13 +1000318 for (i = 0; i < bp->b_page_count; i++) {
319 struct page *page = bp->b_pages[i];
320
Dave Chinner0e6e8472011-03-26 09:16:45 +1100321 __free_page(page);
Nathan Scott948ecdb2006-09-28 11:03:13 +1000322 }
Dave Chinner0e6e8472011-03-26 09:16:45 +1100323 } else if (bp->b_flags & _XBF_KMEM)
324 kmem_free(bp->b_addr);
Dave Chinner3fc98b12009-12-14 23:11:57 +0000325 _xfs_buf_free_pages(bp);
Dave Chinner3e85c862012-06-22 18:50:09 +1000326 xfs_buf_free_maps(bp);
Christoph Hellwig4347b9d2011-10-10 16:52:48 +0000327 kmem_zone_free(xfs_buf_zone, bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328}
329
330/*
Dave Chinner0e6e8472011-03-26 09:16:45 +1100331 * Allocates all the pages for buffer in question and builds it's page list.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 */
333STATIC int
Dave Chinner0e6e8472011-03-26 09:16:45 +1100334xfs_buf_allocate_memory(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 xfs_buf_t *bp,
336 uint flags)
337{
Dave Chinneraa0e8832012-04-23 15:58:52 +1000338 size_t size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 size_t nbytes, offset;
Nathan Scottce8e9222006-01-11 15:39:08 +1100340 gfp_t gfp_mask = xb_to_gfp(flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 unsigned short page_count, i;
Dave Chinner795cac72012-04-23 15:58:53 +1000342 xfs_off_t start, end;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 int error;
344
Dave Chinner0e6e8472011-03-26 09:16:45 +1100345 /*
346 * for buffers that are contained within a single page, just allocate
347 * the memory from the heap - there's no need for the complexity of
348 * page arrays to keep allocation down to order 0.
349 */
Dave Chinner795cac72012-04-23 15:58:53 +1000350 size = BBTOB(bp->b_length);
351 if (size < PAGE_SIZE) {
Dave Chinneraa5c1582012-04-23 15:58:56 +1000352 bp->b_addr = kmem_alloc(size, KM_NOFS);
Dave Chinner0e6e8472011-03-26 09:16:45 +1100353 if (!bp->b_addr) {
354 /* low memory - use alloc_page loop instead */
355 goto use_alloc_page;
356 }
357
Dave Chinner795cac72012-04-23 15:58:53 +1000358 if (((unsigned long)(bp->b_addr + size - 1) & PAGE_MASK) !=
Dave Chinner0e6e8472011-03-26 09:16:45 +1100359 ((unsigned long)bp->b_addr & PAGE_MASK)) {
360 /* b_addr spans two pages - use alloc_page instead */
361 kmem_free(bp->b_addr);
362 bp->b_addr = NULL;
363 goto use_alloc_page;
364 }
365 bp->b_offset = offset_in_page(bp->b_addr);
366 bp->b_pages = bp->b_page_array;
367 bp->b_pages[0] = virt_to_page(bp->b_addr);
368 bp->b_page_count = 1;
Dave Chinner611c9942012-04-23 15:59:07 +1000369 bp->b_flags |= _XBF_KMEM;
Dave Chinner0e6e8472011-03-26 09:16:45 +1100370 return 0;
371 }
372
373use_alloc_page:
Mark Tinguelyf4b42422012-12-04 17:18:02 -0600374 start = BBTOB(bp->b_maps[0].bm_bn) >> PAGE_SHIFT;
375 end = (BBTOB(bp->b_maps[0].bm_bn + bp->b_length) + PAGE_SIZE - 1)
Dave Chinnercbb7baab2012-06-22 18:50:08 +1000376 >> PAGE_SHIFT;
Dave Chinner795cac72012-04-23 15:58:53 +1000377 page_count = end - start;
Eric Sandeen87937bf2014-04-14 19:01:20 +1000378 error = _xfs_buf_get_pages(bp, page_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 if (unlikely(error))
380 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381
Nathan Scottce8e9222006-01-11 15:39:08 +1100382 offset = bp->b_offset;
Dave Chinner0e6e8472011-03-26 09:16:45 +1100383 bp->b_flags |= _XBF_PAGES;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384
Nathan Scottce8e9222006-01-11 15:39:08 +1100385 for (i = 0; i < bp->b_page_count; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 struct page *page;
387 uint retries = 0;
Dave Chinner0e6e8472011-03-26 09:16:45 +1100388retry:
389 page = alloc_page(gfp_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 if (unlikely(page == NULL)) {
Nathan Scottce8e9222006-01-11 15:39:08 +1100391 if (flags & XBF_READ_AHEAD) {
392 bp->b_page_count = i;
Dave Chinner24513372014-06-25 14:58:08 +1000393 error = -ENOMEM;
Dave Chinner0e6e8472011-03-26 09:16:45 +1100394 goto out_free_pages;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 }
396
397 /*
398 * This could deadlock.
399 *
400 * But until all the XFS lowlevel code is revamped to
401 * handle buffer allocation failures we can't do much.
402 */
403 if (!(++retries % 100))
Dave Chinner4f107002011-03-07 10:00:35 +1100404 xfs_err(NULL,
Tetsuo Handa5bf97b12015-10-12 15:41:29 +1100405 "%s(%u) possible memory allocation deadlock in %s (mode:0x%x)",
406 current->comm, current->pid,
Harvey Harrison34a622b2008-04-10 12:19:21 +1000407 __func__, gfp_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408
Bill O'Donnellff6d6af2015-10-12 18:21:22 +1100409 XFS_STATS_INC(bp->b_target->bt_mount, xb_page_retries);
Jens Axboe8aa7e842009-07-09 14:52:32 +0200410 congestion_wait(BLK_RW_ASYNC, HZ/50);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 goto retry;
412 }
413
Bill O'Donnellff6d6af2015-10-12 18:21:22 +1100414 XFS_STATS_INC(bp->b_target->bt_mount, xb_page_found);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415
Dave Chinner0e6e8472011-03-26 09:16:45 +1100416 nbytes = min_t(size_t, size, PAGE_SIZE - offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 size -= nbytes;
Nathan Scottce8e9222006-01-11 15:39:08 +1100418 bp->b_pages[i] = page;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 offset = 0;
420 }
Dave Chinner0e6e8472011-03-26 09:16:45 +1100421 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422
Dave Chinner0e6e8472011-03-26 09:16:45 +1100423out_free_pages:
424 for (i = 0; i < bp->b_page_count; i++)
425 __free_page(bp->b_pages[i]);
Darrick J. Wong5d44dd52017-02-02 08:56:10 +0100426 bp->b_flags &= ~_XBF_PAGES;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 return error;
428}
429
430/*
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300431 * Map buffer into kernel address-space if necessary.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 */
433STATIC int
Nathan Scottce8e9222006-01-11 15:39:08 +1100434_xfs_buf_map_pages(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 xfs_buf_t *bp,
436 uint flags)
437{
Dave Chinner0e6e8472011-03-26 09:16:45 +1100438 ASSERT(bp->b_flags & _XBF_PAGES);
Nathan Scottce8e9222006-01-11 15:39:08 +1100439 if (bp->b_page_count == 1) {
Dave Chinner0e6e8472011-03-26 09:16:45 +1100440 /* A single page buffer is always mappable */
Nathan Scottce8e9222006-01-11 15:39:08 +1100441 bp->b_addr = page_address(bp->b_pages[0]) + bp->b_offset;
Dave Chinner611c9942012-04-23 15:59:07 +1000442 } else if (flags & XBF_UNMAPPED) {
443 bp->b_addr = NULL;
444 } else {
Dave Chinnera19fb382011-03-26 09:13:42 +1100445 int retried = 0;
Dave Chinnerae687e52014-03-07 16:19:14 +1100446 unsigned noio_flag;
Dave Chinnera19fb382011-03-26 09:13:42 +1100447
Dave Chinnerae687e52014-03-07 16:19:14 +1100448 /*
449 * vm_map_ram() will allocate auxillary structures (e.g.
450 * pagetables) with GFP_KERNEL, yet we are likely to be under
451 * GFP_NOFS context here. Hence we need to tell memory reclaim
452 * that we are in such a context via PF_MEMALLOC_NOIO to prevent
453 * memory reclaim re-entering the filesystem here and
454 * potentially deadlocking.
455 */
456 noio_flag = memalloc_noio_save();
Dave Chinnera19fb382011-03-26 09:13:42 +1100457 do {
458 bp->b_addr = vm_map_ram(bp->b_pages, bp->b_page_count,
459 -1, PAGE_KERNEL);
460 if (bp->b_addr)
461 break;
462 vm_unmap_aliases();
463 } while (retried++ <= 1);
Dave Chinnerae687e52014-03-07 16:19:14 +1100464 memalloc_noio_restore(noio_flag);
Dave Chinnera19fb382011-03-26 09:13:42 +1100465
466 if (!bp->b_addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 return -ENOMEM;
Nathan Scottce8e9222006-01-11 15:39:08 +1100468 bp->b_addr += bp->b_offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 }
470
471 return 0;
472}
473
474/*
475 * Finding and Reading Buffers
476 */
477
478/*
Nathan Scottce8e9222006-01-11 15:39:08 +1100479 * Look up, and creates if absent, a lockable buffer for
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 * a given range of an inode. The buffer is returned
Chandra Seetharamaneabbaf12011-09-08 20:18:50 +0000481 * locked. No I/O is implied by this call.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 */
483xfs_buf_t *
Nathan Scottce8e9222006-01-11 15:39:08 +1100484_xfs_buf_find(
Dave Chinnere70b73f2012-04-23 15:58:49 +1000485 struct xfs_buftarg *btp,
Dave Chinner3e85c862012-06-22 18:50:09 +1000486 struct xfs_buf_map *map,
487 int nmaps,
Nathan Scottce8e9222006-01-11 15:39:08 +1100488 xfs_buf_flags_t flags,
489 xfs_buf_t *new_bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490{
Dave Chinner74f75a02010-09-24 19:59:04 +1000491 struct xfs_perag *pag;
492 struct rb_node **rbp;
493 struct rb_node *parent;
494 xfs_buf_t *bp;
Dave Chinner3e85c862012-06-22 18:50:09 +1000495 xfs_daddr_t blkno = map[0].bm_bn;
Dave Chinner10616b82013-01-21 23:53:52 +1100496 xfs_daddr_t eofs;
Dave Chinner3e85c862012-06-22 18:50:09 +1000497 int numblks = 0;
498 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499
Dave Chinner3e85c862012-06-22 18:50:09 +1000500 for (i = 0; i < nmaps; i++)
501 numblks += map[i].bm_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502
503 /* Check for IOs smaller than the sector size / not sector aligned */
Dave Chinnerf79af0b2015-08-25 10:05:13 +1000504 ASSERT(!(BBTOB(numblks) < btp->bt_meta_sectorsize));
Eric Sandeen6da54172014-01-21 16:45:52 -0600505 ASSERT(!(BBTOB(blkno) & (xfs_off_t)btp->bt_meta_sectormask));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506
Dave Chinner10616b82013-01-21 23:53:52 +1100507 /*
508 * Corrupted block numbers can get through to here, unfortunately, so we
509 * have to check that the buffer falls within the filesystem bounds.
510 */
511 eofs = XFS_FSB_TO_BB(btp->bt_mount, btp->bt_mount->m_sb.sb_dblocks);
Eric Sandeendb52d092014-11-28 14:03:55 +1100512 if (blkno < 0 || blkno >= eofs) {
Dave Chinner10616b82013-01-21 23:53:52 +1100513 /*
Dave Chinner24513372014-06-25 14:58:08 +1000514 * XXX (dgc): we should really be returning -EFSCORRUPTED here,
Dave Chinner10616b82013-01-21 23:53:52 +1100515 * but none of the higher level infrastructure supports
516 * returning a specific error on buffer lookup failures.
517 */
518 xfs_alert(btp->bt_mount,
519 "%s: Block out of range: block 0x%llx, EOFS 0x%llx ",
520 __func__, blkno, eofs);
Dave Chinner7bc0dc22013-05-21 18:02:08 +1000521 WARN_ON(1);
Dave Chinner10616b82013-01-21 23:53:52 +1100522 return NULL;
523 }
524
Dave Chinner74f75a02010-09-24 19:59:04 +1000525 /* get tree root */
526 pag = xfs_perag_get(btp->bt_mount,
Dave Chinnere70b73f2012-04-23 15:58:49 +1000527 xfs_daddr_to_agno(btp->bt_mount, blkno));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528
Dave Chinner74f75a02010-09-24 19:59:04 +1000529 /* walk tree */
530 spin_lock(&pag->pag_buf_lock);
531 rbp = &pag->pag_buf_tree.rb_node;
532 parent = NULL;
533 bp = NULL;
534 while (*rbp) {
535 parent = *rbp;
536 bp = rb_entry(parent, struct xfs_buf, b_rbnode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537
Dave Chinnerde1cbee2012-04-23 15:58:50 +1000538 if (blkno < bp->b_bn)
Dave Chinner74f75a02010-09-24 19:59:04 +1000539 rbp = &(*rbp)->rb_left;
Dave Chinnerde1cbee2012-04-23 15:58:50 +1000540 else if (blkno > bp->b_bn)
Dave Chinner74f75a02010-09-24 19:59:04 +1000541 rbp = &(*rbp)->rb_right;
542 else {
543 /*
Dave Chinnerde1cbee2012-04-23 15:58:50 +1000544 * found a block number match. If the range doesn't
Dave Chinner74f75a02010-09-24 19:59:04 +1000545 * match, the only way this is allowed is if the buffer
546 * in the cache is stale and the transaction that made
547 * it stale has not yet committed. i.e. we are
548 * reallocating a busy extent. Skip this buffer and
549 * continue searching to the right for an exact match.
550 */
Dave Chinner4e94b712012-04-23 15:58:51 +1000551 if (bp->b_length != numblks) {
Dave Chinner74f75a02010-09-24 19:59:04 +1000552 ASSERT(bp->b_flags & XBF_STALE);
553 rbp = &(*rbp)->rb_right;
554 continue;
555 }
Nathan Scottce8e9222006-01-11 15:39:08 +1100556 atomic_inc(&bp->b_hold);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 goto found;
558 }
559 }
560
561 /* No match found */
Nathan Scottce8e9222006-01-11 15:39:08 +1100562 if (new_bp) {
Dave Chinner74f75a02010-09-24 19:59:04 +1000563 rb_link_node(&new_bp->b_rbnode, parent, rbp);
564 rb_insert_color(&new_bp->b_rbnode, &pag->pag_buf_tree);
565 /* the buffer keeps the perag reference until it is freed */
566 new_bp->b_pag = pag;
567 spin_unlock(&pag->pag_buf_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568 } else {
Bill O'Donnellff6d6af2015-10-12 18:21:22 +1100569 XFS_STATS_INC(btp->bt_mount, xb_miss_locked);
Dave Chinner74f75a02010-09-24 19:59:04 +1000570 spin_unlock(&pag->pag_buf_lock);
571 xfs_perag_put(pag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 }
Nathan Scottce8e9222006-01-11 15:39:08 +1100573 return new_bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574
575found:
Dave Chinner74f75a02010-09-24 19:59:04 +1000576 spin_unlock(&pag->pag_buf_lock);
577 xfs_perag_put(pag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578
Christoph Hellwig0c842ad2011-07-08 14:36:19 +0200579 if (!xfs_buf_trylock(bp)) {
580 if (flags & XBF_TRYLOCK) {
Nathan Scottce8e9222006-01-11 15:39:08 +1100581 xfs_buf_rele(bp);
Bill O'Donnellff6d6af2015-10-12 18:21:22 +1100582 XFS_STATS_INC(btp->bt_mount, xb_busy_locked);
Nathan Scottce8e9222006-01-11 15:39:08 +1100583 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 }
Christoph Hellwig0c842ad2011-07-08 14:36:19 +0200585 xfs_buf_lock(bp);
Bill O'Donnellff6d6af2015-10-12 18:21:22 +1100586 XFS_STATS_INC(btp->bt_mount, xb_get_locked_waited);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 }
588
Dave Chinner0e6e8472011-03-26 09:16:45 +1100589 /*
590 * if the buffer is stale, clear all the external state associated with
591 * it. We need to keep flags such as how we allocated the buffer memory
592 * intact here.
593 */
Nathan Scottce8e9222006-01-11 15:39:08 +1100594 if (bp->b_flags & XBF_STALE) {
595 ASSERT((bp->b_flags & _XBF_DELWRI_Q) == 0);
Dave Chinnercfb02852012-11-12 22:54:19 +1100596 ASSERT(bp->b_iodone == NULL);
Dave Chinner611c9942012-04-23 15:59:07 +1000597 bp->b_flags &= _XBF_KMEM | _XBF_PAGES;
Dave Chinner1813dd62012-11-14 17:54:40 +1100598 bp->b_ops = NULL;
David Chinner2f926582005-09-05 08:33:35 +1000599 }
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000600
601 trace_xfs_buf_find(bp, flags, _RET_IP_);
Bill O'Donnellff6d6af2015-10-12 18:21:22 +1100602 XFS_STATS_INC(btp->bt_mount, xb_get_locked);
Nathan Scottce8e9222006-01-11 15:39:08 +1100603 return bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604}
605
606/*
Dave Chinner38158322011-09-30 04:45:02 +0000607 * Assembles a buffer covering the specified range. The code is optimised for
608 * cache hits, as metadata intensive workloads will see 3 orders of magnitude
609 * more hits than misses.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 */
Dave Chinner38158322011-09-30 04:45:02 +0000611struct xfs_buf *
Dave Chinner6dde2702012-06-22 18:50:10 +1000612xfs_buf_get_map(
613 struct xfs_buftarg *target,
614 struct xfs_buf_map *map,
615 int nmaps,
Nathan Scottce8e9222006-01-11 15:39:08 +1100616 xfs_buf_flags_t flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617{
Dave Chinner38158322011-09-30 04:45:02 +0000618 struct xfs_buf *bp;
619 struct xfs_buf *new_bp;
Dave Chinner0e6e8472011-03-26 09:16:45 +1100620 int error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621
Dave Chinner6dde2702012-06-22 18:50:10 +1000622 bp = _xfs_buf_find(target, map, nmaps, flags, NULL);
Dave Chinner38158322011-09-30 04:45:02 +0000623 if (likely(bp))
624 goto found;
625
Dave Chinner6dde2702012-06-22 18:50:10 +1000626 new_bp = _xfs_buf_alloc(target, map, nmaps, flags);
Nathan Scottce8e9222006-01-11 15:39:08 +1100627 if (unlikely(!new_bp))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 return NULL;
629
Dave Chinnerfe2429b2012-04-23 15:58:45 +1000630 error = xfs_buf_allocate_memory(new_bp, flags);
631 if (error) {
Dave Chinner3e85c862012-06-22 18:50:09 +1000632 xfs_buf_free(new_bp);
Dave Chinner38158322011-09-30 04:45:02 +0000633 return NULL;
634 }
635
Dave Chinner6dde2702012-06-22 18:50:10 +1000636 bp = _xfs_buf_find(target, map, nmaps, flags, new_bp);
Dave Chinnerfe2429b2012-04-23 15:58:45 +1000637 if (!bp) {
638 xfs_buf_free(new_bp);
639 return NULL;
640 }
641
642 if (bp != new_bp)
643 xfs_buf_free(new_bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644
Dave Chinner38158322011-09-30 04:45:02 +0000645found:
Dave Chinner611c9942012-04-23 15:59:07 +1000646 if (!bp->b_addr) {
Nathan Scottce8e9222006-01-11 15:39:08 +1100647 error = _xfs_buf_map_pages(bp, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 if (unlikely(error)) {
Dave Chinner4f107002011-03-07 10:00:35 +1100649 xfs_warn(target->bt_mount,
Eric Sandeen08e96e12013-10-11 20:59:05 -0500650 "%s: failed to map pagesn", __func__);
Dave Chinnera8acad72012-04-23 15:58:54 +1000651 xfs_buf_relse(bp);
652 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 }
654 }
655
Dave Chinnerb79f4a12016-01-12 07:03:44 +1100656 /*
657 * Clear b_error if this is a lookup from a caller that doesn't expect
658 * valid data to be found in the buffer.
659 */
660 if (!(flags & XBF_READ))
661 xfs_buf_ioerror(bp, 0);
662
Bill O'Donnellff6d6af2015-10-12 18:21:22 +1100663 XFS_STATS_INC(target->bt_mount, xb_get);
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000664 trace_xfs_buf_get(bp, flags, _RET_IP_);
Nathan Scottce8e9222006-01-11 15:39:08 +1100665 return bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666}
667
Christoph Hellwig5d765b92008-12-03 12:20:26 +0100668STATIC int
669_xfs_buf_read(
670 xfs_buf_t *bp,
671 xfs_buf_flags_t flags)
672{
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000673 ASSERT(!(flags & XBF_WRITE));
Mark Tinguelyf4b42422012-12-04 17:18:02 -0600674 ASSERT(bp->b_maps[0].bm_bn != XFS_BUF_DADDR_NULL);
Christoph Hellwig5d765b92008-12-03 12:20:26 +0100675
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000676 bp->b_flags &= ~(XBF_WRITE | XBF_ASYNC | XBF_READ_AHEAD);
Christoph Hellwig1d5ae5d2011-07-08 14:36:32 +0200677 bp->b_flags |= flags & (XBF_READ | XBF_ASYNC | XBF_READ_AHEAD);
Christoph Hellwig5d765b92008-12-03 12:20:26 +0100678
Dave Chinner595bff72014-10-02 09:05:14 +1000679 if (flags & XBF_ASYNC) {
680 xfs_buf_submit(bp);
Dave Chinner0e95f192012-04-23 15:58:46 +1000681 return 0;
Dave Chinner595bff72014-10-02 09:05:14 +1000682 }
683 return xfs_buf_submit_wait(bp);
Christoph Hellwig5d765b92008-12-03 12:20:26 +0100684}
685
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686xfs_buf_t *
Dave Chinner6dde2702012-06-22 18:50:10 +1000687xfs_buf_read_map(
688 struct xfs_buftarg *target,
689 struct xfs_buf_map *map,
690 int nmaps,
Dave Chinnerc3f8fc72012-11-12 22:54:01 +1100691 xfs_buf_flags_t flags,
Dave Chinner1813dd62012-11-14 17:54:40 +1100692 const struct xfs_buf_ops *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693{
Dave Chinner6dde2702012-06-22 18:50:10 +1000694 struct xfs_buf *bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695
Nathan Scottce8e9222006-01-11 15:39:08 +1100696 flags |= XBF_READ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697
Dave Chinner6dde2702012-06-22 18:50:10 +1000698 bp = xfs_buf_get_map(target, map, nmaps, flags);
Nathan Scottce8e9222006-01-11 15:39:08 +1100699 if (bp) {
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000700 trace_xfs_buf_read(bp, flags, _RET_IP_);
701
Dave Chinnerb0388bf2016-02-10 15:01:11 +1100702 if (!(bp->b_flags & XBF_DONE)) {
Bill O'Donnellff6d6af2015-10-12 18:21:22 +1100703 XFS_STATS_INC(target->bt_mount, xb_get_read);
Dave Chinner1813dd62012-11-14 17:54:40 +1100704 bp->b_ops = ops;
Christoph Hellwig5d765b92008-12-03 12:20:26 +0100705 _xfs_buf_read(bp, flags);
Nathan Scottce8e9222006-01-11 15:39:08 +1100706 } else if (flags & XBF_ASYNC) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 /*
708 * Read ahead call which is already satisfied,
709 * drop the buffer
710 */
Dave Chinnera8acad72012-04-23 15:58:54 +1000711 xfs_buf_relse(bp);
712 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714 /* We do not want read in the flags */
Nathan Scottce8e9222006-01-11 15:39:08 +1100715 bp->b_flags &= ~XBF_READ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 }
717 }
718
Nathan Scottce8e9222006-01-11 15:39:08 +1100719 return bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720}
721
722/*
Nathan Scottce8e9222006-01-11 15:39:08 +1100723 * If we are not low on memory then do the readahead in a deadlock
724 * safe manner.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 */
726void
Dave Chinner6dde2702012-06-22 18:50:10 +1000727xfs_buf_readahead_map(
728 struct xfs_buftarg *target,
729 struct xfs_buf_map *map,
Dave Chinnerc3f8fc72012-11-12 22:54:01 +1100730 int nmaps,
Dave Chinner1813dd62012-11-14 17:54:40 +1100731 const struct xfs_buf_ops *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732{
Dave Chinner0e6e8472011-03-26 09:16:45 +1100733 if (bdi_read_congested(target->bt_bdi))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 return;
735
Dave Chinner6dde2702012-06-22 18:50:10 +1000736 xfs_buf_read_map(target, map, nmaps,
Dave Chinner1813dd62012-11-14 17:54:40 +1100737 XBF_TRYLOCK|XBF_ASYNC|XBF_READ_AHEAD, ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738}
739
Dave Chinner5adc94c2010-09-24 21:58:31 +1000740/*
741 * Read an uncached buffer from disk. Allocates and returns a locked
742 * buffer containing the disk contents or nothing.
743 */
Dave Chinnerba372672014-10-02 09:05:32 +1000744int
Dave Chinner5adc94c2010-09-24 21:58:31 +1000745xfs_buf_read_uncached(
Dave Chinner5adc94c2010-09-24 21:58:31 +1000746 struct xfs_buftarg *target,
747 xfs_daddr_t daddr,
Dave Chinnere70b73f2012-04-23 15:58:49 +1000748 size_t numblks,
Dave Chinnerc3f8fc72012-11-12 22:54:01 +1100749 int flags,
Dave Chinnerba372672014-10-02 09:05:32 +1000750 struct xfs_buf **bpp,
Dave Chinner1813dd62012-11-14 17:54:40 +1100751 const struct xfs_buf_ops *ops)
Dave Chinner5adc94c2010-09-24 21:58:31 +1000752{
Dave Chinnereab4e632012-11-12 22:54:02 +1100753 struct xfs_buf *bp;
Dave Chinner5adc94c2010-09-24 21:58:31 +1000754
Dave Chinnerba372672014-10-02 09:05:32 +1000755 *bpp = NULL;
756
Dave Chinnere70b73f2012-04-23 15:58:49 +1000757 bp = xfs_buf_get_uncached(target, numblks, flags);
Dave Chinner5adc94c2010-09-24 21:58:31 +1000758 if (!bp)
Dave Chinnerba372672014-10-02 09:05:32 +1000759 return -ENOMEM;
Dave Chinner5adc94c2010-09-24 21:58:31 +1000760
761 /* set up the buffer for a read IO */
Dave Chinner3e85c862012-06-22 18:50:09 +1000762 ASSERT(bp->b_map_count == 1);
Dave Chinnerba372672014-10-02 09:05:32 +1000763 bp->b_bn = XFS_BUF_DADDR_NULL; /* always null for uncached buffers */
Dave Chinner3e85c862012-06-22 18:50:09 +1000764 bp->b_maps[0].bm_bn = daddr;
Dave Chinnercbb7baab2012-06-22 18:50:08 +1000765 bp->b_flags |= XBF_READ;
Dave Chinner1813dd62012-11-14 17:54:40 +1100766 bp->b_ops = ops;
Dave Chinner5adc94c2010-09-24 21:58:31 +1000767
Dave Chinner595bff72014-10-02 09:05:14 +1000768 xfs_buf_submit_wait(bp);
Dave Chinnerba372672014-10-02 09:05:32 +1000769 if (bp->b_error) {
770 int error = bp->b_error;
Christoph Hellwig83a0adc2013-12-17 00:03:52 -0800771 xfs_buf_relse(bp);
Dave Chinnerba372672014-10-02 09:05:32 +1000772 return error;
Christoph Hellwig83a0adc2013-12-17 00:03:52 -0800773 }
Dave Chinnerba372672014-10-02 09:05:32 +1000774
775 *bpp = bp;
776 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777}
778
Dave Chinner44396472011-04-21 09:34:27 +0000779/*
780 * Return a buffer allocated as an empty buffer and associated to external
781 * memory via xfs_buf_associate_memory() back to it's empty state.
782 */
783void
784xfs_buf_set_empty(
785 struct xfs_buf *bp,
Dave Chinnere70b73f2012-04-23 15:58:49 +1000786 size_t numblks)
Dave Chinner44396472011-04-21 09:34:27 +0000787{
788 if (bp->b_pages)
789 _xfs_buf_free_pages(bp);
790
791 bp->b_pages = NULL;
792 bp->b_page_count = 0;
793 bp->b_addr = NULL;
Dave Chinner4e94b712012-04-23 15:58:51 +1000794 bp->b_length = numblks;
Dave Chinneraa0e8832012-04-23 15:58:52 +1000795 bp->b_io_length = numblks;
Dave Chinner3e85c862012-06-22 18:50:09 +1000796
797 ASSERT(bp->b_map_count == 1);
Dave Chinner44396472011-04-21 09:34:27 +0000798 bp->b_bn = XFS_BUF_DADDR_NULL;
Dave Chinner3e85c862012-06-22 18:50:09 +1000799 bp->b_maps[0].bm_bn = XFS_BUF_DADDR_NULL;
800 bp->b_maps[0].bm_len = bp->b_length;
Dave Chinner44396472011-04-21 09:34:27 +0000801}
802
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803static inline struct page *
804mem_to_page(
805 void *addr)
806{
Christoph Lameter9e2779f2008-02-04 22:28:34 -0800807 if ((!is_vmalloc_addr(addr))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 return virt_to_page(addr);
809 } else {
810 return vmalloc_to_page(addr);
811 }
812}
813
814int
Nathan Scottce8e9222006-01-11 15:39:08 +1100815xfs_buf_associate_memory(
816 xfs_buf_t *bp,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817 void *mem,
818 size_t len)
819{
820 int rval;
821 int i = 0;
Lachlan McIlroyd1afb672007-11-27 17:01:24 +1100822 unsigned long pageaddr;
823 unsigned long offset;
824 size_t buflen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825 int page_count;
826
Dave Chinner0e6e8472011-03-26 09:16:45 +1100827 pageaddr = (unsigned long)mem & PAGE_MASK;
Lachlan McIlroyd1afb672007-11-27 17:01:24 +1100828 offset = (unsigned long)mem - pageaddr;
Dave Chinner0e6e8472011-03-26 09:16:45 +1100829 buflen = PAGE_ALIGN(len + offset);
830 page_count = buflen >> PAGE_SHIFT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831
832 /* Free any previous set of page pointers */
Nathan Scottce8e9222006-01-11 15:39:08 +1100833 if (bp->b_pages)
834 _xfs_buf_free_pages(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835
Nathan Scottce8e9222006-01-11 15:39:08 +1100836 bp->b_pages = NULL;
837 bp->b_addr = mem;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838
Eric Sandeen87937bf2014-04-14 19:01:20 +1000839 rval = _xfs_buf_get_pages(bp, page_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 if (rval)
841 return rval;
842
Nathan Scottce8e9222006-01-11 15:39:08 +1100843 bp->b_offset = offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844
Lachlan McIlroyd1afb672007-11-27 17:01:24 +1100845 for (i = 0; i < bp->b_page_count; i++) {
846 bp->b_pages[i] = mem_to_page((void *)pageaddr);
Dave Chinner0e6e8472011-03-26 09:16:45 +1100847 pageaddr += PAGE_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849
Dave Chinneraa0e8832012-04-23 15:58:52 +1000850 bp->b_io_length = BTOBB(len);
Dave Chinner4e94b712012-04-23 15:58:51 +1000851 bp->b_length = BTOBB(buflen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852
853 return 0;
854}
855
856xfs_buf_t *
Dave Chinner686865f2010-09-24 20:07:47 +1000857xfs_buf_get_uncached(
858 struct xfs_buftarg *target,
Dave Chinnere70b73f2012-04-23 15:58:49 +1000859 size_t numblks,
Dave Chinner686865f2010-09-24 20:07:47 +1000860 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861{
Dave Chinnere70b73f2012-04-23 15:58:49 +1000862 unsigned long page_count;
Christoph Hellwig1fa40b02007-05-14 18:23:50 +1000863 int error, i;
Dave Chinner3e85c862012-06-22 18:50:09 +1000864 struct xfs_buf *bp;
865 DEFINE_SINGLE_BUF_MAP(map, XFS_BUF_DADDR_NULL, numblks);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866
Brian Fosterc891c302016-07-20 11:13:43 +1000867 /* flags might contain irrelevant bits, pass only what we care about */
868 bp = _xfs_buf_alloc(target, &map, 1, flags & XBF_NO_IOACCT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 if (unlikely(bp == NULL))
870 goto fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871
Dave Chinnere70b73f2012-04-23 15:58:49 +1000872 page_count = PAGE_ALIGN(numblks << BBSHIFT) >> PAGE_SHIFT;
Eric Sandeen87937bf2014-04-14 19:01:20 +1000873 error = _xfs_buf_get_pages(bp, page_count);
Christoph Hellwig1fa40b02007-05-14 18:23:50 +1000874 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 goto fail_free_buf;
876
Christoph Hellwig1fa40b02007-05-14 18:23:50 +1000877 for (i = 0; i < page_count; i++) {
Dave Chinner686865f2010-09-24 20:07:47 +1000878 bp->b_pages[i] = alloc_page(xb_to_gfp(flags));
Christoph Hellwig1fa40b02007-05-14 18:23:50 +1000879 if (!bp->b_pages[i])
880 goto fail_free_mem;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881 }
Christoph Hellwig1fa40b02007-05-14 18:23:50 +1000882 bp->b_flags |= _XBF_PAGES;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883
Dave Chinner611c9942012-04-23 15:59:07 +1000884 error = _xfs_buf_map_pages(bp, 0);
Christoph Hellwig1fa40b02007-05-14 18:23:50 +1000885 if (unlikely(error)) {
Dave Chinner4f107002011-03-07 10:00:35 +1100886 xfs_warn(target->bt_mount,
Eric Sandeen08e96e12013-10-11 20:59:05 -0500887 "%s: failed to map pages", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888 goto fail_free_mem;
Christoph Hellwig1fa40b02007-05-14 18:23:50 +1000889 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890
Dave Chinner686865f2010-09-24 20:07:47 +1000891 trace_xfs_buf_get_uncached(bp, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892 return bp;
Christoph Hellwig1fa40b02007-05-14 18:23:50 +1000893
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894 fail_free_mem:
Christoph Hellwig1fa40b02007-05-14 18:23:50 +1000895 while (--i >= 0)
896 __free_page(bp->b_pages[i]);
Christoph Hellwigca165b82007-05-24 15:21:11 +1000897 _xfs_buf_free_pages(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898 fail_free_buf:
Dave Chinner3e85c862012-06-22 18:50:09 +1000899 xfs_buf_free_maps(bp);
Christoph Hellwig4347b9d2011-10-10 16:52:48 +0000900 kmem_zone_free(xfs_buf_zone, bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901 fail:
902 return NULL;
903}
904
905/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906 * Increment reference count on buffer, to hold the buffer concurrently
907 * with another thread which may release (free) the buffer asynchronously.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 * Must hold the buffer already to call this function.
909 */
910void
Nathan Scottce8e9222006-01-11 15:39:08 +1100911xfs_buf_hold(
912 xfs_buf_t *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913{
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000914 trace_xfs_buf_hold(bp, _RET_IP_);
Nathan Scottce8e9222006-01-11 15:39:08 +1100915 atomic_inc(&bp->b_hold);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916}
917
918/*
Brian Foster9c7504a2016-07-20 11:15:28 +1000919 * Release a hold on the specified buffer. If the hold count is 1, the buffer is
920 * placed on LRU or freed (depending on b_lru_ref).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921 */
922void
Nathan Scottce8e9222006-01-11 15:39:08 +1100923xfs_buf_rele(
924 xfs_buf_t *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925{
Dave Chinner74f75a02010-09-24 19:59:04 +1000926 struct xfs_perag *pag = bp->b_pag;
Brian Foster9c7504a2016-07-20 11:15:28 +1000927 bool release;
928 bool freebuf = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000930 trace_xfs_buf_rele(bp, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931
Dave Chinner74f75a02010-09-24 19:59:04 +1000932 if (!pag) {
Dave Chinner430cbeb2010-12-02 16:30:55 +1100933 ASSERT(list_empty(&bp->b_lru));
Dave Chinner74f75a02010-09-24 19:59:04 +1000934 ASSERT(RB_EMPTY_NODE(&bp->b_rbnode));
Brian Foster9c7504a2016-07-20 11:15:28 +1000935 if (atomic_dec_and_test(&bp->b_hold)) {
936 xfs_buf_ioacct_dec(bp);
Nathan Scottfad3aa12006-02-01 12:14:52 +1100937 xfs_buf_free(bp);
Brian Foster9c7504a2016-07-20 11:15:28 +1000938 }
Nathan Scottfad3aa12006-02-01 12:14:52 +1100939 return;
940 }
941
Dave Chinner74f75a02010-09-24 19:59:04 +1000942 ASSERT(!RB_EMPTY_NODE(&bp->b_rbnode));
Dave Chinner430cbeb2010-12-02 16:30:55 +1100943
Lachlan McIlroy37906892008-08-13 15:42:10 +1000944 ASSERT(atomic_read(&bp->b_hold) > 0);
Dave Chinnera4082352013-08-28 10:18:06 +1000945
Brian Foster9c7504a2016-07-20 11:15:28 +1000946 release = atomic_dec_and_lock(&bp->b_hold, &pag->pag_buf_lock);
947 spin_lock(&bp->b_lock);
948 if (!release) {
949 /*
950 * Drop the in-flight state if the buffer is already on the LRU
951 * and it holds the only reference. This is racy because we
952 * haven't acquired the pag lock, but the use of _XBF_IN_FLIGHT
953 * ensures the decrement occurs only once per-buf.
954 */
955 if ((atomic_read(&bp->b_hold) == 1) && !list_empty(&bp->b_lru))
956 xfs_buf_ioacct_dec(bp);
957 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958 }
Brian Foster9c7504a2016-07-20 11:15:28 +1000959
960 /* the last reference has been dropped ... */
961 xfs_buf_ioacct_dec(bp);
962 if (!(bp->b_flags & XBF_STALE) && atomic_read(&bp->b_lru_ref)) {
963 /*
964 * If the buffer is added to the LRU take a new reference to the
965 * buffer for the LRU and clear the (now stale) dispose list
966 * state flag
967 */
968 if (list_lru_add(&bp->b_target->bt_lru, &bp->b_lru)) {
969 bp->b_state &= ~XFS_BSTATE_DISPOSE;
970 atomic_inc(&bp->b_hold);
971 }
972 spin_unlock(&pag->pag_buf_lock);
973 } else {
974 /*
975 * most of the time buffers will already be removed from the
976 * LRU, so optimise that case by checking for the
977 * XFS_BSTATE_DISPOSE flag indicating the last list the buffer
978 * was on was the disposal list
979 */
980 if (!(bp->b_state & XFS_BSTATE_DISPOSE)) {
981 list_lru_del(&bp->b_target->bt_lru, &bp->b_lru);
982 } else {
983 ASSERT(list_empty(&bp->b_lru));
984 }
985
986 ASSERT(!(bp->b_flags & _XBF_DELWRI_Q));
987 rb_erase(&bp->b_rbnode, &pag->pag_buf_tree);
988 spin_unlock(&pag->pag_buf_lock);
989 xfs_perag_put(pag);
990 freebuf = true;
991 }
992
993out_unlock:
994 spin_unlock(&bp->b_lock);
995
996 if (freebuf)
997 xfs_buf_free(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998}
999
1000
1001/*
Dave Chinner0e6e8472011-03-26 09:16:45 +11001002 * Lock a buffer object, if it is not already locked.
Dave Chinner90810b92010-11-30 15:16:16 +11001003 *
1004 * If we come across a stale, pinned, locked buffer, we know that we are
1005 * being asked to lock a buffer that has been reallocated. Because it is
1006 * pinned, we know that the log has not been pushed to disk and hence it
1007 * will still be locked. Rather than continuing to have trylock attempts
1008 * fail until someone else pushes the log, push it ourselves before
1009 * returning. This means that the xfsaild will not get stuck trying
1010 * to push on stale inode buffers.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 */
1012int
Christoph Hellwig0c842ad2011-07-08 14:36:19 +02001013xfs_buf_trylock(
1014 struct xfs_buf *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015{
1016 int locked;
1017
Nathan Scottce8e9222006-01-11 15:39:08 +11001018 locked = down_trylock(&bp->b_sema) == 0;
Darrick J. Wong479c6412016-06-21 11:53:28 +10001019 if (locked) {
Nathan Scottce8e9222006-01-11 15:39:08 +11001020 XB_SET_OWNER(bp);
Darrick J. Wong479c6412016-06-21 11:53:28 +10001021 trace_xfs_buf_trylock(bp, _RET_IP_);
1022 } else {
1023 trace_xfs_buf_trylock_fail(bp, _RET_IP_);
1024 }
Christoph Hellwig0c842ad2011-07-08 14:36:19 +02001025 return locked;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027
1028/*
Dave Chinner0e6e8472011-03-26 09:16:45 +11001029 * Lock a buffer object.
Dave Chinnered3b4d62010-05-21 12:07:08 +10001030 *
1031 * If we come across a stale, pinned, locked buffer, we know that we
1032 * are being asked to lock a buffer that has been reallocated. Because
1033 * it is pinned, we know that the log has not been pushed to disk and
1034 * hence it will still be locked. Rather than sleeping until someone
1035 * else pushes the log, push it ourselves before trying to get the lock.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036 */
Nathan Scottce8e9222006-01-11 15:39:08 +11001037void
1038xfs_buf_lock(
Christoph Hellwig0c842ad2011-07-08 14:36:19 +02001039 struct xfs_buf *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040{
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001041 trace_xfs_buf_lock(bp, _RET_IP_);
1042
Dave Chinnered3b4d62010-05-21 12:07:08 +10001043 if (atomic_read(&bp->b_pin_count) && (bp->b_flags & XBF_STALE))
Dave Chinnerebad8612010-09-22 10:47:20 +10001044 xfs_log_force(bp->b_target->bt_mount, 0);
Nathan Scottce8e9222006-01-11 15:39:08 +11001045 down(&bp->b_sema);
1046 XB_SET_OWNER(bp);
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001047
1048 trace_xfs_buf_lock_done(bp, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049}
1050
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051void
Nathan Scottce8e9222006-01-11 15:39:08 +11001052xfs_buf_unlock(
Christoph Hellwig0c842ad2011-07-08 14:36:19 +02001053 struct xfs_buf *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054{
Nathan Scottce8e9222006-01-11 15:39:08 +11001055 XB_CLEAR_OWNER(bp);
1056 up(&bp->b_sema);
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001057
1058 trace_xfs_buf_unlock(bp, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059}
1060
Nathan Scottce8e9222006-01-11 15:39:08 +11001061STATIC void
1062xfs_buf_wait_unpin(
1063 xfs_buf_t *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064{
1065 DECLARE_WAITQUEUE (wait, current);
1066
Nathan Scottce8e9222006-01-11 15:39:08 +11001067 if (atomic_read(&bp->b_pin_count) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068 return;
1069
Nathan Scottce8e9222006-01-11 15:39:08 +11001070 add_wait_queue(&bp->b_waiters, &wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071 for (;;) {
1072 set_current_state(TASK_UNINTERRUPTIBLE);
Nathan Scottce8e9222006-01-11 15:39:08 +11001073 if (atomic_read(&bp->b_pin_count) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074 break;
Jens Axboe7eaceac2011-03-10 08:52:07 +01001075 io_schedule();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076 }
Nathan Scottce8e9222006-01-11 15:39:08 +11001077 remove_wait_queue(&bp->b_waiters, &wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078 set_current_state(TASK_RUNNING);
1079}
1080
1081/*
1082 * Buffer Utility Routines
1083 */
1084
Dave Chinnere8aaba92014-10-02 09:04:22 +10001085void
1086xfs_buf_ioend(
1087 struct xfs_buf *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088{
Dave Chinnere8aaba92014-10-02 09:04:22 +10001089 bool read = bp->b_flags & XBF_READ;
1090
1091 trace_xfs_buf_iodone(bp, _RET_IP_);
Dave Chinner1813dd62012-11-14 17:54:40 +11001092
1093 bp->b_flags &= ~(XBF_READ | XBF_WRITE | XBF_READ_AHEAD);
Dave Chinnerd5929de2013-02-27 13:25:54 +11001094
Dave Chinner61be9c52014-10-02 09:04:31 +10001095 /*
1096 * Pull in IO completion errors now. We are guaranteed to be running
1097 * single threaded, so we don't need the lock to read b_io_error.
1098 */
1099 if (!bp->b_error && bp->b_io_error)
1100 xfs_buf_ioerror(bp, bp->b_io_error);
1101
Dave Chinnere8aaba92014-10-02 09:04:22 +10001102 /* Only validate buffers that were read without errors */
1103 if (read && !bp->b_error && bp->b_ops) {
1104 ASSERT(!bp->b_iodone);
Dave Chinner1813dd62012-11-14 17:54:40 +11001105 bp->b_ops->verify_read(bp);
Dave Chinnere8aaba92014-10-02 09:04:22 +10001106 }
1107
1108 if (!bp->b_error)
1109 bp->b_flags |= XBF_DONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110
Christoph Hellwig80f6c292010-08-18 05:29:11 -04001111 if (bp->b_iodone)
Nathan Scottce8e9222006-01-11 15:39:08 +11001112 (*(bp->b_iodone))(bp);
1113 else if (bp->b_flags & XBF_ASYNC)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114 xfs_buf_relse(bp);
Dave Chinner595bff72014-10-02 09:05:14 +10001115 else
Dave Chinner1813dd62012-11-14 17:54:40 +11001116 complete(&bp->b_iowait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117}
1118
Dave Chinnere8aaba92014-10-02 09:04:22 +10001119static void
1120xfs_buf_ioend_work(
1121 struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122{
Dave Chinnere8aaba92014-10-02 09:04:22 +10001123 struct xfs_buf *bp =
Brian Fosterb29c70f2014-12-04 09:43:17 +11001124 container_of(work, xfs_buf_t, b_ioend_work);
Dave Chinner1813dd62012-11-14 17:54:40 +11001125
Dave Chinnere8aaba92014-10-02 09:04:22 +10001126 xfs_buf_ioend(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127}
1128
Alexander Kuleshov211fe1a2016-01-04 16:10:42 +11001129static void
Dave Chinnere8aaba92014-10-02 09:04:22 +10001130xfs_buf_ioend_async(
1131 struct xfs_buf *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132{
Brian Fosterb29c70f2014-12-04 09:43:17 +11001133 INIT_WORK(&bp->b_ioend_work, xfs_buf_ioend_work);
1134 queue_work(bp->b_ioend_wq, &bp->b_ioend_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001135}
1136
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137void
Nathan Scottce8e9222006-01-11 15:39:08 +11001138xfs_buf_ioerror(
1139 xfs_buf_t *bp,
1140 int error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141{
Dave Chinner24513372014-06-25 14:58:08 +10001142 ASSERT(error <= 0 && error >= -1000);
1143 bp->b_error = error;
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001144 trace_xfs_buf_ioerror(bp, error, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145}
1146
Christoph Hellwig901796a2011-10-10 16:52:49 +00001147void
1148xfs_buf_ioerror_alert(
1149 struct xfs_buf *bp,
1150 const char *func)
1151{
1152 xfs_alert(bp->b_target->bt_mount,
Dave Chinneraa0e8832012-04-23 15:58:52 +10001153"metadata I/O error: block 0x%llx (\"%s\") error %d numblks %d",
Dave Chinner24513372014-06-25 14:58:08 +10001154 (__uint64_t)XFS_BUF_ADDR(bp), func, -bp->b_error, bp->b_length);
Christoph Hellwig901796a2011-10-10 16:52:49 +00001155}
1156
Christoph Hellwiga2dcf5d2012-07-13 02:24:10 -04001157int
1158xfs_bwrite(
1159 struct xfs_buf *bp)
1160{
1161 int error;
1162
1163 ASSERT(xfs_buf_islocked(bp));
1164
1165 bp->b_flags |= XBF_WRITE;
Dave Chinner27187752014-10-02 09:04:56 +10001166 bp->b_flags &= ~(XBF_ASYNC | XBF_READ | _XBF_DELWRI_Q |
1167 XBF_WRITE_FAIL | XBF_DONE);
Christoph Hellwiga2dcf5d2012-07-13 02:24:10 -04001168
Dave Chinner595bff72014-10-02 09:05:14 +10001169 error = xfs_buf_submit_wait(bp);
Christoph Hellwiga2dcf5d2012-07-13 02:24:10 -04001170 if (error) {
1171 xfs_force_shutdown(bp->b_target->bt_mount,
1172 SHUTDOWN_META_IO_ERROR);
1173 }
1174 return error;
1175}
1176
Brian Foster9bdd9bd2016-05-18 10:56:41 +10001177static void
Nathan Scottce8e9222006-01-11 15:39:08 +11001178xfs_buf_bio_end_io(
Christoph Hellwig4246a0b2015-07-20 15:29:37 +02001179 struct bio *bio)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180{
Brian Foster9bdd9bd2016-05-18 10:56:41 +10001181 struct xfs_buf *bp = (struct xfs_buf *)bio->bi_private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182
Dave Chinner37eb17e2012-11-12 22:09:46 +11001183 /*
1184 * don't overwrite existing errors - otherwise we can lose errors on
1185 * buffers that require multiple bios to complete.
1186 */
Brian Foster9bdd9bd2016-05-18 10:56:41 +10001187 if (bio->bi_error)
1188 cmpxchg(&bp->b_io_error, 0, bio->bi_error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189
Dave Chinner37eb17e2012-11-12 22:09:46 +11001190 if (!bp->b_error && xfs_buf_is_vmapped(bp) && (bp->b_flags & XBF_READ))
James Bottomley73c77e22010-01-25 11:42:24 -06001191 invalidate_kernel_vmap_range(bp->b_addr, xfs_buf_vmap_len(bp));
1192
Dave Chinnere8aaba92014-10-02 09:04:22 +10001193 if (atomic_dec_and_test(&bp->b_io_remaining) == 1)
1194 xfs_buf_ioend_async(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195 bio_put(bio);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196}
1197
Dave Chinner3e85c862012-06-22 18:50:09 +10001198static void
1199xfs_buf_ioapply_map(
1200 struct xfs_buf *bp,
1201 int map,
1202 int *buf_offset,
1203 int *count,
Mike Christie50bfcd02016-06-05 14:31:57 -05001204 int op,
1205 int op_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206{
Dave Chinner3e85c862012-06-22 18:50:09 +10001207 int page_index;
1208 int total_nr_pages = bp->b_page_count;
1209 int nr_pages;
1210 struct bio *bio;
1211 sector_t sector = bp->b_maps[map].bm_bn;
1212 int size;
1213 int offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214
Nathan Scottce8e9222006-01-11 15:39:08 +11001215 total_nr_pages = bp->b_page_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001216
Dave Chinner3e85c862012-06-22 18:50:09 +10001217 /* skip the pages in the buffer before the start offset */
1218 page_index = 0;
1219 offset = *buf_offset;
1220 while (offset >= PAGE_SIZE) {
1221 page_index++;
1222 offset -= PAGE_SIZE;
Christoph Hellwigf538d4d2005-11-02 10:26:59 +11001223 }
1224
Dave Chinner3e85c862012-06-22 18:50:09 +10001225 /*
1226 * Limit the IO size to the length of the current vector, and update the
1227 * remaining IO count for the next time around.
1228 */
1229 size = min_t(int, BBTOB(bp->b_maps[map].bm_len), *count);
1230 *count -= size;
1231 *buf_offset += size;
Christoph Hellwig34951f52011-07-26 15:06:44 +00001232
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233next_chunk:
Nathan Scottce8e9222006-01-11 15:39:08 +11001234 atomic_inc(&bp->b_io_remaining);
Ming Leic908e382016-05-30 21:34:33 +08001235 nr_pages = min(total_nr_pages, BIO_MAX_PAGES);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236
1237 bio = bio_alloc(GFP_NOIO, nr_pages);
Nathan Scottce8e9222006-01-11 15:39:08 +11001238 bio->bi_bdev = bp->b_target->bt_bdev;
Kent Overstreet4f024f32013-10-11 15:44:27 -07001239 bio->bi_iter.bi_sector = sector;
Nathan Scottce8e9222006-01-11 15:39:08 +11001240 bio->bi_end_io = xfs_buf_bio_end_io;
1241 bio->bi_private = bp;
Mike Christie50bfcd02016-06-05 14:31:57 -05001242 bio_set_op_attrs(bio, op, op_flags);
Dave Chinner0e6e8472011-03-26 09:16:45 +11001243
Dave Chinner3e85c862012-06-22 18:50:09 +10001244 for (; size && nr_pages; nr_pages--, page_index++) {
Dave Chinner0e6e8472011-03-26 09:16:45 +11001245 int rbytes, nbytes = PAGE_SIZE - offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001246
1247 if (nbytes > size)
1248 nbytes = size;
1249
Dave Chinner3e85c862012-06-22 18:50:09 +10001250 rbytes = bio_add_page(bio, bp->b_pages[page_index], nbytes,
1251 offset);
Nathan Scottce8e9222006-01-11 15:39:08 +11001252 if (rbytes < nbytes)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253 break;
1254
1255 offset = 0;
Dave Chinneraa0e8832012-04-23 15:58:52 +10001256 sector += BTOBB(nbytes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257 size -= nbytes;
1258 total_nr_pages--;
1259 }
1260
Kent Overstreet4f024f32013-10-11 15:44:27 -07001261 if (likely(bio->bi_iter.bi_size)) {
James Bottomley73c77e22010-01-25 11:42:24 -06001262 if (xfs_buf_is_vmapped(bp)) {
1263 flush_kernel_vmap_range(bp->b_addr,
1264 xfs_buf_vmap_len(bp));
1265 }
Mike Christie4e49ea42016-06-05 14:31:41 -05001266 submit_bio(bio);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267 if (size)
1268 goto next_chunk;
1269 } else {
Dave Chinner37eb17e2012-11-12 22:09:46 +11001270 /*
1271 * This is guaranteed not to be the last io reference count
Dave Chinner595bff72014-10-02 09:05:14 +10001272 * because the caller (xfs_buf_submit) holds a count itself.
Dave Chinner37eb17e2012-11-12 22:09:46 +11001273 */
1274 atomic_dec(&bp->b_io_remaining);
Dave Chinner24513372014-06-25 14:58:08 +10001275 xfs_buf_ioerror(bp, -EIO);
Dave Chinnerec53d1d2010-07-20 17:52:59 +10001276 bio_put(bio);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277 }
Dave Chinner3e85c862012-06-22 18:50:09 +10001278
1279}
1280
1281STATIC void
1282_xfs_buf_ioapply(
1283 struct xfs_buf *bp)
1284{
1285 struct blk_plug plug;
Mike Christie50bfcd02016-06-05 14:31:57 -05001286 int op;
1287 int op_flags = 0;
Dave Chinner3e85c862012-06-22 18:50:09 +10001288 int offset;
1289 int size;
1290 int i;
1291
Dave Chinnerc163f9a2013-03-12 23:30:34 +11001292 /*
1293 * Make sure we capture only current IO errors rather than stale errors
1294 * left over from previous use of the buffer (e.g. failed readahead).
1295 */
1296 bp->b_error = 0;
1297
Brian Fosterb29c70f2014-12-04 09:43:17 +11001298 /*
1299 * Initialize the I/O completion workqueue if we haven't yet or the
1300 * submitter has not opted to specify a custom one.
1301 */
1302 if (!bp->b_ioend_wq)
1303 bp->b_ioend_wq = bp->b_target->bt_mount->m_buf_workqueue;
1304
Dave Chinner3e85c862012-06-22 18:50:09 +10001305 if (bp->b_flags & XBF_WRITE) {
Mike Christie50bfcd02016-06-05 14:31:57 -05001306 op = REQ_OP_WRITE;
Dave Chinner3e85c862012-06-22 18:50:09 +10001307 if (bp->b_flags & XBF_SYNCIO)
Mike Christie50bfcd02016-06-05 14:31:57 -05001308 op_flags = WRITE_SYNC;
Dave Chinner3e85c862012-06-22 18:50:09 +10001309 if (bp->b_flags & XBF_FUA)
Mike Christie50bfcd02016-06-05 14:31:57 -05001310 op_flags |= REQ_FUA;
Dave Chinner3e85c862012-06-22 18:50:09 +10001311 if (bp->b_flags & XBF_FLUSH)
Mike Christie28a8f0d2016-06-05 14:32:25 -05001312 op_flags |= REQ_PREFLUSH;
Dave Chinner1813dd62012-11-14 17:54:40 +11001313
1314 /*
1315 * Run the write verifier callback function if it exists. If
1316 * this function fails it will mark the buffer with an error and
1317 * the IO should not be dispatched.
1318 */
1319 if (bp->b_ops) {
1320 bp->b_ops->verify_write(bp);
1321 if (bp->b_error) {
1322 xfs_force_shutdown(bp->b_target->bt_mount,
1323 SHUTDOWN_CORRUPT_INCORE);
1324 return;
1325 }
Dave Chinner400b9d82014-08-04 12:42:40 +10001326 } else if (bp->b_bn != XFS_BUF_DADDR_NULL) {
1327 struct xfs_mount *mp = bp->b_target->bt_mount;
1328
1329 /*
1330 * non-crc filesystems don't attach verifiers during
1331 * log recovery, so don't warn for such filesystems.
1332 */
1333 if (xfs_sb_version_hascrc(&mp->m_sb)) {
1334 xfs_warn(mp,
1335 "%s: no ops on block 0x%llx/0x%x",
1336 __func__, bp->b_bn, bp->b_length);
1337 xfs_hex_dump(bp->b_addr, 64);
1338 dump_stack();
1339 }
Dave Chinner1813dd62012-11-14 17:54:40 +11001340 }
Dave Chinner3e85c862012-06-22 18:50:09 +10001341 } else if (bp->b_flags & XBF_READ_AHEAD) {
Mike Christie50bfcd02016-06-05 14:31:57 -05001342 op = REQ_OP_READ;
1343 op_flags = REQ_RAHEAD;
Dave Chinner3e85c862012-06-22 18:50:09 +10001344 } else {
Mike Christie50bfcd02016-06-05 14:31:57 -05001345 op = REQ_OP_READ;
Dave Chinner3e85c862012-06-22 18:50:09 +10001346 }
1347
1348 /* we only use the buffer cache for meta-data */
Mike Christie50bfcd02016-06-05 14:31:57 -05001349 op_flags |= REQ_META;
Dave Chinner3e85c862012-06-22 18:50:09 +10001350
1351 /*
1352 * Walk all the vectors issuing IO on them. Set up the initial offset
1353 * into the buffer and the desired IO size before we start -
1354 * _xfs_buf_ioapply_vec() will modify them appropriately for each
1355 * subsequent call.
1356 */
1357 offset = bp->b_offset;
1358 size = BBTOB(bp->b_io_length);
1359 blk_start_plug(&plug);
1360 for (i = 0; i < bp->b_map_count; i++) {
Mike Christie50bfcd02016-06-05 14:31:57 -05001361 xfs_buf_ioapply_map(bp, i, &offset, &size, op, op_flags);
Dave Chinner3e85c862012-06-22 18:50:09 +10001362 if (bp->b_error)
1363 break;
1364 if (size <= 0)
1365 break; /* all done */
1366 }
1367 blk_finish_plug(&plug);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368}
1369
Dave Chinner595bff72014-10-02 09:05:14 +10001370/*
1371 * Asynchronous IO submission path. This transfers the buffer lock ownership and
1372 * the current reference to the IO. It is not safe to reference the buffer after
1373 * a call to this function unless the caller holds an additional reference
1374 * itself.
1375 */
Dave Chinner0e95f192012-04-23 15:58:46 +10001376void
Dave Chinner595bff72014-10-02 09:05:14 +10001377xfs_buf_submit(
1378 struct xfs_buf *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379{
Dave Chinner595bff72014-10-02 09:05:14 +10001380 trace_xfs_buf_submit(bp, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001382 ASSERT(!(bp->b_flags & _XBF_DELWRI_Q));
Dave Chinner595bff72014-10-02 09:05:14 +10001383 ASSERT(bp->b_flags & XBF_ASYNC);
1384
1385 /* on shutdown we stale and complete the buffer immediately */
1386 if (XFS_FORCED_SHUTDOWN(bp->b_target->bt_mount)) {
1387 xfs_buf_ioerror(bp, -EIO);
1388 bp->b_flags &= ~XBF_DONE;
1389 xfs_buf_stale(bp);
1390 xfs_buf_ioend(bp);
1391 return;
1392 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393
Christoph Hellwig375ec69d2011-08-23 08:28:03 +00001394 if (bp->b_flags & XBF_WRITE)
Nathan Scottce8e9222006-01-11 15:39:08 +11001395 xfs_buf_wait_unpin(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396
Dave Chinner61be9c52014-10-02 09:04:31 +10001397 /* clear the internal error state to avoid spurious errors */
1398 bp->b_io_error = 0;
1399
Eric Sandeen8d6c1212014-04-17 08:15:28 +10001400 /*
Dave Chinner595bff72014-10-02 09:05:14 +10001401 * The caller's reference is released during I/O completion.
1402 * This occurs some time after the last b_io_remaining reference is
1403 * released, so after we drop our Io reference we have to have some
1404 * other reference to ensure the buffer doesn't go away from underneath
1405 * us. Take a direct reference to ensure we have safe access to the
1406 * buffer until we are finished with it.
Dave Chinnere11bb802014-10-02 09:04:11 +10001407 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408 xfs_buf_hold(bp);
1409
Eric Sandeen8d6c1212014-04-17 08:15:28 +10001410 /*
Dave Chinnere11bb802014-10-02 09:04:11 +10001411 * Set the count to 1 initially, this will stop an I/O completion
1412 * callout which happens before we have started all the I/O from calling
1413 * xfs_buf_ioend too early.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414 */
Nathan Scottce8e9222006-01-11 15:39:08 +11001415 atomic_set(&bp->b_io_remaining, 1);
Brian Foster9c7504a2016-07-20 11:15:28 +10001416 xfs_buf_ioacct_inc(bp);
Nathan Scottce8e9222006-01-11 15:39:08 +11001417 _xfs_buf_ioapply(bp);
Dave Chinnere11bb802014-10-02 09:04:11 +10001418
Eric Sandeen8d6c1212014-04-17 08:15:28 +10001419 /*
Dave Chinner595bff72014-10-02 09:05:14 +10001420 * If _xfs_buf_ioapply failed, we can get back here with only the IO
1421 * reference we took above. If we drop it to zero, run completion so
1422 * that we don't return to the caller with completion still pending.
Eric Sandeen8d6c1212014-04-17 08:15:28 +10001423 */
Dave Chinnere8aaba92014-10-02 09:04:22 +10001424 if (atomic_dec_and_test(&bp->b_io_remaining) == 1) {
Dave Chinner595bff72014-10-02 09:05:14 +10001425 if (bp->b_error)
Dave Chinnere8aaba92014-10-02 09:04:22 +10001426 xfs_buf_ioend(bp);
1427 else
1428 xfs_buf_ioend_async(bp);
1429 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430
Nathan Scottce8e9222006-01-11 15:39:08 +11001431 xfs_buf_rele(bp);
Dave Chinner595bff72014-10-02 09:05:14 +10001432 /* Note: it is not safe to reference bp now we've dropped our ref */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433}
1434
1435/*
Dave Chinner595bff72014-10-02 09:05:14 +10001436 * Synchronous buffer IO submission path, read or write.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437 */
1438int
Dave Chinner595bff72014-10-02 09:05:14 +10001439xfs_buf_submit_wait(
1440 struct xfs_buf *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441{
Dave Chinner595bff72014-10-02 09:05:14 +10001442 int error;
1443
1444 trace_xfs_buf_submit_wait(bp, _RET_IP_);
1445
1446 ASSERT(!(bp->b_flags & (_XBF_DELWRI_Q | XBF_ASYNC)));
1447
1448 if (XFS_FORCED_SHUTDOWN(bp->b_target->bt_mount)) {
1449 xfs_buf_ioerror(bp, -EIO);
1450 xfs_buf_stale(bp);
1451 bp->b_flags &= ~XBF_DONE;
1452 return -EIO;
1453 }
1454
1455 if (bp->b_flags & XBF_WRITE)
1456 xfs_buf_wait_unpin(bp);
1457
1458 /* clear the internal error state to avoid spurious errors */
1459 bp->b_io_error = 0;
1460
1461 /*
1462 * For synchronous IO, the IO does not inherit the submitters reference
1463 * count, nor the buffer lock. Hence we cannot release the reference we
1464 * are about to take until we've waited for all IO completion to occur,
1465 * including any xfs_buf_ioend_async() work that may be pending.
1466 */
1467 xfs_buf_hold(bp);
1468
1469 /*
1470 * Set the count to 1 initially, this will stop an I/O completion
1471 * callout which happens before we have started all the I/O from calling
1472 * xfs_buf_ioend too early.
1473 */
1474 atomic_set(&bp->b_io_remaining, 1);
1475 _xfs_buf_ioapply(bp);
1476
1477 /*
1478 * make sure we run completion synchronously if it raced with us and is
1479 * already complete.
1480 */
1481 if (atomic_dec_and_test(&bp->b_io_remaining) == 1)
1482 xfs_buf_ioend(bp);
1483
1484 /* wait for completion before gathering the error from the buffer */
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001485 trace_xfs_buf_iowait(bp, _RET_IP_);
Dave Chinner595bff72014-10-02 09:05:14 +10001486 wait_for_completion(&bp->b_iowait);
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001487 trace_xfs_buf_iowait_done(bp, _RET_IP_);
Dave Chinner595bff72014-10-02 09:05:14 +10001488 error = bp->b_error;
1489
1490 /*
1491 * all done now, we can release the hold that keeps the buffer
1492 * referenced for the entire IO.
1493 */
1494 xfs_buf_rele(bp);
1495 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496}
1497
Christoph Hellwig88ee2df2015-06-22 09:44:29 +10001498void *
Nathan Scottce8e9222006-01-11 15:39:08 +11001499xfs_buf_offset(
Christoph Hellwig88ee2df2015-06-22 09:44:29 +10001500 struct xfs_buf *bp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501 size_t offset)
1502{
1503 struct page *page;
1504
Dave Chinner611c9942012-04-23 15:59:07 +10001505 if (bp->b_addr)
Chandra Seetharaman62926042011-07-22 23:40:15 +00001506 return bp->b_addr + offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507
Nathan Scottce8e9222006-01-11 15:39:08 +11001508 offset += bp->b_offset;
Dave Chinner0e6e8472011-03-26 09:16:45 +11001509 page = bp->b_pages[offset >> PAGE_SHIFT];
Christoph Hellwig88ee2df2015-06-22 09:44:29 +10001510 return page_address(page) + (offset & (PAGE_SIZE-1));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001511}
1512
1513/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514 * Move data into or out of a buffer.
1515 */
1516void
Nathan Scottce8e9222006-01-11 15:39:08 +11001517xfs_buf_iomove(
1518 xfs_buf_t *bp, /* buffer to process */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519 size_t boff, /* starting buffer offset */
1520 size_t bsize, /* length to copy */
Dave Chinnerb9c48642010-01-20 10:47:39 +11001521 void *data, /* data address */
Nathan Scottce8e9222006-01-11 15:39:08 +11001522 xfs_buf_rw_t mode) /* read/write/zero flag */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001523{
Dave Chinner795cac72012-04-23 15:58:53 +10001524 size_t bend;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525
1526 bend = boff + bsize;
1527 while (boff < bend) {
Dave Chinner795cac72012-04-23 15:58:53 +10001528 struct page *page;
1529 int page_index, page_offset, csize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530
Dave Chinner795cac72012-04-23 15:58:53 +10001531 page_index = (boff + bp->b_offset) >> PAGE_SHIFT;
1532 page_offset = (boff + bp->b_offset) & ~PAGE_MASK;
1533 page = bp->b_pages[page_index];
1534 csize = min_t(size_t, PAGE_SIZE - page_offset,
1535 BBTOB(bp->b_io_length) - boff);
1536
1537 ASSERT((csize + page_offset) <= PAGE_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538
1539 switch (mode) {
Nathan Scottce8e9222006-01-11 15:39:08 +11001540 case XBRW_ZERO:
Dave Chinner795cac72012-04-23 15:58:53 +10001541 memset(page_address(page) + page_offset, 0, csize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542 break;
Nathan Scottce8e9222006-01-11 15:39:08 +11001543 case XBRW_READ:
Dave Chinner795cac72012-04-23 15:58:53 +10001544 memcpy(data, page_address(page) + page_offset, csize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545 break;
Nathan Scottce8e9222006-01-11 15:39:08 +11001546 case XBRW_WRITE:
Dave Chinner795cac72012-04-23 15:58:53 +10001547 memcpy(page_address(page) + page_offset, data, csize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001548 }
1549
1550 boff += csize;
1551 data += csize;
1552 }
1553}
1554
1555/*
Nathan Scottce8e9222006-01-11 15:39:08 +11001556 * Handling of buffer targets (buftargs).
Linus Torvalds1da177e2005-04-16 15:20:36 -07001557 */
1558
1559/*
Dave Chinner430cbeb2010-12-02 16:30:55 +11001560 * Wait for any bufs with callbacks that have been submitted but have not yet
1561 * returned. These buffers will have an elevated hold count, so wait on those
1562 * while freeing all the buffers only held by the LRU.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563 */
Dave Chinnere80dfa12013-08-28 10:18:05 +10001564static enum lru_status
1565xfs_buftarg_wait_rele(
1566 struct list_head *item,
Vladimir Davydov3f97b162015-02-12 14:59:35 -08001567 struct list_lru_one *lru,
Dave Chinnere80dfa12013-08-28 10:18:05 +10001568 spinlock_t *lru_lock,
1569 void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570
Dave Chinnere80dfa12013-08-28 10:18:05 +10001571{
1572 struct xfs_buf *bp = container_of(item, struct xfs_buf, b_lru);
Dave Chinnera4082352013-08-28 10:18:06 +10001573 struct list_head *dispose = arg;
Dave Chinnere80dfa12013-08-28 10:18:05 +10001574
1575 if (atomic_read(&bp->b_hold) > 1) {
Dave Chinnera4082352013-08-28 10:18:06 +10001576 /* need to wait, so skip it this pass */
Dave Chinnere80dfa12013-08-28 10:18:05 +10001577 trace_xfs_buf_wait_buftarg(bp, _RET_IP_);
Dave Chinnera4082352013-08-28 10:18:06 +10001578 return LRU_SKIP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579 }
Dave Chinnera4082352013-08-28 10:18:06 +10001580 if (!spin_trylock(&bp->b_lock))
1581 return LRU_SKIP;
Dave Chinnere80dfa12013-08-28 10:18:05 +10001582
Dave Chinnera4082352013-08-28 10:18:06 +10001583 /*
1584 * clear the LRU reference count so the buffer doesn't get
1585 * ignored in xfs_buf_rele().
1586 */
1587 atomic_set(&bp->b_lru_ref, 0);
1588 bp->b_state |= XFS_BSTATE_DISPOSE;
Vladimir Davydov3f97b162015-02-12 14:59:35 -08001589 list_lru_isolate_move(lru, item, dispose);
Dave Chinnera4082352013-08-28 10:18:06 +10001590 spin_unlock(&bp->b_lock);
1591 return LRU_REMOVED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001592}
1593
Dave Chinnere80dfa12013-08-28 10:18:05 +10001594void
1595xfs_wait_buftarg(
1596 struct xfs_buftarg *btp)
1597{
Dave Chinnera4082352013-08-28 10:18:06 +10001598 LIST_HEAD(dispose);
1599 int loop = 0;
1600
Dave Chinner85bec542016-01-19 08:28:10 +11001601 /*
Brian Foster9c7504a2016-07-20 11:15:28 +10001602 * First wait on the buftarg I/O count for all in-flight buffers to be
1603 * released. This is critical as new buffers do not make the LRU until
1604 * they are released.
1605 *
1606 * Next, flush the buffer workqueue to ensure all completion processing
1607 * has finished. Just waiting on buffer locks is not sufficient for
1608 * async IO as the reference count held over IO is not released until
1609 * after the buffer lock is dropped. Hence we need to ensure here that
1610 * all reference counts have been dropped before we start walking the
1611 * LRU list.
Dave Chinner85bec542016-01-19 08:28:10 +11001612 */
Brian Foster9c7504a2016-07-20 11:15:28 +10001613 while (percpu_counter_sum(&btp->bt_io_count))
1614 delay(100);
Brian Foster800b2692016-08-26 16:01:59 +10001615 flush_workqueue(btp->bt_mount->m_buf_workqueue);
Dave Chinner85bec542016-01-19 08:28:10 +11001616
Dave Chinnera4082352013-08-28 10:18:06 +10001617 /* loop until there is nothing left on the lru list. */
1618 while (list_lru_count(&btp->bt_lru)) {
Dave Chinnere80dfa12013-08-28 10:18:05 +10001619 list_lru_walk(&btp->bt_lru, xfs_buftarg_wait_rele,
Dave Chinnera4082352013-08-28 10:18:06 +10001620 &dispose, LONG_MAX);
1621
1622 while (!list_empty(&dispose)) {
1623 struct xfs_buf *bp;
1624 bp = list_first_entry(&dispose, struct xfs_buf, b_lru);
1625 list_del_init(&bp->b_lru);
Dave Chinnerac8809f2013-12-12 16:34:38 +11001626 if (bp->b_flags & XBF_WRITE_FAIL) {
1627 xfs_alert(btp->bt_mount,
Joe Perchesf41febd2015-07-29 11:52:04 +10001628"Corruption Alert: Buffer at block 0x%llx had permanent write failures!",
Dave Chinnerac8809f2013-12-12 16:34:38 +11001629 (long long)bp->b_bn);
Joe Perchesf41febd2015-07-29 11:52:04 +10001630 xfs_alert(btp->bt_mount,
1631"Please run xfs_repair to determine the extent of the problem.");
Dave Chinnerac8809f2013-12-12 16:34:38 +11001632 }
Dave Chinnera4082352013-08-28 10:18:06 +10001633 xfs_buf_rele(bp);
1634 }
1635 if (loop++ != 0)
1636 delay(100);
1637 }
Dave Chinnere80dfa12013-08-28 10:18:05 +10001638}
1639
1640static enum lru_status
1641xfs_buftarg_isolate(
1642 struct list_head *item,
Vladimir Davydov3f97b162015-02-12 14:59:35 -08001643 struct list_lru_one *lru,
Dave Chinnere80dfa12013-08-28 10:18:05 +10001644 spinlock_t *lru_lock,
1645 void *arg)
1646{
1647 struct xfs_buf *bp = container_of(item, struct xfs_buf, b_lru);
1648 struct list_head *dispose = arg;
1649
1650 /*
Dave Chinnera4082352013-08-28 10:18:06 +10001651 * we are inverting the lru lock/bp->b_lock here, so use a trylock.
1652 * If we fail to get the lock, just skip it.
1653 */
1654 if (!spin_trylock(&bp->b_lock))
1655 return LRU_SKIP;
1656 /*
Dave Chinnere80dfa12013-08-28 10:18:05 +10001657 * Decrement the b_lru_ref count unless the value is already
1658 * zero. If the value is already zero, we need to reclaim the
1659 * buffer, otherwise it gets another trip through the LRU.
1660 */
Dave Chinnera4082352013-08-28 10:18:06 +10001661 if (!atomic_add_unless(&bp->b_lru_ref, -1, 0)) {
1662 spin_unlock(&bp->b_lock);
Dave Chinnere80dfa12013-08-28 10:18:05 +10001663 return LRU_ROTATE;
Dave Chinnera4082352013-08-28 10:18:06 +10001664 }
Dave Chinnere80dfa12013-08-28 10:18:05 +10001665
Dave Chinnera4082352013-08-28 10:18:06 +10001666 bp->b_state |= XFS_BSTATE_DISPOSE;
Vladimir Davydov3f97b162015-02-12 14:59:35 -08001667 list_lru_isolate_move(lru, item, dispose);
Dave Chinnera4082352013-08-28 10:18:06 +10001668 spin_unlock(&bp->b_lock);
Dave Chinnere80dfa12013-08-28 10:18:05 +10001669 return LRU_REMOVED;
1670}
1671
Andrew Mortonaddbda42013-08-28 10:18:06 +10001672static unsigned long
Dave Chinnere80dfa12013-08-28 10:18:05 +10001673xfs_buftarg_shrink_scan(
Dave Chinnerff57ab22010-11-30 17:27:57 +11001674 struct shrinker *shrink,
Ying Han1495f232011-05-24 17:12:27 -07001675 struct shrink_control *sc)
David Chinnera6867a62006-01-11 15:37:58 +11001676{
Dave Chinnerff57ab22010-11-30 17:27:57 +11001677 struct xfs_buftarg *btp = container_of(shrink,
1678 struct xfs_buftarg, bt_shrinker);
Dave Chinner430cbeb2010-12-02 16:30:55 +11001679 LIST_HEAD(dispose);
Andrew Mortonaddbda42013-08-28 10:18:06 +10001680 unsigned long freed;
Dave Chinner430cbeb2010-12-02 16:30:55 +11001681
Vladimir Davydov503c3582015-02-12 14:58:47 -08001682 freed = list_lru_shrink_walk(&btp->bt_lru, sc,
1683 xfs_buftarg_isolate, &dispose);
Dave Chinner430cbeb2010-12-02 16:30:55 +11001684
1685 while (!list_empty(&dispose)) {
Dave Chinnere80dfa12013-08-28 10:18:05 +10001686 struct xfs_buf *bp;
Dave Chinner430cbeb2010-12-02 16:30:55 +11001687 bp = list_first_entry(&dispose, struct xfs_buf, b_lru);
1688 list_del_init(&bp->b_lru);
1689 xfs_buf_rele(bp);
1690 }
1691
Dave Chinnere80dfa12013-08-28 10:18:05 +10001692 return freed;
1693}
1694
Andrew Mortonaddbda42013-08-28 10:18:06 +10001695static unsigned long
Dave Chinnere80dfa12013-08-28 10:18:05 +10001696xfs_buftarg_shrink_count(
1697 struct shrinker *shrink,
1698 struct shrink_control *sc)
1699{
1700 struct xfs_buftarg *btp = container_of(shrink,
1701 struct xfs_buftarg, bt_shrinker);
Vladimir Davydov503c3582015-02-12 14:58:47 -08001702 return list_lru_shrink_count(&btp->bt_lru, sc);
David Chinnera6867a62006-01-11 15:37:58 +11001703}
1704
Linus Torvalds1da177e2005-04-16 15:20:36 -07001705void
1706xfs_free_buftarg(
Christoph Hellwigb7963132009-03-03 14:48:37 -05001707 struct xfs_mount *mp,
1708 struct xfs_buftarg *btp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001709{
Dave Chinnerff57ab22010-11-30 17:27:57 +11001710 unregister_shrinker(&btp->bt_shrinker);
Brian Foster9c7504a2016-07-20 11:15:28 +10001711 ASSERT(percpu_counter_sum(&btp->bt_io_count) == 0);
1712 percpu_counter_destroy(&btp->bt_io_count);
Glauber Costaf5e1dd32013-08-28 10:18:18 +10001713 list_lru_destroy(&btp->bt_lru);
Dave Chinnerff57ab22010-11-30 17:27:57 +11001714
Christoph Hellwigb7963132009-03-03 14:48:37 -05001715 if (mp->m_flags & XFS_MOUNT_BARRIER)
1716 xfs_blkdev_issue_flush(btp);
David Chinnera6867a62006-01-11 15:37:58 +11001717
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10001718 kmem_free(btp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001719}
1720
Eric Sandeen3fefdee2013-11-13 14:53:45 -06001721int
1722xfs_setsize_buftarg(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001723 xfs_buftarg_t *btp,
Eric Sandeen3fefdee2013-11-13 14:53:45 -06001724 unsigned int sectorsize)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725{
Eric Sandeen7c71ee72014-01-21 16:46:23 -06001726 /* Set up metadata sector size info */
Eric Sandeen6da54172014-01-21 16:45:52 -06001727 btp->bt_meta_sectorsize = sectorsize;
1728 btp->bt_meta_sectormask = sectorsize - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729
Nathan Scottce8e9222006-01-11 15:39:08 +11001730 if (set_blocksize(btp->bt_bdev, sectorsize)) {
Dave Chinner4f107002011-03-07 10:00:35 +11001731 xfs_warn(btp->bt_mount,
Dmitry Monakhova1c6f0572015-04-13 16:31:37 +04001732 "Cannot set_blocksize to %u on device %pg",
1733 sectorsize, btp->bt_bdev);
Dave Chinner24513372014-06-25 14:58:08 +10001734 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001735 }
1736
Eric Sandeen7c71ee72014-01-21 16:46:23 -06001737 /* Set up device logical sector size mask */
1738 btp->bt_logical_sectorsize = bdev_logical_block_size(btp->bt_bdev);
1739 btp->bt_logical_sectormask = bdev_logical_block_size(btp->bt_bdev) - 1;
1740
Linus Torvalds1da177e2005-04-16 15:20:36 -07001741 return 0;
1742}
1743
1744/*
Eric Sandeen3fefdee2013-11-13 14:53:45 -06001745 * When allocating the initial buffer target we have not yet
1746 * read in the superblock, so don't know what sized sectors
1747 * are being used at this early stage. Play safe.
Nathan Scottce8e9222006-01-11 15:39:08 +11001748 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749STATIC int
1750xfs_setsize_buftarg_early(
1751 xfs_buftarg_t *btp,
1752 struct block_device *bdev)
1753{
Eric Sandeena96c4152014-04-14 19:00:29 +10001754 return xfs_setsize_buftarg(btp, bdev_logical_block_size(bdev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001755}
1756
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757xfs_buftarg_t *
1758xfs_alloc_buftarg(
Dave Chinnerebad8612010-09-22 10:47:20 +10001759 struct xfs_mount *mp,
Eric Sandeen34dcefd2014-04-14 19:01:00 +10001760 struct block_device *bdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001761{
1762 xfs_buftarg_t *btp;
1763
Dave Chinnerb17cb362013-05-20 09:51:12 +10001764 btp = kmem_zalloc(sizeof(*btp), KM_SLEEP | KM_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001765
Dave Chinnerebad8612010-09-22 10:47:20 +10001766 btp->bt_mount = mp;
Nathan Scottce8e9222006-01-11 15:39:08 +11001767 btp->bt_dev = bdev->bd_dev;
1768 btp->bt_bdev = bdev;
Dave Chinner0e6e8472011-03-26 09:16:45 +11001769 btp->bt_bdi = blk_get_backing_dev_info(bdev);
Dave Chinner0e6e8472011-03-26 09:16:45 +11001770
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771 if (xfs_setsize_buftarg_early(btp, bdev))
1772 goto error;
Glauber Costa5ca302c2013-08-28 10:18:18 +10001773
1774 if (list_lru_init(&btp->bt_lru))
1775 goto error;
1776
Brian Foster9c7504a2016-07-20 11:15:28 +10001777 if (percpu_counter_init(&btp->bt_io_count, 0, GFP_KERNEL))
1778 goto error;
1779
Dave Chinnere80dfa12013-08-28 10:18:05 +10001780 btp->bt_shrinker.count_objects = xfs_buftarg_shrink_count;
1781 btp->bt_shrinker.scan_objects = xfs_buftarg_shrink_scan;
Dave Chinnerff57ab22010-11-30 17:27:57 +11001782 btp->bt_shrinker.seeks = DEFAULT_SEEKS;
Dave Chinnere80dfa12013-08-28 10:18:05 +10001783 btp->bt_shrinker.flags = SHRINKER_NUMA_AWARE;
Dave Chinnerff57ab22010-11-30 17:27:57 +11001784 register_shrinker(&btp->bt_shrinker);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785 return btp;
1786
1787error:
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10001788 kmem_free(btp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789 return NULL;
1790}
1791
Linus Torvalds1da177e2005-04-16 15:20:36 -07001792/*
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001793 * Add a buffer to the delayed write list.
1794 *
1795 * This queues a buffer for writeout if it hasn't already been. Note that
1796 * neither this routine nor the buffer list submission functions perform
1797 * any internal synchronization. It is expected that the lists are thread-local
1798 * to the callers.
1799 *
1800 * Returns true if we queued up the buffer, or false if it already had
1801 * been on the buffer list.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001802 */
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001803bool
Nathan Scottce8e9222006-01-11 15:39:08 +11001804xfs_buf_delwri_queue(
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001805 struct xfs_buf *bp,
1806 struct list_head *list)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001807{
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001808 ASSERT(xfs_buf_islocked(bp));
1809 ASSERT(!(bp->b_flags & XBF_READ));
1810
1811 /*
1812 * If the buffer is already marked delwri it already is queued up
1813 * by someone else for imediate writeout. Just ignore it in that
1814 * case.
1815 */
1816 if (bp->b_flags & _XBF_DELWRI_Q) {
1817 trace_xfs_buf_delwri_queued(bp, _RET_IP_);
1818 return false;
1819 }
David Chinnera6867a62006-01-11 15:37:58 +11001820
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001821 trace_xfs_buf_delwri_queue(bp, _RET_IP_);
1822
Dave Chinnerd808f612010-02-02 10:13:42 +11001823 /*
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001824 * If a buffer gets written out synchronously or marked stale while it
1825 * is on a delwri list we lazily remove it. To do this, the other party
1826 * clears the _XBF_DELWRI_Q flag but otherwise leaves the buffer alone.
1827 * It remains referenced and on the list. In a rare corner case it
1828 * might get readded to a delwri list after the synchronous writeout, in
1829 * which case we need just need to re-add the flag here.
Dave Chinnerd808f612010-02-02 10:13:42 +11001830 */
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001831 bp->b_flags |= _XBF_DELWRI_Q;
1832 if (list_empty(&bp->b_list)) {
1833 atomic_inc(&bp->b_hold);
1834 list_add_tail(&bp->b_list, list);
David Chinner585e6d82007-02-10 18:32:29 +11001835 }
David Chinner585e6d82007-02-10 18:32:29 +11001836
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001837 return true;
David Chinner585e6d82007-02-10 18:32:29 +11001838}
1839
Dave Chinner089716a2010-01-26 15:13:25 +11001840/*
1841 * Compare function is more complex than it needs to be because
1842 * the return value is only 32 bits and we are doing comparisons
1843 * on 64 bit values
1844 */
1845static int
1846xfs_buf_cmp(
1847 void *priv,
1848 struct list_head *a,
1849 struct list_head *b)
1850{
1851 struct xfs_buf *ap = container_of(a, struct xfs_buf, b_list);
1852 struct xfs_buf *bp = container_of(b, struct xfs_buf, b_list);
1853 xfs_daddr_t diff;
1854
Mark Tinguelyf4b42422012-12-04 17:18:02 -06001855 diff = ap->b_maps[0].bm_bn - bp->b_maps[0].bm_bn;
Dave Chinner089716a2010-01-26 15:13:25 +11001856 if (diff < 0)
1857 return -1;
1858 if (diff > 0)
1859 return 1;
1860 return 0;
1861}
1862
Dave Chinner26f1fe82016-06-01 17:38:15 +10001863/*
1864 * submit buffers for write.
1865 *
1866 * When we have a large buffer list, we do not want to hold all the buffers
1867 * locked while we block on the request queue waiting for IO dispatch. To avoid
1868 * this problem, we lock and submit buffers in groups of 50, thereby minimising
1869 * the lock hold times for lists which may contain thousands of objects.
1870 *
1871 * To do this, we sort the buffer list before we walk the list to lock and
1872 * submit buffers, and we plug and unplug around each group of buffers we
1873 * submit.
1874 */
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001875static int
Dave Chinner26f1fe82016-06-01 17:38:15 +10001876xfs_buf_delwri_submit_buffers(
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001877 struct list_head *buffer_list,
Dave Chinner26f1fe82016-06-01 17:38:15 +10001878 struct list_head *wait_list)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001879{
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001880 struct xfs_buf *bp, *n;
Dave Chinner26f1fe82016-06-01 17:38:15 +10001881 LIST_HEAD (submit_list);
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001882 int pinned = 0;
Dave Chinner26f1fe82016-06-01 17:38:15 +10001883 struct blk_plug plug;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001884
Dave Chinner26f1fe82016-06-01 17:38:15 +10001885 list_sort(NULL, buffer_list, xfs_buf_cmp);
1886
1887 blk_start_plug(&plug);
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001888 list_for_each_entry_safe(bp, n, buffer_list, b_list) {
Dave Chinner26f1fe82016-06-01 17:38:15 +10001889 if (!wait_list) {
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001890 if (xfs_buf_ispinned(bp)) {
1891 pinned++;
1892 continue;
1893 }
1894 if (!xfs_buf_trylock(bp))
1895 continue;
1896 } else {
1897 xfs_buf_lock(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001898 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001899
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001900 /*
1901 * Someone else might have written the buffer synchronously or
1902 * marked it stale in the meantime. In that case only the
1903 * _XBF_DELWRI_Q flag got cleared, and we have to drop the
1904 * reference and remove it from the list here.
1905 */
1906 if (!(bp->b_flags & _XBF_DELWRI_Q)) {
1907 list_del_init(&bp->b_list);
1908 xfs_buf_relse(bp);
1909 continue;
1910 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001911
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001912 trace_xfs_buf_delwri_split(bp, _RET_IP_);
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001913
Dave Chinnercf53e992014-10-02 09:04:01 +10001914 /*
Dave Chinner26f1fe82016-06-01 17:38:15 +10001915 * We do all IO submission async. This means if we need
1916 * to wait for IO completion we need to take an extra
1917 * reference so the buffer is still valid on the other
1918 * side. We need to move the buffer onto the io_list
1919 * at this point so the caller can still access it.
Dave Chinnercf53e992014-10-02 09:04:01 +10001920 */
Dave Chinnerbbfeb612016-07-20 11:53:35 +10001921 bp->b_flags &= ~(_XBF_DELWRI_Q | XBF_WRITE_FAIL);
Dave Chinner26f1fe82016-06-01 17:38:15 +10001922 bp->b_flags |= XBF_WRITE | XBF_ASYNC;
1923 if (wait_list) {
Dave Chinnercf53e992014-10-02 09:04:01 +10001924 xfs_buf_hold(bp);
Dave Chinner26f1fe82016-06-01 17:38:15 +10001925 list_move_tail(&bp->b_list, wait_list);
1926 } else
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001927 list_del_init(&bp->b_list);
Dave Chinner8dac3922014-10-02 09:04:40 +10001928
Dave Chinner595bff72014-10-02 09:05:14 +10001929 xfs_buf_submit(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001930 }
Christoph Hellwiga1b7ea52011-03-30 11:05:09 +00001931 blk_finish_plug(&plug);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001932
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001933 return pinned;
1934}
Nathan Scottf07c2252006-09-28 10:52:15 +10001935
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001936/*
1937 * Write out a buffer list asynchronously.
1938 *
1939 * This will take the @buffer_list, write all non-locked and non-pinned buffers
1940 * out and not wait for I/O completion on any of the buffers. This interface
1941 * is only safely useable for callers that can track I/O completion by higher
1942 * level means, e.g. AIL pushing as the @buffer_list is consumed in this
1943 * function.
1944 */
1945int
1946xfs_buf_delwri_submit_nowait(
1947 struct list_head *buffer_list)
1948{
Dave Chinner26f1fe82016-06-01 17:38:15 +10001949 return xfs_buf_delwri_submit_buffers(buffer_list, NULL);
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001950}
1951
1952/*
1953 * Write out a buffer list synchronously.
1954 *
1955 * This will take the @buffer_list, write all buffers out and wait for I/O
1956 * completion on all of the buffers. @buffer_list is consumed by the function,
1957 * so callers must have some other way of tracking buffers if they require such
1958 * functionality.
1959 */
1960int
1961xfs_buf_delwri_submit(
1962 struct list_head *buffer_list)
1963{
Dave Chinner26f1fe82016-06-01 17:38:15 +10001964 LIST_HEAD (wait_list);
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001965 int error = 0, error2;
1966 struct xfs_buf *bp;
1967
Dave Chinner26f1fe82016-06-01 17:38:15 +10001968 xfs_buf_delwri_submit_buffers(buffer_list, &wait_list);
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001969
1970 /* Wait for IO to complete. */
Dave Chinner26f1fe82016-06-01 17:38:15 +10001971 while (!list_empty(&wait_list)) {
1972 bp = list_first_entry(&wait_list, struct xfs_buf, b_list);
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001973
1974 list_del_init(&bp->b_list);
Dave Chinnercf53e992014-10-02 09:04:01 +10001975
1976 /* locking the buffer will wait for async IO completion. */
1977 xfs_buf_lock(bp);
1978 error2 = bp->b_error;
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001979 xfs_buf_relse(bp);
1980 if (!error)
1981 error = error2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001982 }
1983
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001984 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001985}
1986
Christoph Hellwig04d8b282005-11-02 10:15:05 +11001987int __init
Nathan Scottce8e9222006-01-11 15:39:08 +11001988xfs_buf_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001989{
Nathan Scott87582802006-03-14 13:18:19 +11001990 xfs_buf_zone = kmem_zone_init_flags(sizeof(xfs_buf_t), "xfs_buf",
1991 KM_ZONE_HWALIGN, NULL);
Nathan Scottce8e9222006-01-11 15:39:08 +11001992 if (!xfs_buf_zone)
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001993 goto out;
Christoph Hellwig04d8b282005-11-02 10:15:05 +11001994
Christoph Hellwig23ea4032005-06-21 15:14:01 +10001995 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001996
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001997 out:
Nathan Scott87582802006-03-14 13:18:19 +11001998 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001999}
2000
Linus Torvalds1da177e2005-04-16 15:20:36 -07002001void
Nathan Scottce8e9222006-01-11 15:39:08 +11002002xfs_buf_terminate(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002003{
Nathan Scottce8e9222006-01-11 15:39:08 +11002004 kmem_zone_destroy(xfs_buf_zone);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002005}