blob: bb502a391792100f011c372009d52df4e9f88375 [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/*
Dave Chinner430cbeb2010-12-02 16:30:55 +110083 * When we mark a buffer stale, we remove the buffer from the LRU and clear the
84 * b_lru_ref count so that the buffer is freed immediately when the buffer
85 * reference count falls to zero. If the buffer is already on the LRU, we need
86 * to remove the reference that LRU holds on the buffer.
87 *
88 * This prevents build-up of stale buffers on the LRU.
89 */
90void
91xfs_buf_stale(
92 struct xfs_buf *bp)
93{
Christoph Hellwig43ff2122012-04-23 15:58:39 +100094 ASSERT(xfs_buf_islocked(bp));
95
Dave Chinner430cbeb2010-12-02 16:30:55 +110096 bp->b_flags |= XBF_STALE;
Christoph Hellwig43ff2122012-04-23 15:58:39 +100097
98 /*
99 * Clear the delwri status so that a delwri queue walker will not
100 * flush this buffer to disk now that it is stale. The delwri queue has
101 * a reference to the buffer, so this is safe to do.
102 */
103 bp->b_flags &= ~_XBF_DELWRI_Q;
104
Dave Chinnera4082352013-08-28 10:18:06 +1000105 spin_lock(&bp->b_lock);
106 atomic_set(&bp->b_lru_ref, 0);
107 if (!(bp->b_state & XFS_BSTATE_DISPOSE) &&
Dave Chinnere80dfa12013-08-28 10:18:05 +1000108 (list_lru_del(&bp->b_target->bt_lru, &bp->b_lru)))
109 atomic_dec(&bp->b_hold);
Dave Chinner430cbeb2010-12-02 16:30:55 +1100110
Dave Chinner430cbeb2010-12-02 16:30:55 +1100111 ASSERT(atomic_read(&bp->b_hold) >= 1);
Dave Chinnera4082352013-08-28 10:18:06 +1000112 spin_unlock(&bp->b_lock);
Dave Chinner430cbeb2010-12-02 16:30:55 +1100113}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114
Dave Chinner3e85c862012-06-22 18:50:09 +1000115static int
116xfs_buf_get_maps(
117 struct xfs_buf *bp,
118 int map_count)
119{
120 ASSERT(bp->b_maps == NULL);
121 bp->b_map_count = map_count;
122
123 if (map_count == 1) {
Mark Tinguelyf4b42422012-12-04 17:18:02 -0600124 bp->b_maps = &bp->__b_map;
Dave Chinner3e85c862012-06-22 18:50:09 +1000125 return 0;
126 }
127
128 bp->b_maps = kmem_zalloc(map_count * sizeof(struct xfs_buf_map),
129 KM_NOFS);
130 if (!bp->b_maps)
Dave Chinner24513372014-06-25 14:58:08 +1000131 return -ENOMEM;
Dave Chinner3e85c862012-06-22 18:50:09 +1000132 return 0;
133}
134
135/*
136 * Frees b_pages if it was allocated.
137 */
138static void
139xfs_buf_free_maps(
140 struct xfs_buf *bp)
141{
Mark Tinguelyf4b42422012-12-04 17:18:02 -0600142 if (bp->b_maps != &bp->__b_map) {
Dave Chinner3e85c862012-06-22 18:50:09 +1000143 kmem_free(bp->b_maps);
144 bp->b_maps = NULL;
145 }
146}
147
Christoph Hellwig4347b9d2011-10-10 16:52:48 +0000148struct xfs_buf *
Dave Chinner3e85c862012-06-22 18:50:09 +1000149_xfs_buf_alloc(
Christoph Hellwig4347b9d2011-10-10 16:52:48 +0000150 struct xfs_buftarg *target,
Dave Chinner3e85c862012-06-22 18:50:09 +1000151 struct xfs_buf_map *map,
152 int nmaps,
Nathan Scottce8e9222006-01-11 15:39:08 +1100153 xfs_buf_flags_t flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154{
Christoph Hellwig4347b9d2011-10-10 16:52:48 +0000155 struct xfs_buf *bp;
Dave Chinner3e85c862012-06-22 18:50:09 +1000156 int error;
157 int i;
Christoph Hellwig4347b9d2011-10-10 16:52:48 +0000158
Dave Chinneraa5c1582012-04-23 15:58:56 +1000159 bp = kmem_zone_zalloc(xfs_buf_zone, KM_NOFS);
Christoph Hellwig4347b9d2011-10-10 16:52:48 +0000160 if (unlikely(!bp))
161 return NULL;
162
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 /*
Dave Chinner12bcb3f2012-04-23 15:59:05 +1000164 * We don't want certain flags to appear in b_flags unless they are
165 * specifically set by later operations on the buffer.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 */
Dave Chinner611c9942012-04-23 15:59:07 +1000167 flags &= ~(XBF_UNMAPPED | XBF_TRYLOCK | XBF_ASYNC | XBF_READ_AHEAD);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168
Nathan Scottce8e9222006-01-11 15:39:08 +1100169 atomic_set(&bp->b_hold, 1);
Dave Chinner430cbeb2010-12-02 16:30:55 +1100170 atomic_set(&bp->b_lru_ref, 1);
David Chinnerb4dd3302008-08-13 16:36:11 +1000171 init_completion(&bp->b_iowait);
Dave Chinner430cbeb2010-12-02 16:30:55 +1100172 INIT_LIST_HEAD(&bp->b_lru);
Nathan Scottce8e9222006-01-11 15:39:08 +1100173 INIT_LIST_HEAD(&bp->b_list);
Dave Chinner74f75a02010-09-24 19:59:04 +1000174 RB_CLEAR_NODE(&bp->b_rbnode);
Thomas Gleixnera731cd12010-09-07 14:33:15 +0000175 sema_init(&bp->b_sema, 0); /* held, no waiters */
Dave Chinnera4082352013-08-28 10:18:06 +1000176 spin_lock_init(&bp->b_lock);
Nathan Scottce8e9222006-01-11 15:39:08 +1100177 XB_SET_OWNER(bp);
178 bp->b_target = target;
Dave Chinner3e85c862012-06-22 18:50:09 +1000179 bp->b_flags = flags;
Dave Chinnerde1cbee2012-04-23 15:58:50 +1000180
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 /*
Dave Chinneraa0e8832012-04-23 15:58:52 +1000182 * Set length and io_length to the same value initially.
183 * I/O routines should use io_length, which will be the same in
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 * most cases but may be reset (e.g. XFS recovery).
185 */
Dave Chinner3e85c862012-06-22 18:50:09 +1000186 error = xfs_buf_get_maps(bp, nmaps);
187 if (error) {
188 kmem_zone_free(xfs_buf_zone, bp);
189 return NULL;
190 }
191
192 bp->b_bn = map[0].bm_bn;
193 bp->b_length = 0;
194 for (i = 0; i < nmaps; i++) {
195 bp->b_maps[i].bm_bn = map[i].bm_bn;
196 bp->b_maps[i].bm_len = map[i].bm_len;
197 bp->b_length += map[i].bm_len;
198 }
199 bp->b_io_length = bp->b_length;
200
Nathan Scottce8e9222006-01-11 15:39:08 +1100201 atomic_set(&bp->b_pin_count, 0);
202 init_waitqueue_head(&bp->b_waiters);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203
Nathan Scottce8e9222006-01-11 15:39:08 +1100204 XFS_STATS_INC(xb_create);
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000205 trace_xfs_buf_init(bp, _RET_IP_);
Christoph Hellwig4347b9d2011-10-10 16:52:48 +0000206
207 return bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208}
209
210/*
Nathan Scottce8e9222006-01-11 15:39:08 +1100211 * Allocate a page array capable of holding a specified number
212 * of pages, and point the page buf at it.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 */
214STATIC int
Nathan Scottce8e9222006-01-11 15:39:08 +1100215_xfs_buf_get_pages(
216 xfs_buf_t *bp,
Eric Sandeen87937bf2014-04-14 19:01:20 +1000217 int page_count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218{
219 /* Make sure that we have a page list */
Nathan Scottce8e9222006-01-11 15:39:08 +1100220 if (bp->b_pages == NULL) {
Nathan Scottce8e9222006-01-11 15:39:08 +1100221 bp->b_page_count = page_count;
222 if (page_count <= XB_PAGES) {
223 bp->b_pages = bp->b_page_array;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 } else {
Nathan Scottce8e9222006-01-11 15:39:08 +1100225 bp->b_pages = kmem_alloc(sizeof(struct page *) *
Dave Chinneraa5c1582012-04-23 15:58:56 +1000226 page_count, KM_NOFS);
Nathan Scottce8e9222006-01-11 15:39:08 +1100227 if (bp->b_pages == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 return -ENOMEM;
229 }
Nathan Scottce8e9222006-01-11 15:39:08 +1100230 memset(bp->b_pages, 0, sizeof(struct page *) * page_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 }
232 return 0;
233}
234
235/*
Nathan Scottce8e9222006-01-11 15:39:08 +1100236 * Frees b_pages if it was allocated.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 */
238STATIC void
Nathan Scottce8e9222006-01-11 15:39:08 +1100239_xfs_buf_free_pages(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 xfs_buf_t *bp)
241{
Nathan Scottce8e9222006-01-11 15:39:08 +1100242 if (bp->b_pages != bp->b_page_array) {
Denys Vlasenkof0e2d932008-05-19 16:31:57 +1000243 kmem_free(bp->b_pages);
Dave Chinner3fc98b12009-12-14 23:11:57 +0000244 bp->b_pages = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 }
246}
247
248/*
249 * Releases the specified buffer.
250 *
251 * The modification state of any associated pages is left unchanged.
Zhi Yong Wub46fe822013-08-07 10:10:59 +0000252 * The buffer must not be on any hash - use xfs_buf_rele instead for
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 * hashed and refcounted buffers
254 */
255void
Nathan Scottce8e9222006-01-11 15:39:08 +1100256xfs_buf_free(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 xfs_buf_t *bp)
258{
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000259 trace_xfs_buf_free(bp, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260
Dave Chinner430cbeb2010-12-02 16:30:55 +1100261 ASSERT(list_empty(&bp->b_lru));
262
Dave Chinner0e6e8472011-03-26 09:16:45 +1100263 if (bp->b_flags & _XBF_PAGES) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 uint i;
265
James Bottomley73c77e22010-01-25 11:42:24 -0600266 if (xfs_buf_is_vmapped(bp))
Alex Elder8a262e52010-03-16 18:55:56 +0000267 vm_unmap_ram(bp->b_addr - bp->b_offset,
268 bp->b_page_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269
Nathan Scott948ecdb2006-09-28 11:03:13 +1000270 for (i = 0; i < bp->b_page_count; i++) {
271 struct page *page = bp->b_pages[i];
272
Dave Chinner0e6e8472011-03-26 09:16:45 +1100273 __free_page(page);
Nathan Scott948ecdb2006-09-28 11:03:13 +1000274 }
Dave Chinner0e6e8472011-03-26 09:16:45 +1100275 } else if (bp->b_flags & _XBF_KMEM)
276 kmem_free(bp->b_addr);
Dave Chinner3fc98b12009-12-14 23:11:57 +0000277 _xfs_buf_free_pages(bp);
Dave Chinner3e85c862012-06-22 18:50:09 +1000278 xfs_buf_free_maps(bp);
Christoph Hellwig4347b9d2011-10-10 16:52:48 +0000279 kmem_zone_free(xfs_buf_zone, bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280}
281
282/*
Dave Chinner0e6e8472011-03-26 09:16:45 +1100283 * Allocates all the pages for buffer in question and builds it's page list.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 */
285STATIC int
Dave Chinner0e6e8472011-03-26 09:16:45 +1100286xfs_buf_allocate_memory(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 xfs_buf_t *bp,
288 uint flags)
289{
Dave Chinneraa0e8832012-04-23 15:58:52 +1000290 size_t size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 size_t nbytes, offset;
Nathan Scottce8e9222006-01-11 15:39:08 +1100292 gfp_t gfp_mask = xb_to_gfp(flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 unsigned short page_count, i;
Dave Chinner795cac72012-04-23 15:58:53 +1000294 xfs_off_t start, end;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 int error;
296
Dave Chinner0e6e8472011-03-26 09:16:45 +1100297 /*
298 * for buffers that are contained within a single page, just allocate
299 * the memory from the heap - there's no need for the complexity of
300 * page arrays to keep allocation down to order 0.
301 */
Dave Chinner795cac72012-04-23 15:58:53 +1000302 size = BBTOB(bp->b_length);
303 if (size < PAGE_SIZE) {
Dave Chinneraa5c1582012-04-23 15:58:56 +1000304 bp->b_addr = kmem_alloc(size, KM_NOFS);
Dave Chinner0e6e8472011-03-26 09:16:45 +1100305 if (!bp->b_addr) {
306 /* low memory - use alloc_page loop instead */
307 goto use_alloc_page;
308 }
309
Dave Chinner795cac72012-04-23 15:58:53 +1000310 if (((unsigned long)(bp->b_addr + size - 1) & PAGE_MASK) !=
Dave Chinner0e6e8472011-03-26 09:16:45 +1100311 ((unsigned long)bp->b_addr & PAGE_MASK)) {
312 /* b_addr spans two pages - use alloc_page instead */
313 kmem_free(bp->b_addr);
314 bp->b_addr = NULL;
315 goto use_alloc_page;
316 }
317 bp->b_offset = offset_in_page(bp->b_addr);
318 bp->b_pages = bp->b_page_array;
319 bp->b_pages[0] = virt_to_page(bp->b_addr);
320 bp->b_page_count = 1;
Dave Chinner611c9942012-04-23 15:59:07 +1000321 bp->b_flags |= _XBF_KMEM;
Dave Chinner0e6e8472011-03-26 09:16:45 +1100322 return 0;
323 }
324
325use_alloc_page:
Mark Tinguelyf4b42422012-12-04 17:18:02 -0600326 start = BBTOB(bp->b_maps[0].bm_bn) >> PAGE_SHIFT;
327 end = (BBTOB(bp->b_maps[0].bm_bn + bp->b_length) + PAGE_SIZE - 1)
Dave Chinnercbb7baab2012-06-22 18:50:08 +1000328 >> PAGE_SHIFT;
Dave Chinner795cac72012-04-23 15:58:53 +1000329 page_count = end - start;
Eric Sandeen87937bf2014-04-14 19:01:20 +1000330 error = _xfs_buf_get_pages(bp, page_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 if (unlikely(error))
332 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333
Nathan Scottce8e9222006-01-11 15:39:08 +1100334 offset = bp->b_offset;
Dave Chinner0e6e8472011-03-26 09:16:45 +1100335 bp->b_flags |= _XBF_PAGES;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336
Nathan Scottce8e9222006-01-11 15:39:08 +1100337 for (i = 0; i < bp->b_page_count; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 struct page *page;
339 uint retries = 0;
Dave Chinner0e6e8472011-03-26 09:16:45 +1100340retry:
341 page = alloc_page(gfp_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 if (unlikely(page == NULL)) {
Nathan Scottce8e9222006-01-11 15:39:08 +1100343 if (flags & XBF_READ_AHEAD) {
344 bp->b_page_count = i;
Dave Chinner24513372014-06-25 14:58:08 +1000345 error = -ENOMEM;
Dave Chinner0e6e8472011-03-26 09:16:45 +1100346 goto out_free_pages;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 }
348
349 /*
350 * This could deadlock.
351 *
352 * But until all the XFS lowlevel code is revamped to
353 * handle buffer allocation failures we can't do much.
354 */
355 if (!(++retries % 100))
Dave Chinner4f107002011-03-07 10:00:35 +1100356 xfs_err(NULL,
357 "possible memory allocation deadlock in %s (mode:0x%x)",
Harvey Harrison34a622b2008-04-10 12:19:21 +1000358 __func__, gfp_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359
Nathan Scottce8e9222006-01-11 15:39:08 +1100360 XFS_STATS_INC(xb_page_retries);
Jens Axboe8aa7e842009-07-09 14:52:32 +0200361 congestion_wait(BLK_RW_ASYNC, HZ/50);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 goto retry;
363 }
364
Nathan Scottce8e9222006-01-11 15:39:08 +1100365 XFS_STATS_INC(xb_page_found);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366
Dave Chinner0e6e8472011-03-26 09:16:45 +1100367 nbytes = min_t(size_t, size, PAGE_SIZE - offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 size -= nbytes;
Nathan Scottce8e9222006-01-11 15:39:08 +1100369 bp->b_pages[i] = page;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 offset = 0;
371 }
Dave Chinner0e6e8472011-03-26 09:16:45 +1100372 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373
Dave Chinner0e6e8472011-03-26 09:16:45 +1100374out_free_pages:
375 for (i = 0; i < bp->b_page_count; i++)
376 __free_page(bp->b_pages[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 return error;
378}
379
380/*
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300381 * Map buffer into kernel address-space if necessary.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 */
383STATIC int
Nathan Scottce8e9222006-01-11 15:39:08 +1100384_xfs_buf_map_pages(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385 xfs_buf_t *bp,
386 uint flags)
387{
Dave Chinner0e6e8472011-03-26 09:16:45 +1100388 ASSERT(bp->b_flags & _XBF_PAGES);
Nathan Scottce8e9222006-01-11 15:39:08 +1100389 if (bp->b_page_count == 1) {
Dave Chinner0e6e8472011-03-26 09:16:45 +1100390 /* A single page buffer is always mappable */
Nathan Scottce8e9222006-01-11 15:39:08 +1100391 bp->b_addr = page_address(bp->b_pages[0]) + bp->b_offset;
Dave Chinner611c9942012-04-23 15:59:07 +1000392 } else if (flags & XBF_UNMAPPED) {
393 bp->b_addr = NULL;
394 } else {
Dave Chinnera19fb382011-03-26 09:13:42 +1100395 int retried = 0;
Dave Chinnerae687e52014-03-07 16:19:14 +1100396 unsigned noio_flag;
Dave Chinnera19fb382011-03-26 09:13:42 +1100397
Dave Chinnerae687e52014-03-07 16:19:14 +1100398 /*
399 * vm_map_ram() will allocate auxillary structures (e.g.
400 * pagetables) with GFP_KERNEL, yet we are likely to be under
401 * GFP_NOFS context here. Hence we need to tell memory reclaim
402 * that we are in such a context via PF_MEMALLOC_NOIO to prevent
403 * memory reclaim re-entering the filesystem here and
404 * potentially deadlocking.
405 */
406 noio_flag = memalloc_noio_save();
Dave Chinnera19fb382011-03-26 09:13:42 +1100407 do {
408 bp->b_addr = vm_map_ram(bp->b_pages, bp->b_page_count,
409 -1, PAGE_KERNEL);
410 if (bp->b_addr)
411 break;
412 vm_unmap_aliases();
413 } while (retried++ <= 1);
Dave Chinnerae687e52014-03-07 16:19:14 +1100414 memalloc_noio_restore(noio_flag);
Dave Chinnera19fb382011-03-26 09:13:42 +1100415
416 if (!bp->b_addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 return -ENOMEM;
Nathan Scottce8e9222006-01-11 15:39:08 +1100418 bp->b_addr += bp->b_offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 }
420
421 return 0;
422}
423
424/*
425 * Finding and Reading Buffers
426 */
427
428/*
Nathan Scottce8e9222006-01-11 15:39:08 +1100429 * Look up, and creates if absent, a lockable buffer for
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 * a given range of an inode. The buffer is returned
Chandra Seetharamaneabbaf12011-09-08 20:18:50 +0000431 * locked. No I/O is implied by this call.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 */
433xfs_buf_t *
Nathan Scottce8e9222006-01-11 15:39:08 +1100434_xfs_buf_find(
Dave Chinnere70b73f2012-04-23 15:58:49 +1000435 struct xfs_buftarg *btp,
Dave Chinner3e85c862012-06-22 18:50:09 +1000436 struct xfs_buf_map *map,
437 int nmaps,
Nathan Scottce8e9222006-01-11 15:39:08 +1100438 xfs_buf_flags_t flags,
439 xfs_buf_t *new_bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440{
Dave Chinnere70b73f2012-04-23 15:58:49 +1000441 size_t numbytes;
Dave Chinner74f75a02010-09-24 19:59:04 +1000442 struct xfs_perag *pag;
443 struct rb_node **rbp;
444 struct rb_node *parent;
445 xfs_buf_t *bp;
Dave Chinner3e85c862012-06-22 18:50:09 +1000446 xfs_daddr_t blkno = map[0].bm_bn;
Dave Chinner10616b82013-01-21 23:53:52 +1100447 xfs_daddr_t eofs;
Dave Chinner3e85c862012-06-22 18:50:09 +1000448 int numblks = 0;
449 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450
Dave Chinner3e85c862012-06-22 18:50:09 +1000451 for (i = 0; i < nmaps; i++)
452 numblks += map[i].bm_len;
Dave Chinnere70b73f2012-04-23 15:58:49 +1000453 numbytes = BBTOB(numblks);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454
455 /* Check for IOs smaller than the sector size / not sector aligned */
Eric Sandeen6da54172014-01-21 16:45:52 -0600456 ASSERT(!(numbytes < btp->bt_meta_sectorsize));
457 ASSERT(!(BBTOB(blkno) & (xfs_off_t)btp->bt_meta_sectormask));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458
Dave Chinner10616b82013-01-21 23:53:52 +1100459 /*
460 * Corrupted block numbers can get through to here, unfortunately, so we
461 * have to check that the buffer falls within the filesystem bounds.
462 */
463 eofs = XFS_FSB_TO_BB(btp->bt_mount, btp->bt_mount->m_sb.sb_dblocks);
Eric Sandeendb52d092014-11-28 14:03:55 +1100464 if (blkno < 0 || blkno >= eofs) {
Dave Chinner10616b82013-01-21 23:53:52 +1100465 /*
Dave Chinner24513372014-06-25 14:58:08 +1000466 * XXX (dgc): we should really be returning -EFSCORRUPTED here,
Dave Chinner10616b82013-01-21 23:53:52 +1100467 * but none of the higher level infrastructure supports
468 * returning a specific error on buffer lookup failures.
469 */
470 xfs_alert(btp->bt_mount,
471 "%s: Block out of range: block 0x%llx, EOFS 0x%llx ",
472 __func__, blkno, eofs);
Dave Chinner7bc0dc22013-05-21 18:02:08 +1000473 WARN_ON(1);
Dave Chinner10616b82013-01-21 23:53:52 +1100474 return NULL;
475 }
476
Dave Chinner74f75a02010-09-24 19:59:04 +1000477 /* get tree root */
478 pag = xfs_perag_get(btp->bt_mount,
Dave Chinnere70b73f2012-04-23 15:58:49 +1000479 xfs_daddr_to_agno(btp->bt_mount, blkno));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480
Dave Chinner74f75a02010-09-24 19:59:04 +1000481 /* walk tree */
482 spin_lock(&pag->pag_buf_lock);
483 rbp = &pag->pag_buf_tree.rb_node;
484 parent = NULL;
485 bp = NULL;
486 while (*rbp) {
487 parent = *rbp;
488 bp = rb_entry(parent, struct xfs_buf, b_rbnode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489
Dave Chinnerde1cbee2012-04-23 15:58:50 +1000490 if (blkno < bp->b_bn)
Dave Chinner74f75a02010-09-24 19:59:04 +1000491 rbp = &(*rbp)->rb_left;
Dave Chinnerde1cbee2012-04-23 15:58:50 +1000492 else if (blkno > bp->b_bn)
Dave Chinner74f75a02010-09-24 19:59:04 +1000493 rbp = &(*rbp)->rb_right;
494 else {
495 /*
Dave Chinnerde1cbee2012-04-23 15:58:50 +1000496 * found a block number match. If the range doesn't
Dave Chinner74f75a02010-09-24 19:59:04 +1000497 * match, the only way this is allowed is if the buffer
498 * in the cache is stale and the transaction that made
499 * it stale has not yet committed. i.e. we are
500 * reallocating a busy extent. Skip this buffer and
501 * continue searching to the right for an exact match.
502 */
Dave Chinner4e94b712012-04-23 15:58:51 +1000503 if (bp->b_length != numblks) {
Dave Chinner74f75a02010-09-24 19:59:04 +1000504 ASSERT(bp->b_flags & XBF_STALE);
505 rbp = &(*rbp)->rb_right;
506 continue;
507 }
Nathan Scottce8e9222006-01-11 15:39:08 +1100508 atomic_inc(&bp->b_hold);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 goto found;
510 }
511 }
512
513 /* No match found */
Nathan Scottce8e9222006-01-11 15:39:08 +1100514 if (new_bp) {
Dave Chinner74f75a02010-09-24 19:59:04 +1000515 rb_link_node(&new_bp->b_rbnode, parent, rbp);
516 rb_insert_color(&new_bp->b_rbnode, &pag->pag_buf_tree);
517 /* the buffer keeps the perag reference until it is freed */
518 new_bp->b_pag = pag;
519 spin_unlock(&pag->pag_buf_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 } else {
Nathan Scottce8e9222006-01-11 15:39:08 +1100521 XFS_STATS_INC(xb_miss_locked);
Dave Chinner74f75a02010-09-24 19:59:04 +1000522 spin_unlock(&pag->pag_buf_lock);
523 xfs_perag_put(pag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 }
Nathan Scottce8e9222006-01-11 15:39:08 +1100525 return new_bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526
527found:
Dave Chinner74f75a02010-09-24 19:59:04 +1000528 spin_unlock(&pag->pag_buf_lock);
529 xfs_perag_put(pag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530
Christoph Hellwig0c842ad2011-07-08 14:36:19 +0200531 if (!xfs_buf_trylock(bp)) {
532 if (flags & XBF_TRYLOCK) {
Nathan Scottce8e9222006-01-11 15:39:08 +1100533 xfs_buf_rele(bp);
534 XFS_STATS_INC(xb_busy_locked);
535 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 }
Christoph Hellwig0c842ad2011-07-08 14:36:19 +0200537 xfs_buf_lock(bp);
538 XFS_STATS_INC(xb_get_locked_waited);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 }
540
Dave Chinner0e6e8472011-03-26 09:16:45 +1100541 /*
542 * if the buffer is stale, clear all the external state associated with
543 * it. We need to keep flags such as how we allocated the buffer memory
544 * intact here.
545 */
Nathan Scottce8e9222006-01-11 15:39:08 +1100546 if (bp->b_flags & XBF_STALE) {
547 ASSERT((bp->b_flags & _XBF_DELWRI_Q) == 0);
Dave Chinnercfb02852012-11-12 22:54:19 +1100548 ASSERT(bp->b_iodone == NULL);
Dave Chinner611c9942012-04-23 15:59:07 +1000549 bp->b_flags &= _XBF_KMEM | _XBF_PAGES;
Dave Chinner1813dd62012-11-14 17:54:40 +1100550 bp->b_ops = NULL;
David Chinner2f926582005-09-05 08:33:35 +1000551 }
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000552
553 trace_xfs_buf_find(bp, flags, _RET_IP_);
Nathan Scottce8e9222006-01-11 15:39:08 +1100554 XFS_STATS_INC(xb_get_locked);
555 return bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556}
557
558/*
Dave Chinner38158322011-09-30 04:45:02 +0000559 * Assembles a buffer covering the specified range. The code is optimised for
560 * cache hits, as metadata intensive workloads will see 3 orders of magnitude
561 * more hits than misses.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 */
Dave Chinner38158322011-09-30 04:45:02 +0000563struct xfs_buf *
Dave Chinner6dde2702012-06-22 18:50:10 +1000564xfs_buf_get_map(
565 struct xfs_buftarg *target,
566 struct xfs_buf_map *map,
567 int nmaps,
Nathan Scottce8e9222006-01-11 15:39:08 +1100568 xfs_buf_flags_t flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569{
Dave Chinner38158322011-09-30 04:45:02 +0000570 struct xfs_buf *bp;
571 struct xfs_buf *new_bp;
Dave Chinner0e6e8472011-03-26 09:16:45 +1100572 int error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573
Dave Chinner6dde2702012-06-22 18:50:10 +1000574 bp = _xfs_buf_find(target, map, nmaps, flags, NULL);
Dave Chinner38158322011-09-30 04:45:02 +0000575 if (likely(bp))
576 goto found;
577
Dave Chinner6dde2702012-06-22 18:50:10 +1000578 new_bp = _xfs_buf_alloc(target, map, nmaps, flags);
Nathan Scottce8e9222006-01-11 15:39:08 +1100579 if (unlikely(!new_bp))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 return NULL;
581
Dave Chinnerfe2429b2012-04-23 15:58:45 +1000582 error = xfs_buf_allocate_memory(new_bp, flags);
583 if (error) {
Dave Chinner3e85c862012-06-22 18:50:09 +1000584 xfs_buf_free(new_bp);
Dave Chinner38158322011-09-30 04:45:02 +0000585 return NULL;
586 }
587
Dave Chinner6dde2702012-06-22 18:50:10 +1000588 bp = _xfs_buf_find(target, map, nmaps, flags, new_bp);
Dave Chinnerfe2429b2012-04-23 15:58:45 +1000589 if (!bp) {
590 xfs_buf_free(new_bp);
591 return NULL;
592 }
593
594 if (bp != new_bp)
595 xfs_buf_free(new_bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596
Dave Chinner38158322011-09-30 04:45:02 +0000597found:
Dave Chinner611c9942012-04-23 15:59:07 +1000598 if (!bp->b_addr) {
Nathan Scottce8e9222006-01-11 15:39:08 +1100599 error = _xfs_buf_map_pages(bp, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 if (unlikely(error)) {
Dave Chinner4f107002011-03-07 10:00:35 +1100601 xfs_warn(target->bt_mount,
Eric Sandeen08e96e12013-10-11 20:59:05 -0500602 "%s: failed to map pagesn", __func__);
Dave Chinnera8acad72012-04-23 15:58:54 +1000603 xfs_buf_relse(bp);
604 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 }
606 }
607
Nathan Scottce8e9222006-01-11 15:39:08 +1100608 XFS_STATS_INC(xb_get);
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000609 trace_xfs_buf_get(bp, flags, _RET_IP_);
Nathan Scottce8e9222006-01-11 15:39:08 +1100610 return bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611}
612
Christoph Hellwig5d765b92008-12-03 12:20:26 +0100613STATIC int
614_xfs_buf_read(
615 xfs_buf_t *bp,
616 xfs_buf_flags_t flags)
617{
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000618 ASSERT(!(flags & XBF_WRITE));
Mark Tinguelyf4b42422012-12-04 17:18:02 -0600619 ASSERT(bp->b_maps[0].bm_bn != XFS_BUF_DADDR_NULL);
Christoph Hellwig5d765b92008-12-03 12:20:26 +0100620
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000621 bp->b_flags &= ~(XBF_WRITE | XBF_ASYNC | XBF_READ_AHEAD);
Christoph Hellwig1d5ae5d2011-07-08 14:36:32 +0200622 bp->b_flags |= flags & (XBF_READ | XBF_ASYNC | XBF_READ_AHEAD);
Christoph Hellwig5d765b92008-12-03 12:20:26 +0100623
Dave Chinner595bff72014-10-02 09:05:14 +1000624 if (flags & XBF_ASYNC) {
625 xfs_buf_submit(bp);
Dave Chinner0e95f192012-04-23 15:58:46 +1000626 return 0;
Dave Chinner595bff72014-10-02 09:05:14 +1000627 }
628 return xfs_buf_submit_wait(bp);
Christoph Hellwig5d765b92008-12-03 12:20:26 +0100629}
630
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631xfs_buf_t *
Dave Chinner6dde2702012-06-22 18:50:10 +1000632xfs_buf_read_map(
633 struct xfs_buftarg *target,
634 struct xfs_buf_map *map,
635 int nmaps,
Dave Chinnerc3f8fc72012-11-12 22:54:01 +1100636 xfs_buf_flags_t flags,
Dave Chinner1813dd62012-11-14 17:54:40 +1100637 const struct xfs_buf_ops *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638{
Dave Chinner6dde2702012-06-22 18:50:10 +1000639 struct xfs_buf *bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640
Nathan Scottce8e9222006-01-11 15:39:08 +1100641 flags |= XBF_READ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642
Dave Chinner6dde2702012-06-22 18:50:10 +1000643 bp = xfs_buf_get_map(target, map, nmaps, flags);
Nathan Scottce8e9222006-01-11 15:39:08 +1100644 if (bp) {
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000645 trace_xfs_buf_read(bp, flags, _RET_IP_);
646
Nathan Scottce8e9222006-01-11 15:39:08 +1100647 if (!XFS_BUF_ISDONE(bp)) {
Nathan Scottce8e9222006-01-11 15:39:08 +1100648 XFS_STATS_INC(xb_get_read);
Dave Chinner1813dd62012-11-14 17:54:40 +1100649 bp->b_ops = ops;
Christoph Hellwig5d765b92008-12-03 12:20:26 +0100650 _xfs_buf_read(bp, flags);
Nathan Scottce8e9222006-01-11 15:39:08 +1100651 } else if (flags & XBF_ASYNC) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652 /*
653 * Read ahead call which is already satisfied,
654 * drop the buffer
655 */
Dave Chinnera8acad72012-04-23 15:58:54 +1000656 xfs_buf_relse(bp);
657 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659 /* We do not want read in the flags */
Nathan Scottce8e9222006-01-11 15:39:08 +1100660 bp->b_flags &= ~XBF_READ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 }
662 }
663
Nathan Scottce8e9222006-01-11 15:39:08 +1100664 return bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665}
666
667/*
Nathan Scottce8e9222006-01-11 15:39:08 +1100668 * If we are not low on memory then do the readahead in a deadlock
669 * safe manner.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 */
671void
Dave Chinner6dde2702012-06-22 18:50:10 +1000672xfs_buf_readahead_map(
673 struct xfs_buftarg *target,
674 struct xfs_buf_map *map,
Dave Chinnerc3f8fc72012-11-12 22:54:01 +1100675 int nmaps,
Dave Chinner1813dd62012-11-14 17:54:40 +1100676 const struct xfs_buf_ops *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677{
Dave Chinner0e6e8472011-03-26 09:16:45 +1100678 if (bdi_read_congested(target->bt_bdi))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679 return;
680
Dave Chinner6dde2702012-06-22 18:50:10 +1000681 xfs_buf_read_map(target, map, nmaps,
Dave Chinner1813dd62012-11-14 17:54:40 +1100682 XBF_TRYLOCK|XBF_ASYNC|XBF_READ_AHEAD, ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683}
684
Dave Chinner5adc94c2010-09-24 21:58:31 +1000685/*
686 * Read an uncached buffer from disk. Allocates and returns a locked
687 * buffer containing the disk contents or nothing.
688 */
Dave Chinnerba372672014-10-02 09:05:32 +1000689int
Dave Chinner5adc94c2010-09-24 21:58:31 +1000690xfs_buf_read_uncached(
Dave Chinner5adc94c2010-09-24 21:58:31 +1000691 struct xfs_buftarg *target,
692 xfs_daddr_t daddr,
Dave Chinnere70b73f2012-04-23 15:58:49 +1000693 size_t numblks,
Dave Chinnerc3f8fc72012-11-12 22:54:01 +1100694 int flags,
Dave Chinnerba372672014-10-02 09:05:32 +1000695 struct xfs_buf **bpp,
Dave Chinner1813dd62012-11-14 17:54:40 +1100696 const struct xfs_buf_ops *ops)
Dave Chinner5adc94c2010-09-24 21:58:31 +1000697{
Dave Chinnereab4e632012-11-12 22:54:02 +1100698 struct xfs_buf *bp;
Dave Chinner5adc94c2010-09-24 21:58:31 +1000699
Dave Chinnerba372672014-10-02 09:05:32 +1000700 *bpp = NULL;
701
Dave Chinnere70b73f2012-04-23 15:58:49 +1000702 bp = xfs_buf_get_uncached(target, numblks, flags);
Dave Chinner5adc94c2010-09-24 21:58:31 +1000703 if (!bp)
Dave Chinnerba372672014-10-02 09:05:32 +1000704 return -ENOMEM;
Dave Chinner5adc94c2010-09-24 21:58:31 +1000705
706 /* set up the buffer for a read IO */
Dave Chinner3e85c862012-06-22 18:50:09 +1000707 ASSERT(bp->b_map_count == 1);
Dave Chinnerba372672014-10-02 09:05:32 +1000708 bp->b_bn = XFS_BUF_DADDR_NULL; /* always null for uncached buffers */
Dave Chinner3e85c862012-06-22 18:50:09 +1000709 bp->b_maps[0].bm_bn = daddr;
Dave Chinnercbb7baab2012-06-22 18:50:08 +1000710 bp->b_flags |= XBF_READ;
Dave Chinner1813dd62012-11-14 17:54:40 +1100711 bp->b_ops = ops;
Dave Chinner5adc94c2010-09-24 21:58:31 +1000712
Dave Chinner595bff72014-10-02 09:05:14 +1000713 xfs_buf_submit_wait(bp);
Dave Chinnerba372672014-10-02 09:05:32 +1000714 if (bp->b_error) {
715 int error = bp->b_error;
Christoph Hellwig83a0adc2013-12-17 00:03:52 -0800716 xfs_buf_relse(bp);
Dave Chinnerba372672014-10-02 09:05:32 +1000717 return error;
Christoph Hellwig83a0adc2013-12-17 00:03:52 -0800718 }
Dave Chinnerba372672014-10-02 09:05:32 +1000719
720 *bpp = bp;
721 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722}
723
Dave Chinner44396472011-04-21 09:34:27 +0000724/*
725 * Return a buffer allocated as an empty buffer and associated to external
726 * memory via xfs_buf_associate_memory() back to it's empty state.
727 */
728void
729xfs_buf_set_empty(
730 struct xfs_buf *bp,
Dave Chinnere70b73f2012-04-23 15:58:49 +1000731 size_t numblks)
Dave Chinner44396472011-04-21 09:34:27 +0000732{
733 if (bp->b_pages)
734 _xfs_buf_free_pages(bp);
735
736 bp->b_pages = NULL;
737 bp->b_page_count = 0;
738 bp->b_addr = NULL;
Dave Chinner4e94b712012-04-23 15:58:51 +1000739 bp->b_length = numblks;
Dave Chinneraa0e8832012-04-23 15:58:52 +1000740 bp->b_io_length = numblks;
Dave Chinner3e85c862012-06-22 18:50:09 +1000741
742 ASSERT(bp->b_map_count == 1);
Dave Chinner44396472011-04-21 09:34:27 +0000743 bp->b_bn = XFS_BUF_DADDR_NULL;
Dave Chinner3e85c862012-06-22 18:50:09 +1000744 bp->b_maps[0].bm_bn = XFS_BUF_DADDR_NULL;
745 bp->b_maps[0].bm_len = bp->b_length;
Dave Chinner44396472011-04-21 09:34:27 +0000746}
747
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748static inline struct page *
749mem_to_page(
750 void *addr)
751{
Christoph Lameter9e2779f2008-02-04 22:28:34 -0800752 if ((!is_vmalloc_addr(addr))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 return virt_to_page(addr);
754 } else {
755 return vmalloc_to_page(addr);
756 }
757}
758
759int
Nathan Scottce8e9222006-01-11 15:39:08 +1100760xfs_buf_associate_memory(
761 xfs_buf_t *bp,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 void *mem,
763 size_t len)
764{
765 int rval;
766 int i = 0;
Lachlan McIlroyd1afb672007-11-27 17:01:24 +1100767 unsigned long pageaddr;
768 unsigned long offset;
769 size_t buflen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 int page_count;
771
Dave Chinner0e6e8472011-03-26 09:16:45 +1100772 pageaddr = (unsigned long)mem & PAGE_MASK;
Lachlan McIlroyd1afb672007-11-27 17:01:24 +1100773 offset = (unsigned long)mem - pageaddr;
Dave Chinner0e6e8472011-03-26 09:16:45 +1100774 buflen = PAGE_ALIGN(len + offset);
775 page_count = buflen >> PAGE_SHIFT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776
777 /* Free any previous set of page pointers */
Nathan Scottce8e9222006-01-11 15:39:08 +1100778 if (bp->b_pages)
779 _xfs_buf_free_pages(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780
Nathan Scottce8e9222006-01-11 15:39:08 +1100781 bp->b_pages = NULL;
782 bp->b_addr = mem;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783
Eric Sandeen87937bf2014-04-14 19:01:20 +1000784 rval = _xfs_buf_get_pages(bp, page_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785 if (rval)
786 return rval;
787
Nathan Scottce8e9222006-01-11 15:39:08 +1100788 bp->b_offset = offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789
Lachlan McIlroyd1afb672007-11-27 17:01:24 +1100790 for (i = 0; i < bp->b_page_count; i++) {
791 bp->b_pages[i] = mem_to_page((void *)pageaddr);
Dave Chinner0e6e8472011-03-26 09:16:45 +1100792 pageaddr += PAGE_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794
Dave Chinneraa0e8832012-04-23 15:58:52 +1000795 bp->b_io_length = BTOBB(len);
Dave Chinner4e94b712012-04-23 15:58:51 +1000796 bp->b_length = BTOBB(buflen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797
798 return 0;
799}
800
801xfs_buf_t *
Dave Chinner686865f2010-09-24 20:07:47 +1000802xfs_buf_get_uncached(
803 struct xfs_buftarg *target,
Dave Chinnere70b73f2012-04-23 15:58:49 +1000804 size_t numblks,
Dave Chinner686865f2010-09-24 20:07:47 +1000805 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806{
Dave Chinnere70b73f2012-04-23 15:58:49 +1000807 unsigned long page_count;
Christoph Hellwig1fa40b02007-05-14 18:23:50 +1000808 int error, i;
Dave Chinner3e85c862012-06-22 18:50:09 +1000809 struct xfs_buf *bp;
810 DEFINE_SINGLE_BUF_MAP(map, XFS_BUF_DADDR_NULL, numblks);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811
Dave Chinner3e85c862012-06-22 18:50:09 +1000812 bp = _xfs_buf_alloc(target, &map, 1, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 if (unlikely(bp == NULL))
814 goto fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815
Dave Chinnere70b73f2012-04-23 15:58:49 +1000816 page_count = PAGE_ALIGN(numblks << BBSHIFT) >> PAGE_SHIFT;
Eric Sandeen87937bf2014-04-14 19:01:20 +1000817 error = _xfs_buf_get_pages(bp, page_count);
Christoph Hellwig1fa40b02007-05-14 18:23:50 +1000818 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819 goto fail_free_buf;
820
Christoph Hellwig1fa40b02007-05-14 18:23:50 +1000821 for (i = 0; i < page_count; i++) {
Dave Chinner686865f2010-09-24 20:07:47 +1000822 bp->b_pages[i] = alloc_page(xb_to_gfp(flags));
Christoph Hellwig1fa40b02007-05-14 18:23:50 +1000823 if (!bp->b_pages[i])
824 goto fail_free_mem;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825 }
Christoph Hellwig1fa40b02007-05-14 18:23:50 +1000826 bp->b_flags |= _XBF_PAGES;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827
Dave Chinner611c9942012-04-23 15:59:07 +1000828 error = _xfs_buf_map_pages(bp, 0);
Christoph Hellwig1fa40b02007-05-14 18:23:50 +1000829 if (unlikely(error)) {
Dave Chinner4f107002011-03-07 10:00:35 +1100830 xfs_warn(target->bt_mount,
Eric Sandeen08e96e12013-10-11 20:59:05 -0500831 "%s: failed to map pages", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 goto fail_free_mem;
Christoph Hellwig1fa40b02007-05-14 18:23:50 +1000833 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834
Dave Chinner686865f2010-09-24 20:07:47 +1000835 trace_xfs_buf_get_uncached(bp, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836 return bp;
Christoph Hellwig1fa40b02007-05-14 18:23:50 +1000837
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 fail_free_mem:
Christoph Hellwig1fa40b02007-05-14 18:23:50 +1000839 while (--i >= 0)
840 __free_page(bp->b_pages[i]);
Christoph Hellwigca165b82007-05-24 15:21:11 +1000841 _xfs_buf_free_pages(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 fail_free_buf:
Dave Chinner3e85c862012-06-22 18:50:09 +1000843 xfs_buf_free_maps(bp);
Christoph Hellwig4347b9d2011-10-10 16:52:48 +0000844 kmem_zone_free(xfs_buf_zone, bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845 fail:
846 return NULL;
847}
848
849/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 * Increment reference count on buffer, to hold the buffer concurrently
851 * with another thread which may release (free) the buffer asynchronously.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 * Must hold the buffer already to call this function.
853 */
854void
Nathan Scottce8e9222006-01-11 15:39:08 +1100855xfs_buf_hold(
856 xfs_buf_t *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857{
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000858 trace_xfs_buf_hold(bp, _RET_IP_);
Nathan Scottce8e9222006-01-11 15:39:08 +1100859 atomic_inc(&bp->b_hold);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860}
861
862/*
Nathan Scottce8e9222006-01-11 15:39:08 +1100863 * Releases a hold on the specified buffer. If the
864 * the hold count is 1, calls xfs_buf_free.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 */
866void
Nathan Scottce8e9222006-01-11 15:39:08 +1100867xfs_buf_rele(
868 xfs_buf_t *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869{
Dave Chinner74f75a02010-09-24 19:59:04 +1000870 struct xfs_perag *pag = bp->b_pag;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000872 trace_xfs_buf_rele(bp, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873
Dave Chinner74f75a02010-09-24 19:59:04 +1000874 if (!pag) {
Dave Chinner430cbeb2010-12-02 16:30:55 +1100875 ASSERT(list_empty(&bp->b_lru));
Dave Chinner74f75a02010-09-24 19:59:04 +1000876 ASSERT(RB_EMPTY_NODE(&bp->b_rbnode));
Nathan Scottfad3aa12006-02-01 12:14:52 +1100877 if (atomic_dec_and_test(&bp->b_hold))
878 xfs_buf_free(bp);
879 return;
880 }
881
Dave Chinner74f75a02010-09-24 19:59:04 +1000882 ASSERT(!RB_EMPTY_NODE(&bp->b_rbnode));
Dave Chinner430cbeb2010-12-02 16:30:55 +1100883
Lachlan McIlroy37906892008-08-13 15:42:10 +1000884 ASSERT(atomic_read(&bp->b_hold) > 0);
Dave Chinner74f75a02010-09-24 19:59:04 +1000885 if (atomic_dec_and_lock(&bp->b_hold, &pag->pag_buf_lock)) {
Dave Chinnera4082352013-08-28 10:18:06 +1000886 spin_lock(&bp->b_lock);
887 if (!(bp->b_flags & XBF_STALE) && atomic_read(&bp->b_lru_ref)) {
888 /*
889 * If the buffer is added to the LRU take a new
890 * reference to the buffer for the LRU and clear the
891 * (now stale) dispose list state flag
892 */
893 if (list_lru_add(&bp->b_target->bt_lru, &bp->b_lru)) {
894 bp->b_state &= ~XFS_BSTATE_DISPOSE;
895 atomic_inc(&bp->b_hold);
896 }
897 spin_unlock(&bp->b_lock);
Dave Chinner430cbeb2010-12-02 16:30:55 +1100898 spin_unlock(&pag->pag_buf_lock);
Christoph Hellwig7f14d0a2005-11-02 15:09:35 +1100899 } else {
Dave Chinnera4082352013-08-28 10:18:06 +1000900 /*
901 * most of the time buffers will already be removed from
902 * the LRU, so optimise that case by checking for the
903 * XFS_BSTATE_DISPOSE flag indicating the last list the
904 * buffer was on was the disposal list
905 */
906 if (!(bp->b_state & XFS_BSTATE_DISPOSE)) {
907 list_lru_del(&bp->b_target->bt_lru, &bp->b_lru);
908 } else {
909 ASSERT(list_empty(&bp->b_lru));
910 }
911 spin_unlock(&bp->b_lock);
912
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000913 ASSERT(!(bp->b_flags & _XBF_DELWRI_Q));
Dave Chinner74f75a02010-09-24 19:59:04 +1000914 rb_erase(&bp->b_rbnode, &pag->pag_buf_tree);
915 spin_unlock(&pag->pag_buf_lock);
916 xfs_perag_put(pag);
Nathan Scottce8e9222006-01-11 15:39:08 +1100917 xfs_buf_free(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 }
919 }
920}
921
922
923/*
Dave Chinner0e6e8472011-03-26 09:16:45 +1100924 * Lock a buffer object, if it is not already locked.
Dave Chinner90810b92010-11-30 15:16:16 +1100925 *
926 * If we come across a stale, pinned, locked buffer, we know that we are
927 * being asked to lock a buffer that has been reallocated. Because it is
928 * pinned, we know that the log has not been pushed to disk and hence it
929 * will still be locked. Rather than continuing to have trylock attempts
930 * fail until someone else pushes the log, push it ourselves before
931 * returning. This means that the xfsaild will not get stuck trying
932 * to push on stale inode buffers.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933 */
934int
Christoph Hellwig0c842ad2011-07-08 14:36:19 +0200935xfs_buf_trylock(
936 struct xfs_buf *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937{
938 int locked;
939
Nathan Scottce8e9222006-01-11 15:39:08 +1100940 locked = down_trylock(&bp->b_sema) == 0;
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000941 if (locked)
Nathan Scottce8e9222006-01-11 15:39:08 +1100942 XB_SET_OWNER(bp);
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000943
Christoph Hellwig0c842ad2011-07-08 14:36:19 +0200944 trace_xfs_buf_trylock(bp, _RET_IP_);
945 return locked;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947
948/*
Dave Chinner0e6e8472011-03-26 09:16:45 +1100949 * Lock a buffer object.
Dave Chinnered3b4d62010-05-21 12:07:08 +1000950 *
951 * If we come across a stale, pinned, locked buffer, we know that we
952 * are being asked to lock a buffer that has been reallocated. Because
953 * it is pinned, we know that the log has not been pushed to disk and
954 * hence it will still be locked. Rather than sleeping until someone
955 * else pushes the log, push it ourselves before trying to get the lock.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956 */
Nathan Scottce8e9222006-01-11 15:39:08 +1100957void
958xfs_buf_lock(
Christoph Hellwig0c842ad2011-07-08 14:36:19 +0200959 struct xfs_buf *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960{
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000961 trace_xfs_buf_lock(bp, _RET_IP_);
962
Dave Chinnered3b4d62010-05-21 12:07:08 +1000963 if (atomic_read(&bp->b_pin_count) && (bp->b_flags & XBF_STALE))
Dave Chinnerebad8612010-09-22 10:47:20 +1000964 xfs_log_force(bp->b_target->bt_mount, 0);
Nathan Scottce8e9222006-01-11 15:39:08 +1100965 down(&bp->b_sema);
966 XB_SET_OWNER(bp);
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000967
968 trace_xfs_buf_lock_done(bp, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969}
970
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971void
Nathan Scottce8e9222006-01-11 15:39:08 +1100972xfs_buf_unlock(
Christoph Hellwig0c842ad2011-07-08 14:36:19 +0200973 struct xfs_buf *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974{
Nathan Scottce8e9222006-01-11 15:39:08 +1100975 XB_CLEAR_OWNER(bp);
976 up(&bp->b_sema);
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000977
978 trace_xfs_buf_unlock(bp, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979}
980
Nathan Scottce8e9222006-01-11 15:39:08 +1100981STATIC void
982xfs_buf_wait_unpin(
983 xfs_buf_t *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984{
985 DECLARE_WAITQUEUE (wait, current);
986
Nathan Scottce8e9222006-01-11 15:39:08 +1100987 if (atomic_read(&bp->b_pin_count) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988 return;
989
Nathan Scottce8e9222006-01-11 15:39:08 +1100990 add_wait_queue(&bp->b_waiters, &wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991 for (;;) {
992 set_current_state(TASK_UNINTERRUPTIBLE);
Nathan Scottce8e9222006-01-11 15:39:08 +1100993 if (atomic_read(&bp->b_pin_count) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994 break;
Jens Axboe7eaceac2011-03-10 08:52:07 +0100995 io_schedule();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996 }
Nathan Scottce8e9222006-01-11 15:39:08 +1100997 remove_wait_queue(&bp->b_waiters, &wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 set_current_state(TASK_RUNNING);
999}
1000
1001/*
1002 * Buffer Utility Routines
1003 */
1004
Dave Chinnere8aaba92014-10-02 09:04:22 +10001005void
1006xfs_buf_ioend(
1007 struct xfs_buf *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008{
Dave Chinnere8aaba92014-10-02 09:04:22 +10001009 bool read = bp->b_flags & XBF_READ;
1010
1011 trace_xfs_buf_iodone(bp, _RET_IP_);
Dave Chinner1813dd62012-11-14 17:54:40 +11001012
1013 bp->b_flags &= ~(XBF_READ | XBF_WRITE | XBF_READ_AHEAD);
Dave Chinnerd5929de2013-02-27 13:25:54 +11001014
Dave Chinner61be9c52014-10-02 09:04:31 +10001015 /*
1016 * Pull in IO completion errors now. We are guaranteed to be running
1017 * single threaded, so we don't need the lock to read b_io_error.
1018 */
1019 if (!bp->b_error && bp->b_io_error)
1020 xfs_buf_ioerror(bp, bp->b_io_error);
1021
Dave Chinnere8aaba92014-10-02 09:04:22 +10001022 /* Only validate buffers that were read without errors */
1023 if (read && !bp->b_error && bp->b_ops) {
1024 ASSERT(!bp->b_iodone);
Dave Chinner1813dd62012-11-14 17:54:40 +11001025 bp->b_ops->verify_read(bp);
Dave Chinnere8aaba92014-10-02 09:04:22 +10001026 }
1027
1028 if (!bp->b_error)
1029 bp->b_flags |= XBF_DONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030
Christoph Hellwig80f6c292010-08-18 05:29:11 -04001031 if (bp->b_iodone)
Nathan Scottce8e9222006-01-11 15:39:08 +11001032 (*(bp->b_iodone))(bp);
1033 else if (bp->b_flags & XBF_ASYNC)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034 xfs_buf_relse(bp);
Dave Chinner595bff72014-10-02 09:05:14 +10001035 else
Dave Chinner1813dd62012-11-14 17:54:40 +11001036 complete(&bp->b_iowait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037}
1038
Dave Chinnere8aaba92014-10-02 09:04:22 +10001039static void
1040xfs_buf_ioend_work(
1041 struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042{
Dave Chinnere8aaba92014-10-02 09:04:22 +10001043 struct xfs_buf *bp =
Brian Fosterb29c70f2014-12-04 09:43:17 +11001044 container_of(work, xfs_buf_t, b_ioend_work);
Dave Chinner1813dd62012-11-14 17:54:40 +11001045
Dave Chinnere8aaba92014-10-02 09:04:22 +10001046 xfs_buf_ioend(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047}
1048
1049void
Dave Chinnere8aaba92014-10-02 09:04:22 +10001050xfs_buf_ioend_async(
1051 struct xfs_buf *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052{
Brian Fosterb29c70f2014-12-04 09:43:17 +11001053 INIT_WORK(&bp->b_ioend_work, xfs_buf_ioend_work);
1054 queue_work(bp->b_ioend_wq, &bp->b_ioend_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055}
1056
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057void
Nathan Scottce8e9222006-01-11 15:39:08 +11001058xfs_buf_ioerror(
1059 xfs_buf_t *bp,
1060 int error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061{
Dave Chinner24513372014-06-25 14:58:08 +10001062 ASSERT(error <= 0 && error >= -1000);
1063 bp->b_error = error;
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001064 trace_xfs_buf_ioerror(bp, error, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065}
1066
Christoph Hellwig901796a2011-10-10 16:52:49 +00001067void
1068xfs_buf_ioerror_alert(
1069 struct xfs_buf *bp,
1070 const char *func)
1071{
1072 xfs_alert(bp->b_target->bt_mount,
Dave Chinneraa0e8832012-04-23 15:58:52 +10001073"metadata I/O error: block 0x%llx (\"%s\") error %d numblks %d",
Dave Chinner24513372014-06-25 14:58:08 +10001074 (__uint64_t)XFS_BUF_ADDR(bp), func, -bp->b_error, bp->b_length);
Christoph Hellwig901796a2011-10-10 16:52:49 +00001075}
1076
Christoph Hellwiga2dcf5d2012-07-13 02:24:10 -04001077int
1078xfs_bwrite(
1079 struct xfs_buf *bp)
1080{
1081 int error;
1082
1083 ASSERT(xfs_buf_islocked(bp));
1084
1085 bp->b_flags |= XBF_WRITE;
Dave Chinner27187752014-10-02 09:04:56 +10001086 bp->b_flags &= ~(XBF_ASYNC | XBF_READ | _XBF_DELWRI_Q |
1087 XBF_WRITE_FAIL | XBF_DONE);
Christoph Hellwiga2dcf5d2012-07-13 02:24:10 -04001088
Dave Chinner595bff72014-10-02 09:05:14 +10001089 error = xfs_buf_submit_wait(bp);
Christoph Hellwiga2dcf5d2012-07-13 02:24:10 -04001090 if (error) {
1091 xfs_force_shutdown(bp->b_target->bt_mount,
1092 SHUTDOWN_META_IO_ERROR);
1093 }
1094 return error;
1095}
1096
Christoph Hellwigb8f82a42009-11-14 16:17:22 +00001097STATIC void
Nathan Scottce8e9222006-01-11 15:39:08 +11001098xfs_buf_bio_end_io(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099 struct bio *bio,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100 int error)
1101{
Nathan Scottce8e9222006-01-11 15:39:08 +11001102 xfs_buf_t *bp = (xfs_buf_t *)bio->bi_private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103
Dave Chinner37eb17e2012-11-12 22:09:46 +11001104 /*
1105 * don't overwrite existing errors - otherwise we can lose errors on
1106 * buffers that require multiple bios to complete.
1107 */
Dave Chinner61be9c52014-10-02 09:04:31 +10001108 if (error) {
1109 spin_lock(&bp->b_lock);
1110 if (!bp->b_io_error)
1111 bp->b_io_error = error;
1112 spin_unlock(&bp->b_lock);
1113 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114
Dave Chinner37eb17e2012-11-12 22:09:46 +11001115 if (!bp->b_error && xfs_buf_is_vmapped(bp) && (bp->b_flags & XBF_READ))
James Bottomley73c77e22010-01-25 11:42:24 -06001116 invalidate_kernel_vmap_range(bp->b_addr, xfs_buf_vmap_len(bp));
1117
Dave Chinnere8aaba92014-10-02 09:04:22 +10001118 if (atomic_dec_and_test(&bp->b_io_remaining) == 1)
1119 xfs_buf_ioend_async(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120 bio_put(bio);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121}
1122
Dave Chinner3e85c862012-06-22 18:50:09 +10001123static void
1124xfs_buf_ioapply_map(
1125 struct xfs_buf *bp,
1126 int map,
1127 int *buf_offset,
1128 int *count,
1129 int rw)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130{
Dave Chinner3e85c862012-06-22 18:50:09 +10001131 int page_index;
1132 int total_nr_pages = bp->b_page_count;
1133 int nr_pages;
1134 struct bio *bio;
1135 sector_t sector = bp->b_maps[map].bm_bn;
1136 int size;
1137 int offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138
Nathan Scottce8e9222006-01-11 15:39:08 +11001139 total_nr_pages = bp->b_page_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140
Dave Chinner3e85c862012-06-22 18:50:09 +10001141 /* skip the pages in the buffer before the start offset */
1142 page_index = 0;
1143 offset = *buf_offset;
1144 while (offset >= PAGE_SIZE) {
1145 page_index++;
1146 offset -= PAGE_SIZE;
Christoph Hellwigf538d4d2005-11-02 10:26:59 +11001147 }
1148
Dave Chinner3e85c862012-06-22 18:50:09 +10001149 /*
1150 * Limit the IO size to the length of the current vector, and update the
1151 * remaining IO count for the next time around.
1152 */
1153 size = min_t(int, BBTOB(bp->b_maps[map].bm_len), *count);
1154 *count -= size;
1155 *buf_offset += size;
Christoph Hellwig34951f52011-07-26 15:06:44 +00001156
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157next_chunk:
Nathan Scottce8e9222006-01-11 15:39:08 +11001158 atomic_inc(&bp->b_io_remaining);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159 nr_pages = BIO_MAX_SECTORS >> (PAGE_SHIFT - BBSHIFT);
1160 if (nr_pages > total_nr_pages)
1161 nr_pages = total_nr_pages;
1162
1163 bio = bio_alloc(GFP_NOIO, nr_pages);
Nathan Scottce8e9222006-01-11 15:39:08 +11001164 bio->bi_bdev = bp->b_target->bt_bdev;
Kent Overstreet4f024f32013-10-11 15:44:27 -07001165 bio->bi_iter.bi_sector = sector;
Nathan Scottce8e9222006-01-11 15:39:08 +11001166 bio->bi_end_io = xfs_buf_bio_end_io;
1167 bio->bi_private = bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168
Dave Chinner0e6e8472011-03-26 09:16:45 +11001169
Dave Chinner3e85c862012-06-22 18:50:09 +10001170 for (; size && nr_pages; nr_pages--, page_index++) {
Dave Chinner0e6e8472011-03-26 09:16:45 +11001171 int rbytes, nbytes = PAGE_SIZE - offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172
1173 if (nbytes > size)
1174 nbytes = size;
1175
Dave Chinner3e85c862012-06-22 18:50:09 +10001176 rbytes = bio_add_page(bio, bp->b_pages[page_index], nbytes,
1177 offset);
Nathan Scottce8e9222006-01-11 15:39:08 +11001178 if (rbytes < nbytes)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179 break;
1180
1181 offset = 0;
Dave Chinneraa0e8832012-04-23 15:58:52 +10001182 sector += BTOBB(nbytes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183 size -= nbytes;
1184 total_nr_pages--;
1185 }
1186
Kent Overstreet4f024f32013-10-11 15:44:27 -07001187 if (likely(bio->bi_iter.bi_size)) {
James Bottomley73c77e22010-01-25 11:42:24 -06001188 if (xfs_buf_is_vmapped(bp)) {
1189 flush_kernel_vmap_range(bp->b_addr,
1190 xfs_buf_vmap_len(bp));
1191 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192 submit_bio(rw, bio);
1193 if (size)
1194 goto next_chunk;
1195 } else {
Dave Chinner37eb17e2012-11-12 22:09:46 +11001196 /*
1197 * This is guaranteed not to be the last io reference count
Dave Chinner595bff72014-10-02 09:05:14 +10001198 * because the caller (xfs_buf_submit) holds a count itself.
Dave Chinner37eb17e2012-11-12 22:09:46 +11001199 */
1200 atomic_dec(&bp->b_io_remaining);
Dave Chinner24513372014-06-25 14:58:08 +10001201 xfs_buf_ioerror(bp, -EIO);
Dave Chinnerec53d1d2010-07-20 17:52:59 +10001202 bio_put(bio);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203 }
Dave Chinner3e85c862012-06-22 18:50:09 +10001204
1205}
1206
1207STATIC void
1208_xfs_buf_ioapply(
1209 struct xfs_buf *bp)
1210{
1211 struct blk_plug plug;
1212 int rw;
1213 int offset;
1214 int size;
1215 int i;
1216
Dave Chinnerc163f9a2013-03-12 23:30:34 +11001217 /*
1218 * Make sure we capture only current IO errors rather than stale errors
1219 * left over from previous use of the buffer (e.g. failed readahead).
1220 */
1221 bp->b_error = 0;
1222
Brian Fosterb29c70f2014-12-04 09:43:17 +11001223 /*
1224 * Initialize the I/O completion workqueue if we haven't yet or the
1225 * submitter has not opted to specify a custom one.
1226 */
1227 if (!bp->b_ioend_wq)
1228 bp->b_ioend_wq = bp->b_target->bt_mount->m_buf_workqueue;
1229
Dave Chinner3e85c862012-06-22 18:50:09 +10001230 if (bp->b_flags & XBF_WRITE) {
1231 if (bp->b_flags & XBF_SYNCIO)
1232 rw = WRITE_SYNC;
1233 else
1234 rw = WRITE;
1235 if (bp->b_flags & XBF_FUA)
1236 rw |= REQ_FUA;
1237 if (bp->b_flags & XBF_FLUSH)
1238 rw |= REQ_FLUSH;
Dave Chinner1813dd62012-11-14 17:54:40 +11001239
1240 /*
1241 * Run the write verifier callback function if it exists. If
1242 * this function fails it will mark the buffer with an error and
1243 * the IO should not be dispatched.
1244 */
1245 if (bp->b_ops) {
1246 bp->b_ops->verify_write(bp);
1247 if (bp->b_error) {
1248 xfs_force_shutdown(bp->b_target->bt_mount,
1249 SHUTDOWN_CORRUPT_INCORE);
1250 return;
1251 }
Dave Chinner400b9d82014-08-04 12:42:40 +10001252 } else if (bp->b_bn != XFS_BUF_DADDR_NULL) {
1253 struct xfs_mount *mp = bp->b_target->bt_mount;
1254
1255 /*
1256 * non-crc filesystems don't attach verifiers during
1257 * log recovery, so don't warn for such filesystems.
1258 */
1259 if (xfs_sb_version_hascrc(&mp->m_sb)) {
1260 xfs_warn(mp,
1261 "%s: no ops on block 0x%llx/0x%x",
1262 __func__, bp->b_bn, bp->b_length);
1263 xfs_hex_dump(bp->b_addr, 64);
1264 dump_stack();
1265 }
Dave Chinner1813dd62012-11-14 17:54:40 +11001266 }
Dave Chinner3e85c862012-06-22 18:50:09 +10001267 } else if (bp->b_flags & XBF_READ_AHEAD) {
1268 rw = READA;
1269 } else {
1270 rw = READ;
1271 }
1272
1273 /* we only use the buffer cache for meta-data */
1274 rw |= REQ_META;
1275
1276 /*
1277 * Walk all the vectors issuing IO on them. Set up the initial offset
1278 * into the buffer and the desired IO size before we start -
1279 * _xfs_buf_ioapply_vec() will modify them appropriately for each
1280 * subsequent call.
1281 */
1282 offset = bp->b_offset;
1283 size = BBTOB(bp->b_io_length);
1284 blk_start_plug(&plug);
1285 for (i = 0; i < bp->b_map_count; i++) {
1286 xfs_buf_ioapply_map(bp, i, &offset, &size, rw);
1287 if (bp->b_error)
1288 break;
1289 if (size <= 0)
1290 break; /* all done */
1291 }
1292 blk_finish_plug(&plug);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293}
1294
Dave Chinner595bff72014-10-02 09:05:14 +10001295/*
1296 * Asynchronous IO submission path. This transfers the buffer lock ownership and
1297 * the current reference to the IO. It is not safe to reference the buffer after
1298 * a call to this function unless the caller holds an additional reference
1299 * itself.
1300 */
Dave Chinner0e95f192012-04-23 15:58:46 +10001301void
Dave Chinner595bff72014-10-02 09:05:14 +10001302xfs_buf_submit(
1303 struct xfs_buf *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304{
Dave Chinner595bff72014-10-02 09:05:14 +10001305 trace_xfs_buf_submit(bp, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001307 ASSERT(!(bp->b_flags & _XBF_DELWRI_Q));
Dave Chinner595bff72014-10-02 09:05:14 +10001308 ASSERT(bp->b_flags & XBF_ASYNC);
1309
1310 /* on shutdown we stale and complete the buffer immediately */
1311 if (XFS_FORCED_SHUTDOWN(bp->b_target->bt_mount)) {
1312 xfs_buf_ioerror(bp, -EIO);
1313 bp->b_flags &= ~XBF_DONE;
1314 xfs_buf_stale(bp);
1315 xfs_buf_ioend(bp);
1316 return;
1317 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318
Christoph Hellwig375ec69d2011-08-23 08:28:03 +00001319 if (bp->b_flags & XBF_WRITE)
Nathan Scottce8e9222006-01-11 15:39:08 +11001320 xfs_buf_wait_unpin(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321
Dave Chinner61be9c52014-10-02 09:04:31 +10001322 /* clear the internal error state to avoid spurious errors */
1323 bp->b_io_error = 0;
1324
Eric Sandeen8d6c1212014-04-17 08:15:28 +10001325 /*
Dave Chinner595bff72014-10-02 09:05:14 +10001326 * The caller's reference is released during I/O completion.
1327 * This occurs some time after the last b_io_remaining reference is
1328 * released, so after we drop our Io reference we have to have some
1329 * other reference to ensure the buffer doesn't go away from underneath
1330 * us. Take a direct reference to ensure we have safe access to the
1331 * buffer until we are finished with it.
Dave Chinnere11bb802014-10-02 09:04:11 +10001332 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333 xfs_buf_hold(bp);
1334
Eric Sandeen8d6c1212014-04-17 08:15:28 +10001335 /*
Dave Chinnere11bb802014-10-02 09:04:11 +10001336 * Set the count to 1 initially, this will stop an I/O completion
1337 * callout which happens before we have started all the I/O from calling
1338 * xfs_buf_ioend too early.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339 */
Nathan Scottce8e9222006-01-11 15:39:08 +11001340 atomic_set(&bp->b_io_remaining, 1);
1341 _xfs_buf_ioapply(bp);
Dave Chinnere11bb802014-10-02 09:04:11 +10001342
Eric Sandeen8d6c1212014-04-17 08:15:28 +10001343 /*
Dave Chinner595bff72014-10-02 09:05:14 +10001344 * If _xfs_buf_ioapply failed, we can get back here with only the IO
1345 * reference we took above. If we drop it to zero, run completion so
1346 * that we don't return to the caller with completion still pending.
Eric Sandeen8d6c1212014-04-17 08:15:28 +10001347 */
Dave Chinnere8aaba92014-10-02 09:04:22 +10001348 if (atomic_dec_and_test(&bp->b_io_remaining) == 1) {
Dave Chinner595bff72014-10-02 09:05:14 +10001349 if (bp->b_error)
Dave Chinnere8aaba92014-10-02 09:04:22 +10001350 xfs_buf_ioend(bp);
1351 else
1352 xfs_buf_ioend_async(bp);
1353 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354
Nathan Scottce8e9222006-01-11 15:39:08 +11001355 xfs_buf_rele(bp);
Dave Chinner595bff72014-10-02 09:05:14 +10001356 /* Note: it is not safe to reference bp now we've dropped our ref */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357}
1358
1359/*
Dave Chinner595bff72014-10-02 09:05:14 +10001360 * Synchronous buffer IO submission path, read or write.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361 */
1362int
Dave Chinner595bff72014-10-02 09:05:14 +10001363xfs_buf_submit_wait(
1364 struct xfs_buf *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365{
Dave Chinner595bff72014-10-02 09:05:14 +10001366 int error;
1367
1368 trace_xfs_buf_submit_wait(bp, _RET_IP_);
1369
1370 ASSERT(!(bp->b_flags & (_XBF_DELWRI_Q | XBF_ASYNC)));
1371
1372 if (XFS_FORCED_SHUTDOWN(bp->b_target->bt_mount)) {
1373 xfs_buf_ioerror(bp, -EIO);
1374 xfs_buf_stale(bp);
1375 bp->b_flags &= ~XBF_DONE;
1376 return -EIO;
1377 }
1378
1379 if (bp->b_flags & XBF_WRITE)
1380 xfs_buf_wait_unpin(bp);
1381
1382 /* clear the internal error state to avoid spurious errors */
1383 bp->b_io_error = 0;
1384
1385 /*
1386 * For synchronous IO, the IO does not inherit the submitters reference
1387 * count, nor the buffer lock. Hence we cannot release the reference we
1388 * are about to take until we've waited for all IO completion to occur,
1389 * including any xfs_buf_ioend_async() work that may be pending.
1390 */
1391 xfs_buf_hold(bp);
1392
1393 /*
1394 * Set the count to 1 initially, this will stop an I/O completion
1395 * callout which happens before we have started all the I/O from calling
1396 * xfs_buf_ioend too early.
1397 */
1398 atomic_set(&bp->b_io_remaining, 1);
1399 _xfs_buf_ioapply(bp);
1400
1401 /*
1402 * make sure we run completion synchronously if it raced with us and is
1403 * already complete.
1404 */
1405 if (atomic_dec_and_test(&bp->b_io_remaining) == 1)
1406 xfs_buf_ioend(bp);
1407
1408 /* wait for completion before gathering the error from the buffer */
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001409 trace_xfs_buf_iowait(bp, _RET_IP_);
Dave Chinner595bff72014-10-02 09:05:14 +10001410 wait_for_completion(&bp->b_iowait);
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001411 trace_xfs_buf_iowait_done(bp, _RET_IP_);
Dave Chinner595bff72014-10-02 09:05:14 +10001412 error = bp->b_error;
1413
1414 /*
1415 * all done now, we can release the hold that keeps the buffer
1416 * referenced for the entire IO.
1417 */
1418 xfs_buf_rele(bp);
1419 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420}
1421
Nathan Scottce8e9222006-01-11 15:39:08 +11001422xfs_caddr_t
1423xfs_buf_offset(
1424 xfs_buf_t *bp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425 size_t offset)
1426{
1427 struct page *page;
1428
Dave Chinner611c9942012-04-23 15:59:07 +10001429 if (bp->b_addr)
Chandra Seetharaman62926042011-07-22 23:40:15 +00001430 return bp->b_addr + offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431
Nathan Scottce8e9222006-01-11 15:39:08 +11001432 offset += bp->b_offset;
Dave Chinner0e6e8472011-03-26 09:16:45 +11001433 page = bp->b_pages[offset >> PAGE_SHIFT];
1434 return (xfs_caddr_t)page_address(page) + (offset & (PAGE_SIZE-1));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435}
1436
1437/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438 * Move data into or out of a buffer.
1439 */
1440void
Nathan Scottce8e9222006-01-11 15:39:08 +11001441xfs_buf_iomove(
1442 xfs_buf_t *bp, /* buffer to process */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443 size_t boff, /* starting buffer offset */
1444 size_t bsize, /* length to copy */
Dave Chinnerb9c48642010-01-20 10:47:39 +11001445 void *data, /* data address */
Nathan Scottce8e9222006-01-11 15:39:08 +11001446 xfs_buf_rw_t mode) /* read/write/zero flag */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447{
Dave Chinner795cac72012-04-23 15:58:53 +10001448 size_t bend;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449
1450 bend = boff + bsize;
1451 while (boff < bend) {
Dave Chinner795cac72012-04-23 15:58:53 +10001452 struct page *page;
1453 int page_index, page_offset, csize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454
Dave Chinner795cac72012-04-23 15:58:53 +10001455 page_index = (boff + bp->b_offset) >> PAGE_SHIFT;
1456 page_offset = (boff + bp->b_offset) & ~PAGE_MASK;
1457 page = bp->b_pages[page_index];
1458 csize = min_t(size_t, PAGE_SIZE - page_offset,
1459 BBTOB(bp->b_io_length) - boff);
1460
1461 ASSERT((csize + page_offset) <= PAGE_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001462
1463 switch (mode) {
Nathan Scottce8e9222006-01-11 15:39:08 +11001464 case XBRW_ZERO:
Dave Chinner795cac72012-04-23 15:58:53 +10001465 memset(page_address(page) + page_offset, 0, csize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466 break;
Nathan Scottce8e9222006-01-11 15:39:08 +11001467 case XBRW_READ:
Dave Chinner795cac72012-04-23 15:58:53 +10001468 memcpy(data, page_address(page) + page_offset, csize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469 break;
Nathan Scottce8e9222006-01-11 15:39:08 +11001470 case XBRW_WRITE:
Dave Chinner795cac72012-04-23 15:58:53 +10001471 memcpy(page_address(page) + page_offset, data, csize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472 }
1473
1474 boff += csize;
1475 data += csize;
1476 }
1477}
1478
1479/*
Nathan Scottce8e9222006-01-11 15:39:08 +11001480 * Handling of buffer targets (buftargs).
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481 */
1482
1483/*
Dave Chinner430cbeb2010-12-02 16:30:55 +11001484 * Wait for any bufs with callbacks that have been submitted but have not yet
1485 * returned. These buffers will have an elevated hold count, so wait on those
1486 * while freeing all the buffers only held by the LRU.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487 */
Dave Chinnere80dfa12013-08-28 10:18:05 +10001488static enum lru_status
1489xfs_buftarg_wait_rele(
1490 struct list_head *item,
1491 spinlock_t *lru_lock,
1492 void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493
Dave Chinnere80dfa12013-08-28 10:18:05 +10001494{
1495 struct xfs_buf *bp = container_of(item, struct xfs_buf, b_lru);
Dave Chinnera4082352013-08-28 10:18:06 +10001496 struct list_head *dispose = arg;
Dave Chinnere80dfa12013-08-28 10:18:05 +10001497
1498 if (atomic_read(&bp->b_hold) > 1) {
Dave Chinnera4082352013-08-28 10:18:06 +10001499 /* need to wait, so skip it this pass */
Dave Chinnere80dfa12013-08-28 10:18:05 +10001500 trace_xfs_buf_wait_buftarg(bp, _RET_IP_);
Dave Chinnera4082352013-08-28 10:18:06 +10001501 return LRU_SKIP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502 }
Dave Chinnera4082352013-08-28 10:18:06 +10001503 if (!spin_trylock(&bp->b_lock))
1504 return LRU_SKIP;
Dave Chinnere80dfa12013-08-28 10:18:05 +10001505
Dave Chinnera4082352013-08-28 10:18:06 +10001506 /*
1507 * clear the LRU reference count so the buffer doesn't get
1508 * ignored in xfs_buf_rele().
1509 */
1510 atomic_set(&bp->b_lru_ref, 0);
1511 bp->b_state |= XFS_BSTATE_DISPOSE;
1512 list_move(item, dispose);
1513 spin_unlock(&bp->b_lock);
1514 return LRU_REMOVED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001515}
1516
Dave Chinnere80dfa12013-08-28 10:18:05 +10001517void
1518xfs_wait_buftarg(
1519 struct xfs_buftarg *btp)
1520{
Dave Chinnera4082352013-08-28 10:18:06 +10001521 LIST_HEAD(dispose);
1522 int loop = 0;
1523
1524 /* loop until there is nothing left on the lru list. */
1525 while (list_lru_count(&btp->bt_lru)) {
Dave Chinnere80dfa12013-08-28 10:18:05 +10001526 list_lru_walk(&btp->bt_lru, xfs_buftarg_wait_rele,
Dave Chinnera4082352013-08-28 10:18:06 +10001527 &dispose, LONG_MAX);
1528
1529 while (!list_empty(&dispose)) {
1530 struct xfs_buf *bp;
1531 bp = list_first_entry(&dispose, struct xfs_buf, b_lru);
1532 list_del_init(&bp->b_lru);
Dave Chinnerac8809f2013-12-12 16:34:38 +11001533 if (bp->b_flags & XBF_WRITE_FAIL) {
1534 xfs_alert(btp->bt_mount,
1535"Corruption Alert: Buffer at block 0x%llx had permanent write failures!\n"
1536"Please run xfs_repair to determine the extent of the problem.",
1537 (long long)bp->b_bn);
1538 }
Dave Chinnera4082352013-08-28 10:18:06 +10001539 xfs_buf_rele(bp);
1540 }
1541 if (loop++ != 0)
1542 delay(100);
1543 }
Dave Chinnere80dfa12013-08-28 10:18:05 +10001544}
1545
1546static enum lru_status
1547xfs_buftarg_isolate(
1548 struct list_head *item,
1549 spinlock_t *lru_lock,
1550 void *arg)
1551{
1552 struct xfs_buf *bp = container_of(item, struct xfs_buf, b_lru);
1553 struct list_head *dispose = arg;
1554
1555 /*
Dave Chinnera4082352013-08-28 10:18:06 +10001556 * we are inverting the lru lock/bp->b_lock here, so use a trylock.
1557 * If we fail to get the lock, just skip it.
1558 */
1559 if (!spin_trylock(&bp->b_lock))
1560 return LRU_SKIP;
1561 /*
Dave Chinnere80dfa12013-08-28 10:18:05 +10001562 * Decrement the b_lru_ref count unless the value is already
1563 * zero. If the value is already zero, we need to reclaim the
1564 * buffer, otherwise it gets another trip through the LRU.
1565 */
Dave Chinnera4082352013-08-28 10:18:06 +10001566 if (!atomic_add_unless(&bp->b_lru_ref, -1, 0)) {
1567 spin_unlock(&bp->b_lock);
Dave Chinnere80dfa12013-08-28 10:18:05 +10001568 return LRU_ROTATE;
Dave Chinnera4082352013-08-28 10:18:06 +10001569 }
Dave Chinnere80dfa12013-08-28 10:18:05 +10001570
Dave Chinnera4082352013-08-28 10:18:06 +10001571 bp->b_state |= XFS_BSTATE_DISPOSE;
Dave Chinnere80dfa12013-08-28 10:18:05 +10001572 list_move(item, dispose);
Dave Chinnera4082352013-08-28 10:18:06 +10001573 spin_unlock(&bp->b_lock);
Dave Chinnere80dfa12013-08-28 10:18:05 +10001574 return LRU_REMOVED;
1575}
1576
Andrew Mortonaddbda42013-08-28 10:18:06 +10001577static unsigned long
Dave Chinnere80dfa12013-08-28 10:18:05 +10001578xfs_buftarg_shrink_scan(
Dave Chinnerff57ab22010-11-30 17:27:57 +11001579 struct shrinker *shrink,
Ying Han1495f232011-05-24 17:12:27 -07001580 struct shrink_control *sc)
David Chinnera6867a62006-01-11 15:37:58 +11001581{
Dave Chinnerff57ab22010-11-30 17:27:57 +11001582 struct xfs_buftarg *btp = container_of(shrink,
1583 struct xfs_buftarg, bt_shrinker);
Dave Chinner430cbeb2010-12-02 16:30:55 +11001584 LIST_HEAD(dispose);
Andrew Mortonaddbda42013-08-28 10:18:06 +10001585 unsigned long freed;
Dave Chinnere80dfa12013-08-28 10:18:05 +10001586 unsigned long nr_to_scan = sc->nr_to_scan;
Dave Chinner430cbeb2010-12-02 16:30:55 +11001587
Dave Chinnere80dfa12013-08-28 10:18:05 +10001588 freed = list_lru_walk_node(&btp->bt_lru, sc->nid, xfs_buftarg_isolate,
1589 &dispose, &nr_to_scan);
Dave Chinner430cbeb2010-12-02 16:30:55 +11001590
1591 while (!list_empty(&dispose)) {
Dave Chinnere80dfa12013-08-28 10:18:05 +10001592 struct xfs_buf *bp;
Dave Chinner430cbeb2010-12-02 16:30:55 +11001593 bp = list_first_entry(&dispose, struct xfs_buf, b_lru);
1594 list_del_init(&bp->b_lru);
1595 xfs_buf_rele(bp);
1596 }
1597
Dave Chinnere80dfa12013-08-28 10:18:05 +10001598 return freed;
1599}
1600
Andrew Mortonaddbda42013-08-28 10:18:06 +10001601static unsigned long
Dave Chinnere80dfa12013-08-28 10:18:05 +10001602xfs_buftarg_shrink_count(
1603 struct shrinker *shrink,
1604 struct shrink_control *sc)
1605{
1606 struct xfs_buftarg *btp = container_of(shrink,
1607 struct xfs_buftarg, bt_shrinker);
1608 return list_lru_count_node(&btp->bt_lru, sc->nid);
David Chinnera6867a62006-01-11 15:37:58 +11001609}
1610
Linus Torvalds1da177e2005-04-16 15:20:36 -07001611void
1612xfs_free_buftarg(
Christoph Hellwigb7963132009-03-03 14:48:37 -05001613 struct xfs_mount *mp,
1614 struct xfs_buftarg *btp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615{
Dave Chinnerff57ab22010-11-30 17:27:57 +11001616 unregister_shrinker(&btp->bt_shrinker);
Glauber Costaf5e1dd32013-08-28 10:18:18 +10001617 list_lru_destroy(&btp->bt_lru);
Dave Chinnerff57ab22010-11-30 17:27:57 +11001618
Christoph Hellwigb7963132009-03-03 14:48:37 -05001619 if (mp->m_flags & XFS_MOUNT_BARRIER)
1620 xfs_blkdev_issue_flush(btp);
David Chinnera6867a62006-01-11 15:37:58 +11001621
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10001622 kmem_free(btp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623}
1624
Eric Sandeen3fefdee2013-11-13 14:53:45 -06001625int
1626xfs_setsize_buftarg(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627 xfs_buftarg_t *btp,
Eric Sandeen3fefdee2013-11-13 14:53:45 -06001628 unsigned int sectorsize)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629{
Eric Sandeen7c71ee72014-01-21 16:46:23 -06001630 /* Set up metadata sector size info */
Eric Sandeen6da54172014-01-21 16:45:52 -06001631 btp->bt_meta_sectorsize = sectorsize;
1632 btp->bt_meta_sectormask = sectorsize - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633
Nathan Scottce8e9222006-01-11 15:39:08 +11001634 if (set_blocksize(btp->bt_bdev, sectorsize)) {
Christoph Hellwig02b102d2011-10-10 16:52:51 +00001635 char name[BDEVNAME_SIZE];
1636
1637 bdevname(btp->bt_bdev, name);
1638
Dave Chinner4f107002011-03-07 10:00:35 +11001639 xfs_warn(btp->bt_mount,
Eric Sandeen08e96e12013-10-11 20:59:05 -05001640 "Cannot set_blocksize to %u on device %s",
Christoph Hellwig02b102d2011-10-10 16:52:51 +00001641 sectorsize, name);
Dave Chinner24513372014-06-25 14:58:08 +10001642 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643 }
1644
Eric Sandeen7c71ee72014-01-21 16:46:23 -06001645 /* Set up device logical sector size mask */
1646 btp->bt_logical_sectorsize = bdev_logical_block_size(btp->bt_bdev);
1647 btp->bt_logical_sectormask = bdev_logical_block_size(btp->bt_bdev) - 1;
1648
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649 return 0;
1650}
1651
1652/*
Eric Sandeen3fefdee2013-11-13 14:53:45 -06001653 * When allocating the initial buffer target we have not yet
1654 * read in the superblock, so don't know what sized sectors
1655 * are being used at this early stage. Play safe.
Nathan Scottce8e9222006-01-11 15:39:08 +11001656 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001657STATIC int
1658xfs_setsize_buftarg_early(
1659 xfs_buftarg_t *btp,
1660 struct block_device *bdev)
1661{
Eric Sandeena96c4152014-04-14 19:00:29 +10001662 return xfs_setsize_buftarg(btp, bdev_logical_block_size(bdev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663}
1664
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665xfs_buftarg_t *
1666xfs_alloc_buftarg(
Dave Chinnerebad8612010-09-22 10:47:20 +10001667 struct xfs_mount *mp,
Eric Sandeen34dcefd2014-04-14 19:01:00 +10001668 struct block_device *bdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001669{
1670 xfs_buftarg_t *btp;
1671
Dave Chinnerb17cb362013-05-20 09:51:12 +10001672 btp = kmem_zalloc(sizeof(*btp), KM_SLEEP | KM_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673
Dave Chinnerebad8612010-09-22 10:47:20 +10001674 btp->bt_mount = mp;
Nathan Scottce8e9222006-01-11 15:39:08 +11001675 btp->bt_dev = bdev->bd_dev;
1676 btp->bt_bdev = bdev;
Dave Chinner0e6e8472011-03-26 09:16:45 +11001677 btp->bt_bdi = blk_get_backing_dev_info(bdev);
Dave Chinner0e6e8472011-03-26 09:16:45 +11001678
Linus Torvalds1da177e2005-04-16 15:20:36 -07001679 if (xfs_setsize_buftarg_early(btp, bdev))
1680 goto error;
Glauber Costa5ca302c2013-08-28 10:18:18 +10001681
1682 if (list_lru_init(&btp->bt_lru))
1683 goto error;
1684
Dave Chinnere80dfa12013-08-28 10:18:05 +10001685 btp->bt_shrinker.count_objects = xfs_buftarg_shrink_count;
1686 btp->bt_shrinker.scan_objects = xfs_buftarg_shrink_scan;
Dave Chinnerff57ab22010-11-30 17:27:57 +11001687 btp->bt_shrinker.seeks = DEFAULT_SEEKS;
Dave Chinnere80dfa12013-08-28 10:18:05 +10001688 btp->bt_shrinker.flags = SHRINKER_NUMA_AWARE;
Dave Chinnerff57ab22010-11-30 17:27:57 +11001689 register_shrinker(&btp->bt_shrinker);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001690 return btp;
1691
1692error:
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10001693 kmem_free(btp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001694 return NULL;
1695}
1696
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697/*
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001698 * Add a buffer to the delayed write list.
1699 *
1700 * This queues a buffer for writeout if it hasn't already been. Note that
1701 * neither this routine nor the buffer list submission functions perform
1702 * any internal synchronization. It is expected that the lists are thread-local
1703 * to the callers.
1704 *
1705 * Returns true if we queued up the buffer, or false if it already had
1706 * been on the buffer list.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707 */
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001708bool
Nathan Scottce8e9222006-01-11 15:39:08 +11001709xfs_buf_delwri_queue(
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001710 struct xfs_buf *bp,
1711 struct list_head *list)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712{
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001713 ASSERT(xfs_buf_islocked(bp));
1714 ASSERT(!(bp->b_flags & XBF_READ));
1715
1716 /*
1717 * If the buffer is already marked delwri it already is queued up
1718 * by someone else for imediate writeout. Just ignore it in that
1719 * case.
1720 */
1721 if (bp->b_flags & _XBF_DELWRI_Q) {
1722 trace_xfs_buf_delwri_queued(bp, _RET_IP_);
1723 return false;
1724 }
David Chinnera6867a62006-01-11 15:37:58 +11001725
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001726 trace_xfs_buf_delwri_queue(bp, _RET_IP_);
1727
Dave Chinnerd808f612010-02-02 10:13:42 +11001728 /*
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001729 * If a buffer gets written out synchronously or marked stale while it
1730 * is on a delwri list we lazily remove it. To do this, the other party
1731 * clears the _XBF_DELWRI_Q flag but otherwise leaves the buffer alone.
1732 * It remains referenced and on the list. In a rare corner case it
1733 * might get readded to a delwri list after the synchronous writeout, in
1734 * which case we need just need to re-add the flag here.
Dave Chinnerd808f612010-02-02 10:13:42 +11001735 */
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001736 bp->b_flags |= _XBF_DELWRI_Q;
1737 if (list_empty(&bp->b_list)) {
1738 atomic_inc(&bp->b_hold);
1739 list_add_tail(&bp->b_list, list);
David Chinner585e6d82007-02-10 18:32:29 +11001740 }
David Chinner585e6d82007-02-10 18:32:29 +11001741
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001742 return true;
David Chinner585e6d82007-02-10 18:32:29 +11001743}
1744
Dave Chinner089716a2010-01-26 15:13:25 +11001745/*
1746 * Compare function is more complex than it needs to be because
1747 * the return value is only 32 bits and we are doing comparisons
1748 * on 64 bit values
1749 */
1750static int
1751xfs_buf_cmp(
1752 void *priv,
1753 struct list_head *a,
1754 struct list_head *b)
1755{
1756 struct xfs_buf *ap = container_of(a, struct xfs_buf, b_list);
1757 struct xfs_buf *bp = container_of(b, struct xfs_buf, b_list);
1758 xfs_daddr_t diff;
1759
Mark Tinguelyf4b42422012-12-04 17:18:02 -06001760 diff = ap->b_maps[0].bm_bn - bp->b_maps[0].bm_bn;
Dave Chinner089716a2010-01-26 15:13:25 +11001761 if (diff < 0)
1762 return -1;
1763 if (diff > 0)
1764 return 1;
1765 return 0;
1766}
1767
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001768static int
1769__xfs_buf_delwri_submit(
1770 struct list_head *buffer_list,
1771 struct list_head *io_list,
1772 bool wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001773{
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001774 struct blk_plug plug;
1775 struct xfs_buf *bp, *n;
1776 int pinned = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001778 list_for_each_entry_safe(bp, n, buffer_list, b_list) {
1779 if (!wait) {
1780 if (xfs_buf_ispinned(bp)) {
1781 pinned++;
1782 continue;
1783 }
1784 if (!xfs_buf_trylock(bp))
1785 continue;
1786 } else {
1787 xfs_buf_lock(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001790 /*
1791 * Someone else might have written the buffer synchronously or
1792 * marked it stale in the meantime. In that case only the
1793 * _XBF_DELWRI_Q flag got cleared, and we have to drop the
1794 * reference and remove it from the list here.
1795 */
1796 if (!(bp->b_flags & _XBF_DELWRI_Q)) {
1797 list_del_init(&bp->b_list);
1798 xfs_buf_relse(bp);
1799 continue;
1800 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001801
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001802 list_move_tail(&bp->b_list, io_list);
1803 trace_xfs_buf_delwri_split(bp, _RET_IP_);
1804 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001805
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001806 list_sort(NULL, io_list, xfs_buf_cmp);
Christoph Hellwiga1b7ea52011-03-30 11:05:09 +00001807
1808 blk_start_plug(&plug);
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001809 list_for_each_entry_safe(bp, n, io_list, b_list) {
Dave Chinnerac8809f2013-12-12 16:34:38 +11001810 bp->b_flags &= ~(_XBF_DELWRI_Q | XBF_ASYNC | XBF_WRITE_FAIL);
Dave Chinnercf53e992014-10-02 09:04:01 +10001811 bp->b_flags |= XBF_WRITE | XBF_ASYNC;
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001812
Dave Chinnercf53e992014-10-02 09:04:01 +10001813 /*
1814 * we do all Io submission async. This means if we need to wait
1815 * for IO completion we need to take an extra reference so the
1816 * buffer is still valid on the other side.
1817 */
1818 if (wait)
1819 xfs_buf_hold(bp);
1820 else
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001821 list_del_init(&bp->b_list);
Dave Chinner8dac3922014-10-02 09:04:40 +10001822
Dave Chinner595bff72014-10-02 09:05:14 +10001823 xfs_buf_submit(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001824 }
Christoph Hellwiga1b7ea52011-03-30 11:05:09 +00001825 blk_finish_plug(&plug);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001827 return pinned;
1828}
Nathan Scottf07c2252006-09-28 10:52:15 +10001829
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001830/*
1831 * Write out a buffer list asynchronously.
1832 *
1833 * This will take the @buffer_list, write all non-locked and non-pinned buffers
1834 * out and not wait for I/O completion on any of the buffers. This interface
1835 * is only safely useable for callers that can track I/O completion by higher
1836 * level means, e.g. AIL pushing as the @buffer_list is consumed in this
1837 * function.
1838 */
1839int
1840xfs_buf_delwri_submit_nowait(
1841 struct list_head *buffer_list)
1842{
1843 LIST_HEAD (io_list);
1844 return __xfs_buf_delwri_submit(buffer_list, &io_list, false);
1845}
1846
1847/*
1848 * Write out a buffer list synchronously.
1849 *
1850 * This will take the @buffer_list, write all buffers out and wait for I/O
1851 * completion on all of the buffers. @buffer_list is consumed by the function,
1852 * so callers must have some other way of tracking buffers if they require such
1853 * functionality.
1854 */
1855int
1856xfs_buf_delwri_submit(
1857 struct list_head *buffer_list)
1858{
1859 LIST_HEAD (io_list);
1860 int error = 0, error2;
1861 struct xfs_buf *bp;
1862
1863 __xfs_buf_delwri_submit(buffer_list, &io_list, true);
1864
1865 /* Wait for IO to complete. */
1866 while (!list_empty(&io_list)) {
1867 bp = list_first_entry(&io_list, struct xfs_buf, b_list);
1868
1869 list_del_init(&bp->b_list);
Dave Chinnercf53e992014-10-02 09:04:01 +10001870
1871 /* locking the buffer will wait for async IO completion. */
1872 xfs_buf_lock(bp);
1873 error2 = bp->b_error;
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001874 xfs_buf_relse(bp);
1875 if (!error)
1876 error = error2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877 }
1878
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001879 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001880}
1881
Christoph Hellwig04d8b282005-11-02 10:15:05 +11001882int __init
Nathan Scottce8e9222006-01-11 15:39:08 +11001883xfs_buf_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001884{
Nathan Scott87582802006-03-14 13:18:19 +11001885 xfs_buf_zone = kmem_zone_init_flags(sizeof(xfs_buf_t), "xfs_buf",
1886 KM_ZONE_HWALIGN, NULL);
Nathan Scottce8e9222006-01-11 15:39:08 +11001887 if (!xfs_buf_zone)
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001888 goto out;
Christoph Hellwig04d8b282005-11-02 10:15:05 +11001889
Christoph Hellwig23ea4032005-06-21 15:14:01 +10001890 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001892 out:
Nathan Scott87582802006-03-14 13:18:19 +11001893 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001894}
1895
Linus Torvalds1da177e2005-04-16 15:20:36 -07001896void
Nathan Scottce8e9222006-01-11 15:39:08 +11001897xfs_buf_terminate(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001898{
Nathan Scottce8e9222006-01-11 15:39:08 +11001899 kmem_zone_destroy(xfs_buf_zone);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900}