blob: 9a2191b911377f94e38d81d57d5d037a7e19ae8b [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
Bill O'Donnellff6d6af2015-10-12 18:21:22 +1100204 XFS_STATS_INC(target->bt_mount, 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,
Tetsuo Handa5bf97b12015-10-12 15:41:29 +1100357 "%s(%u) possible memory allocation deadlock in %s (mode:0x%x)",
358 current->comm, current->pid,
Harvey Harrison34a622b2008-04-10 12:19:21 +1000359 __func__, gfp_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360
Bill O'Donnellff6d6af2015-10-12 18:21:22 +1100361 XFS_STATS_INC(bp->b_target->bt_mount, xb_page_retries);
Jens Axboe8aa7e842009-07-09 14:52:32 +0200362 congestion_wait(BLK_RW_ASYNC, HZ/50);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 goto retry;
364 }
365
Bill O'Donnellff6d6af2015-10-12 18:21:22 +1100366 XFS_STATS_INC(bp->b_target->bt_mount, xb_page_found);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367
Dave Chinner0e6e8472011-03-26 09:16:45 +1100368 nbytes = min_t(size_t, size, PAGE_SIZE - offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 size -= nbytes;
Nathan Scottce8e9222006-01-11 15:39:08 +1100370 bp->b_pages[i] = page;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 offset = 0;
372 }
Dave Chinner0e6e8472011-03-26 09:16:45 +1100373 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374
Dave Chinner0e6e8472011-03-26 09:16:45 +1100375out_free_pages:
376 for (i = 0; i < bp->b_page_count; i++)
377 __free_page(bp->b_pages[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 return error;
379}
380
381/*
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300382 * Map buffer into kernel address-space if necessary.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 */
384STATIC int
Nathan Scottce8e9222006-01-11 15:39:08 +1100385_xfs_buf_map_pages(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 xfs_buf_t *bp,
387 uint flags)
388{
Dave Chinner0e6e8472011-03-26 09:16:45 +1100389 ASSERT(bp->b_flags & _XBF_PAGES);
Nathan Scottce8e9222006-01-11 15:39:08 +1100390 if (bp->b_page_count == 1) {
Dave Chinner0e6e8472011-03-26 09:16:45 +1100391 /* A single page buffer is always mappable */
Nathan Scottce8e9222006-01-11 15:39:08 +1100392 bp->b_addr = page_address(bp->b_pages[0]) + bp->b_offset;
Dave Chinner611c9942012-04-23 15:59:07 +1000393 } else if (flags & XBF_UNMAPPED) {
394 bp->b_addr = NULL;
395 } else {
Dave Chinnera19fb382011-03-26 09:13:42 +1100396 int retried = 0;
Dave Chinnerae687e52014-03-07 16:19:14 +1100397 unsigned noio_flag;
Dave Chinnera19fb382011-03-26 09:13:42 +1100398
Dave Chinnerae687e52014-03-07 16:19:14 +1100399 /*
400 * vm_map_ram() will allocate auxillary structures (e.g.
401 * pagetables) with GFP_KERNEL, yet we are likely to be under
402 * GFP_NOFS context here. Hence we need to tell memory reclaim
403 * that we are in such a context via PF_MEMALLOC_NOIO to prevent
404 * memory reclaim re-entering the filesystem here and
405 * potentially deadlocking.
406 */
407 noio_flag = memalloc_noio_save();
Dave Chinnera19fb382011-03-26 09:13:42 +1100408 do {
409 bp->b_addr = vm_map_ram(bp->b_pages, bp->b_page_count,
410 -1, PAGE_KERNEL);
411 if (bp->b_addr)
412 break;
413 vm_unmap_aliases();
414 } while (retried++ <= 1);
Dave Chinnerae687e52014-03-07 16:19:14 +1100415 memalloc_noio_restore(noio_flag);
Dave Chinnera19fb382011-03-26 09:13:42 +1100416
417 if (!bp->b_addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 return -ENOMEM;
Nathan Scottce8e9222006-01-11 15:39:08 +1100419 bp->b_addr += bp->b_offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 }
421
422 return 0;
423}
424
425/*
426 * Finding and Reading Buffers
427 */
428
429/*
Nathan Scottce8e9222006-01-11 15:39:08 +1100430 * Look up, and creates if absent, a lockable buffer for
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 * a given range of an inode. The buffer is returned
Chandra Seetharamaneabbaf12011-09-08 20:18:50 +0000432 * locked. No I/O is implied by this call.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 */
434xfs_buf_t *
Nathan Scottce8e9222006-01-11 15:39:08 +1100435_xfs_buf_find(
Dave Chinnere70b73f2012-04-23 15:58:49 +1000436 struct xfs_buftarg *btp,
Dave Chinner3e85c862012-06-22 18:50:09 +1000437 struct xfs_buf_map *map,
438 int nmaps,
Nathan Scottce8e9222006-01-11 15:39:08 +1100439 xfs_buf_flags_t flags,
440 xfs_buf_t *new_bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441{
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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453
454 /* Check for IOs smaller than the sector size / not sector aligned */
Dave Chinnerf79af0b2015-08-25 10:05:13 +1000455 ASSERT(!(BBTOB(numblks) < btp->bt_meta_sectorsize));
Eric Sandeen6da54172014-01-21 16:45:52 -0600456 ASSERT(!(BBTOB(blkno) & (xfs_off_t)btp->bt_meta_sectormask));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457
Dave Chinner10616b82013-01-21 23:53:52 +1100458 /*
459 * Corrupted block numbers can get through to here, unfortunately, so we
460 * have to check that the buffer falls within the filesystem bounds.
461 */
462 eofs = XFS_FSB_TO_BB(btp->bt_mount, btp->bt_mount->m_sb.sb_dblocks);
Eric Sandeendb52d092014-11-28 14:03:55 +1100463 if (blkno < 0 || blkno >= eofs) {
Dave Chinner10616b82013-01-21 23:53:52 +1100464 /*
Dave Chinner24513372014-06-25 14:58:08 +1000465 * XXX (dgc): we should really be returning -EFSCORRUPTED here,
Dave Chinner10616b82013-01-21 23:53:52 +1100466 * but none of the higher level infrastructure supports
467 * returning a specific error on buffer lookup failures.
468 */
469 xfs_alert(btp->bt_mount,
470 "%s: Block out of range: block 0x%llx, EOFS 0x%llx ",
471 __func__, blkno, eofs);
Dave Chinner7bc0dc22013-05-21 18:02:08 +1000472 WARN_ON(1);
Dave Chinner10616b82013-01-21 23:53:52 +1100473 return NULL;
474 }
475
Dave Chinner74f75a02010-09-24 19:59:04 +1000476 /* get tree root */
477 pag = xfs_perag_get(btp->bt_mount,
Dave Chinnere70b73f2012-04-23 15:58:49 +1000478 xfs_daddr_to_agno(btp->bt_mount, blkno));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479
Dave Chinner74f75a02010-09-24 19:59:04 +1000480 /* walk tree */
481 spin_lock(&pag->pag_buf_lock);
482 rbp = &pag->pag_buf_tree.rb_node;
483 parent = NULL;
484 bp = NULL;
485 while (*rbp) {
486 parent = *rbp;
487 bp = rb_entry(parent, struct xfs_buf, b_rbnode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488
Dave Chinnerde1cbee2012-04-23 15:58:50 +1000489 if (blkno < bp->b_bn)
Dave Chinner74f75a02010-09-24 19:59:04 +1000490 rbp = &(*rbp)->rb_left;
Dave Chinnerde1cbee2012-04-23 15:58:50 +1000491 else if (blkno > bp->b_bn)
Dave Chinner74f75a02010-09-24 19:59:04 +1000492 rbp = &(*rbp)->rb_right;
493 else {
494 /*
Dave Chinnerde1cbee2012-04-23 15:58:50 +1000495 * found a block number match. If the range doesn't
Dave Chinner74f75a02010-09-24 19:59:04 +1000496 * match, the only way this is allowed is if the buffer
497 * in the cache is stale and the transaction that made
498 * it stale has not yet committed. i.e. we are
499 * reallocating a busy extent. Skip this buffer and
500 * continue searching to the right for an exact match.
501 */
Dave Chinner4e94b712012-04-23 15:58:51 +1000502 if (bp->b_length != numblks) {
Dave Chinner74f75a02010-09-24 19:59:04 +1000503 ASSERT(bp->b_flags & XBF_STALE);
504 rbp = &(*rbp)->rb_right;
505 continue;
506 }
Nathan Scottce8e9222006-01-11 15:39:08 +1100507 atomic_inc(&bp->b_hold);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 goto found;
509 }
510 }
511
512 /* No match found */
Nathan Scottce8e9222006-01-11 15:39:08 +1100513 if (new_bp) {
Dave Chinner74f75a02010-09-24 19:59:04 +1000514 rb_link_node(&new_bp->b_rbnode, parent, rbp);
515 rb_insert_color(&new_bp->b_rbnode, &pag->pag_buf_tree);
516 /* the buffer keeps the perag reference until it is freed */
517 new_bp->b_pag = pag;
518 spin_unlock(&pag->pag_buf_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 } else {
Bill O'Donnellff6d6af2015-10-12 18:21:22 +1100520 XFS_STATS_INC(btp->bt_mount, xb_miss_locked);
Dave Chinner74f75a02010-09-24 19:59:04 +1000521 spin_unlock(&pag->pag_buf_lock);
522 xfs_perag_put(pag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 }
Nathan Scottce8e9222006-01-11 15:39:08 +1100524 return new_bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525
526found:
Dave Chinner74f75a02010-09-24 19:59:04 +1000527 spin_unlock(&pag->pag_buf_lock);
528 xfs_perag_put(pag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529
Christoph Hellwig0c842ad2011-07-08 14:36:19 +0200530 if (!xfs_buf_trylock(bp)) {
531 if (flags & XBF_TRYLOCK) {
Nathan Scottce8e9222006-01-11 15:39:08 +1100532 xfs_buf_rele(bp);
Bill O'Donnellff6d6af2015-10-12 18:21:22 +1100533 XFS_STATS_INC(btp->bt_mount, xb_busy_locked);
Nathan Scottce8e9222006-01-11 15:39:08 +1100534 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 }
Christoph Hellwig0c842ad2011-07-08 14:36:19 +0200536 xfs_buf_lock(bp);
Bill O'Donnellff6d6af2015-10-12 18:21:22 +1100537 XFS_STATS_INC(btp->bt_mount, xb_get_locked_waited);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 }
539
Dave Chinner0e6e8472011-03-26 09:16:45 +1100540 /*
541 * if the buffer is stale, clear all the external state associated with
542 * it. We need to keep flags such as how we allocated the buffer memory
543 * intact here.
544 */
Nathan Scottce8e9222006-01-11 15:39:08 +1100545 if (bp->b_flags & XBF_STALE) {
546 ASSERT((bp->b_flags & _XBF_DELWRI_Q) == 0);
Dave Chinnercfb02852012-11-12 22:54:19 +1100547 ASSERT(bp->b_iodone == NULL);
Dave Chinner611c9942012-04-23 15:59:07 +1000548 bp->b_flags &= _XBF_KMEM | _XBF_PAGES;
Dave Chinner1813dd62012-11-14 17:54:40 +1100549 bp->b_ops = NULL;
David Chinner2f926582005-09-05 08:33:35 +1000550 }
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000551
552 trace_xfs_buf_find(bp, flags, _RET_IP_);
Bill O'Donnellff6d6af2015-10-12 18:21:22 +1100553 XFS_STATS_INC(btp->bt_mount, xb_get_locked);
Nathan Scottce8e9222006-01-11 15:39:08 +1100554 return bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555}
556
557/*
Dave Chinner38158322011-09-30 04:45:02 +0000558 * Assembles a buffer covering the specified range. The code is optimised for
559 * cache hits, as metadata intensive workloads will see 3 orders of magnitude
560 * more hits than misses.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 */
Dave Chinner38158322011-09-30 04:45:02 +0000562struct xfs_buf *
Dave Chinner6dde2702012-06-22 18:50:10 +1000563xfs_buf_get_map(
564 struct xfs_buftarg *target,
565 struct xfs_buf_map *map,
566 int nmaps,
Nathan Scottce8e9222006-01-11 15:39:08 +1100567 xfs_buf_flags_t flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568{
Dave Chinner38158322011-09-30 04:45:02 +0000569 struct xfs_buf *bp;
570 struct xfs_buf *new_bp;
Dave Chinner0e6e8472011-03-26 09:16:45 +1100571 int error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572
Dave Chinner6dde2702012-06-22 18:50:10 +1000573 bp = _xfs_buf_find(target, map, nmaps, flags, NULL);
Dave Chinner38158322011-09-30 04:45:02 +0000574 if (likely(bp))
575 goto found;
576
Dave Chinner6dde2702012-06-22 18:50:10 +1000577 new_bp = _xfs_buf_alloc(target, map, nmaps, flags);
Nathan Scottce8e9222006-01-11 15:39:08 +1100578 if (unlikely(!new_bp))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 return NULL;
580
Dave Chinnerfe2429b2012-04-23 15:58:45 +1000581 error = xfs_buf_allocate_memory(new_bp, flags);
582 if (error) {
Dave Chinner3e85c862012-06-22 18:50:09 +1000583 xfs_buf_free(new_bp);
Dave Chinner38158322011-09-30 04:45:02 +0000584 return NULL;
585 }
586
Dave Chinner6dde2702012-06-22 18:50:10 +1000587 bp = _xfs_buf_find(target, map, nmaps, flags, new_bp);
Dave Chinnerfe2429b2012-04-23 15:58:45 +1000588 if (!bp) {
589 xfs_buf_free(new_bp);
590 return NULL;
591 }
592
593 if (bp != new_bp)
594 xfs_buf_free(new_bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595
Dave Chinner38158322011-09-30 04:45:02 +0000596found:
Dave Chinner611c9942012-04-23 15:59:07 +1000597 if (!bp->b_addr) {
Nathan Scottce8e9222006-01-11 15:39:08 +1100598 error = _xfs_buf_map_pages(bp, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 if (unlikely(error)) {
Dave Chinner4f107002011-03-07 10:00:35 +1100600 xfs_warn(target->bt_mount,
Eric Sandeen08e96e12013-10-11 20:59:05 -0500601 "%s: failed to map pagesn", __func__);
Dave Chinnera8acad72012-04-23 15:58:54 +1000602 xfs_buf_relse(bp);
603 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604 }
605 }
606
Dave Chinnerb79f4a12016-01-12 07:03:44 +1100607 /*
608 * Clear b_error if this is a lookup from a caller that doesn't expect
609 * valid data to be found in the buffer.
610 */
611 if (!(flags & XBF_READ))
612 xfs_buf_ioerror(bp, 0);
613
Bill O'Donnellff6d6af2015-10-12 18:21:22 +1100614 XFS_STATS_INC(target->bt_mount, xb_get);
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000615 trace_xfs_buf_get(bp, flags, _RET_IP_);
Nathan Scottce8e9222006-01-11 15:39:08 +1100616 return bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617}
618
Christoph Hellwig5d765b92008-12-03 12:20:26 +0100619STATIC int
620_xfs_buf_read(
621 xfs_buf_t *bp,
622 xfs_buf_flags_t flags)
623{
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000624 ASSERT(!(flags & XBF_WRITE));
Mark Tinguelyf4b42422012-12-04 17:18:02 -0600625 ASSERT(bp->b_maps[0].bm_bn != XFS_BUF_DADDR_NULL);
Christoph Hellwig5d765b92008-12-03 12:20:26 +0100626
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000627 bp->b_flags &= ~(XBF_WRITE | XBF_ASYNC | XBF_READ_AHEAD);
Christoph Hellwig1d5ae5d2011-07-08 14:36:32 +0200628 bp->b_flags |= flags & (XBF_READ | XBF_ASYNC | XBF_READ_AHEAD);
Christoph Hellwig5d765b92008-12-03 12:20:26 +0100629
Dave Chinner595bff72014-10-02 09:05:14 +1000630 if (flags & XBF_ASYNC) {
631 xfs_buf_submit(bp);
Dave Chinner0e95f192012-04-23 15:58:46 +1000632 return 0;
Dave Chinner595bff72014-10-02 09:05:14 +1000633 }
634 return xfs_buf_submit_wait(bp);
Christoph Hellwig5d765b92008-12-03 12:20:26 +0100635}
636
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637xfs_buf_t *
Dave Chinner6dde2702012-06-22 18:50:10 +1000638xfs_buf_read_map(
639 struct xfs_buftarg *target,
640 struct xfs_buf_map *map,
641 int nmaps,
Dave Chinnerc3f8fc72012-11-12 22:54:01 +1100642 xfs_buf_flags_t flags,
Dave Chinner1813dd62012-11-14 17:54:40 +1100643 const struct xfs_buf_ops *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644{
Dave Chinner6dde2702012-06-22 18:50:10 +1000645 struct xfs_buf *bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646
Nathan Scottce8e9222006-01-11 15:39:08 +1100647 flags |= XBF_READ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648
Dave Chinner6dde2702012-06-22 18:50:10 +1000649 bp = xfs_buf_get_map(target, map, nmaps, flags);
Nathan Scottce8e9222006-01-11 15:39:08 +1100650 if (bp) {
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000651 trace_xfs_buf_read(bp, flags, _RET_IP_);
652
Dave Chinnerb0388bf2016-02-10 15:01:11 +1100653 if (!(bp->b_flags & XBF_DONE)) {
Bill O'Donnellff6d6af2015-10-12 18:21:22 +1100654 XFS_STATS_INC(target->bt_mount, xb_get_read);
Dave Chinner1813dd62012-11-14 17:54:40 +1100655 bp->b_ops = ops;
Christoph Hellwig5d765b92008-12-03 12:20:26 +0100656 _xfs_buf_read(bp, flags);
Nathan Scottce8e9222006-01-11 15:39:08 +1100657 } else if (flags & XBF_ASYNC) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 /*
659 * Read ahead call which is already satisfied,
660 * drop the buffer
661 */
Dave Chinnera8acad72012-04-23 15:58:54 +1000662 xfs_buf_relse(bp);
663 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 /* We do not want read in the flags */
Nathan Scottce8e9222006-01-11 15:39:08 +1100666 bp->b_flags &= ~XBF_READ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667 }
668 }
669
Nathan Scottce8e9222006-01-11 15:39:08 +1100670 return bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671}
672
673/*
Nathan Scottce8e9222006-01-11 15:39:08 +1100674 * If we are not low on memory then do the readahead in a deadlock
675 * safe manner.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 */
677void
Dave Chinner6dde2702012-06-22 18:50:10 +1000678xfs_buf_readahead_map(
679 struct xfs_buftarg *target,
680 struct xfs_buf_map *map,
Dave Chinnerc3f8fc72012-11-12 22:54:01 +1100681 int nmaps,
Dave Chinner1813dd62012-11-14 17:54:40 +1100682 const struct xfs_buf_ops *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683{
Dave Chinner0e6e8472011-03-26 09:16:45 +1100684 if (bdi_read_congested(target->bt_bdi))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 return;
686
Dave Chinner6dde2702012-06-22 18:50:10 +1000687 xfs_buf_read_map(target, map, nmaps,
Dave Chinner1813dd62012-11-14 17:54:40 +1100688 XBF_TRYLOCK|XBF_ASYNC|XBF_READ_AHEAD, ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689}
690
Dave Chinner5adc94c2010-09-24 21:58:31 +1000691/*
692 * Read an uncached buffer from disk. Allocates and returns a locked
693 * buffer containing the disk contents or nothing.
694 */
Dave Chinnerba372672014-10-02 09:05:32 +1000695int
Dave Chinner5adc94c2010-09-24 21:58:31 +1000696xfs_buf_read_uncached(
Dave Chinner5adc94c2010-09-24 21:58:31 +1000697 struct xfs_buftarg *target,
698 xfs_daddr_t daddr,
Dave Chinnere70b73f2012-04-23 15:58:49 +1000699 size_t numblks,
Dave Chinnerc3f8fc72012-11-12 22:54:01 +1100700 int flags,
Dave Chinnerba372672014-10-02 09:05:32 +1000701 struct xfs_buf **bpp,
Dave Chinner1813dd62012-11-14 17:54:40 +1100702 const struct xfs_buf_ops *ops)
Dave Chinner5adc94c2010-09-24 21:58:31 +1000703{
Dave Chinnereab4e632012-11-12 22:54:02 +1100704 struct xfs_buf *bp;
Dave Chinner5adc94c2010-09-24 21:58:31 +1000705
Dave Chinnerba372672014-10-02 09:05:32 +1000706 *bpp = NULL;
707
Dave Chinnere70b73f2012-04-23 15:58:49 +1000708 bp = xfs_buf_get_uncached(target, numblks, flags);
Dave Chinner5adc94c2010-09-24 21:58:31 +1000709 if (!bp)
Dave Chinnerba372672014-10-02 09:05:32 +1000710 return -ENOMEM;
Dave Chinner5adc94c2010-09-24 21:58:31 +1000711
712 /* set up the buffer for a read IO */
Dave Chinner3e85c862012-06-22 18:50:09 +1000713 ASSERT(bp->b_map_count == 1);
Dave Chinnerba372672014-10-02 09:05:32 +1000714 bp->b_bn = XFS_BUF_DADDR_NULL; /* always null for uncached buffers */
Dave Chinner3e85c862012-06-22 18:50:09 +1000715 bp->b_maps[0].bm_bn = daddr;
Dave Chinnercbb7baab2012-06-22 18:50:08 +1000716 bp->b_flags |= XBF_READ;
Dave Chinner1813dd62012-11-14 17:54:40 +1100717 bp->b_ops = ops;
Dave Chinner5adc94c2010-09-24 21:58:31 +1000718
Dave Chinner595bff72014-10-02 09:05:14 +1000719 xfs_buf_submit_wait(bp);
Dave Chinnerba372672014-10-02 09:05:32 +1000720 if (bp->b_error) {
721 int error = bp->b_error;
Christoph Hellwig83a0adc2013-12-17 00:03:52 -0800722 xfs_buf_relse(bp);
Dave Chinnerba372672014-10-02 09:05:32 +1000723 return error;
Christoph Hellwig83a0adc2013-12-17 00:03:52 -0800724 }
Dave Chinnerba372672014-10-02 09:05:32 +1000725
726 *bpp = bp;
727 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728}
729
Dave Chinner44396472011-04-21 09:34:27 +0000730/*
731 * Return a buffer allocated as an empty buffer and associated to external
732 * memory via xfs_buf_associate_memory() back to it's empty state.
733 */
734void
735xfs_buf_set_empty(
736 struct xfs_buf *bp,
Dave Chinnere70b73f2012-04-23 15:58:49 +1000737 size_t numblks)
Dave Chinner44396472011-04-21 09:34:27 +0000738{
739 if (bp->b_pages)
740 _xfs_buf_free_pages(bp);
741
742 bp->b_pages = NULL;
743 bp->b_page_count = 0;
744 bp->b_addr = NULL;
Dave Chinner4e94b712012-04-23 15:58:51 +1000745 bp->b_length = numblks;
Dave Chinneraa0e8832012-04-23 15:58:52 +1000746 bp->b_io_length = numblks;
Dave Chinner3e85c862012-06-22 18:50:09 +1000747
748 ASSERT(bp->b_map_count == 1);
Dave Chinner44396472011-04-21 09:34:27 +0000749 bp->b_bn = XFS_BUF_DADDR_NULL;
Dave Chinner3e85c862012-06-22 18:50:09 +1000750 bp->b_maps[0].bm_bn = XFS_BUF_DADDR_NULL;
751 bp->b_maps[0].bm_len = bp->b_length;
Dave Chinner44396472011-04-21 09:34:27 +0000752}
753
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754static inline struct page *
755mem_to_page(
756 void *addr)
757{
Christoph Lameter9e2779f2008-02-04 22:28:34 -0800758 if ((!is_vmalloc_addr(addr))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 return virt_to_page(addr);
760 } else {
761 return vmalloc_to_page(addr);
762 }
763}
764
765int
Nathan Scottce8e9222006-01-11 15:39:08 +1100766xfs_buf_associate_memory(
767 xfs_buf_t *bp,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 void *mem,
769 size_t len)
770{
771 int rval;
772 int i = 0;
Lachlan McIlroyd1afb672007-11-27 17:01:24 +1100773 unsigned long pageaddr;
774 unsigned long offset;
775 size_t buflen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 int page_count;
777
Dave Chinner0e6e8472011-03-26 09:16:45 +1100778 pageaddr = (unsigned long)mem & PAGE_MASK;
Lachlan McIlroyd1afb672007-11-27 17:01:24 +1100779 offset = (unsigned long)mem - pageaddr;
Dave Chinner0e6e8472011-03-26 09:16:45 +1100780 buflen = PAGE_ALIGN(len + offset);
781 page_count = buflen >> PAGE_SHIFT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782
783 /* Free any previous set of page pointers */
Nathan Scottce8e9222006-01-11 15:39:08 +1100784 if (bp->b_pages)
785 _xfs_buf_free_pages(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786
Nathan Scottce8e9222006-01-11 15:39:08 +1100787 bp->b_pages = NULL;
788 bp->b_addr = mem;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789
Eric Sandeen87937bf2014-04-14 19:01:20 +1000790 rval = _xfs_buf_get_pages(bp, page_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791 if (rval)
792 return rval;
793
Nathan Scottce8e9222006-01-11 15:39:08 +1100794 bp->b_offset = offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795
Lachlan McIlroyd1afb672007-11-27 17:01:24 +1100796 for (i = 0; i < bp->b_page_count; i++) {
797 bp->b_pages[i] = mem_to_page((void *)pageaddr);
Dave Chinner0e6e8472011-03-26 09:16:45 +1100798 pageaddr += PAGE_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800
Dave Chinneraa0e8832012-04-23 15:58:52 +1000801 bp->b_io_length = BTOBB(len);
Dave Chinner4e94b712012-04-23 15:58:51 +1000802 bp->b_length = BTOBB(buflen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803
804 return 0;
805}
806
807xfs_buf_t *
Dave Chinner686865f2010-09-24 20:07:47 +1000808xfs_buf_get_uncached(
809 struct xfs_buftarg *target,
Dave Chinnere70b73f2012-04-23 15:58:49 +1000810 size_t numblks,
Dave Chinner686865f2010-09-24 20:07:47 +1000811 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812{
Dave Chinnere70b73f2012-04-23 15:58:49 +1000813 unsigned long page_count;
Christoph Hellwig1fa40b02007-05-14 18:23:50 +1000814 int error, i;
Dave Chinner3e85c862012-06-22 18:50:09 +1000815 struct xfs_buf *bp;
816 DEFINE_SINGLE_BUF_MAP(map, XFS_BUF_DADDR_NULL, numblks);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817
Dave Chinner3e85c862012-06-22 18:50:09 +1000818 bp = _xfs_buf_alloc(target, &map, 1, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819 if (unlikely(bp == NULL))
820 goto fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821
Dave Chinnere70b73f2012-04-23 15:58:49 +1000822 page_count = PAGE_ALIGN(numblks << BBSHIFT) >> PAGE_SHIFT;
Eric Sandeen87937bf2014-04-14 19:01:20 +1000823 error = _xfs_buf_get_pages(bp, page_count);
Christoph Hellwig1fa40b02007-05-14 18:23:50 +1000824 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825 goto fail_free_buf;
826
Christoph Hellwig1fa40b02007-05-14 18:23:50 +1000827 for (i = 0; i < page_count; i++) {
Dave Chinner686865f2010-09-24 20:07:47 +1000828 bp->b_pages[i] = alloc_page(xb_to_gfp(flags));
Christoph Hellwig1fa40b02007-05-14 18:23:50 +1000829 if (!bp->b_pages[i])
830 goto fail_free_mem;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831 }
Christoph Hellwig1fa40b02007-05-14 18:23:50 +1000832 bp->b_flags |= _XBF_PAGES;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833
Dave Chinner611c9942012-04-23 15:59:07 +1000834 error = _xfs_buf_map_pages(bp, 0);
Christoph Hellwig1fa40b02007-05-14 18:23:50 +1000835 if (unlikely(error)) {
Dave Chinner4f107002011-03-07 10:00:35 +1100836 xfs_warn(target->bt_mount,
Eric Sandeen08e96e12013-10-11 20:59:05 -0500837 "%s: failed to map pages", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 goto fail_free_mem;
Christoph Hellwig1fa40b02007-05-14 18:23:50 +1000839 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840
Dave Chinner686865f2010-09-24 20:07:47 +1000841 trace_xfs_buf_get_uncached(bp, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 return bp;
Christoph Hellwig1fa40b02007-05-14 18:23:50 +1000843
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 fail_free_mem:
Christoph Hellwig1fa40b02007-05-14 18:23:50 +1000845 while (--i >= 0)
846 __free_page(bp->b_pages[i]);
Christoph Hellwigca165b82007-05-24 15:21:11 +1000847 _xfs_buf_free_pages(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 fail_free_buf:
Dave Chinner3e85c862012-06-22 18:50:09 +1000849 xfs_buf_free_maps(bp);
Christoph Hellwig4347b9d2011-10-10 16:52:48 +0000850 kmem_zone_free(xfs_buf_zone, bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851 fail:
852 return NULL;
853}
854
855/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 * Increment reference count on buffer, to hold the buffer concurrently
857 * with another thread which may release (free) the buffer asynchronously.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 * Must hold the buffer already to call this function.
859 */
860void
Nathan Scottce8e9222006-01-11 15:39:08 +1100861xfs_buf_hold(
862 xfs_buf_t *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863{
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000864 trace_xfs_buf_hold(bp, _RET_IP_);
Nathan Scottce8e9222006-01-11 15:39:08 +1100865 atomic_inc(&bp->b_hold);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866}
867
868/*
Nathan Scottce8e9222006-01-11 15:39:08 +1100869 * Releases a hold on the specified buffer. If the
870 * the hold count is 1, calls xfs_buf_free.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871 */
872void
Nathan Scottce8e9222006-01-11 15:39:08 +1100873xfs_buf_rele(
874 xfs_buf_t *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875{
Dave Chinner74f75a02010-09-24 19:59:04 +1000876 struct xfs_perag *pag = bp->b_pag;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000878 trace_xfs_buf_rele(bp, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879
Dave Chinner74f75a02010-09-24 19:59:04 +1000880 if (!pag) {
Dave Chinner430cbeb2010-12-02 16:30:55 +1100881 ASSERT(list_empty(&bp->b_lru));
Dave Chinner74f75a02010-09-24 19:59:04 +1000882 ASSERT(RB_EMPTY_NODE(&bp->b_rbnode));
Nathan Scottfad3aa12006-02-01 12:14:52 +1100883 if (atomic_dec_and_test(&bp->b_hold))
884 xfs_buf_free(bp);
885 return;
886 }
887
Dave Chinner74f75a02010-09-24 19:59:04 +1000888 ASSERT(!RB_EMPTY_NODE(&bp->b_rbnode));
Dave Chinner430cbeb2010-12-02 16:30:55 +1100889
Lachlan McIlroy37906892008-08-13 15:42:10 +1000890 ASSERT(atomic_read(&bp->b_hold) > 0);
Dave Chinner74f75a02010-09-24 19:59:04 +1000891 if (atomic_dec_and_lock(&bp->b_hold, &pag->pag_buf_lock)) {
Dave Chinnera4082352013-08-28 10:18:06 +1000892 spin_lock(&bp->b_lock);
893 if (!(bp->b_flags & XBF_STALE) && atomic_read(&bp->b_lru_ref)) {
894 /*
895 * If the buffer is added to the LRU take a new
896 * reference to the buffer for the LRU and clear the
897 * (now stale) dispose list state flag
898 */
899 if (list_lru_add(&bp->b_target->bt_lru, &bp->b_lru)) {
900 bp->b_state &= ~XFS_BSTATE_DISPOSE;
901 atomic_inc(&bp->b_hold);
902 }
903 spin_unlock(&bp->b_lock);
Dave Chinner430cbeb2010-12-02 16:30:55 +1100904 spin_unlock(&pag->pag_buf_lock);
Christoph Hellwig7f14d0a2005-11-02 15:09:35 +1100905 } else {
Dave Chinnera4082352013-08-28 10:18:06 +1000906 /*
907 * most of the time buffers will already be removed from
908 * the LRU, so optimise that case by checking for the
909 * XFS_BSTATE_DISPOSE flag indicating the last list the
910 * buffer was on was the disposal list
911 */
912 if (!(bp->b_state & XFS_BSTATE_DISPOSE)) {
913 list_lru_del(&bp->b_target->bt_lru, &bp->b_lru);
914 } else {
915 ASSERT(list_empty(&bp->b_lru));
916 }
917 spin_unlock(&bp->b_lock);
918
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000919 ASSERT(!(bp->b_flags & _XBF_DELWRI_Q));
Dave Chinner74f75a02010-09-24 19:59:04 +1000920 rb_erase(&bp->b_rbnode, &pag->pag_buf_tree);
921 spin_unlock(&pag->pag_buf_lock);
922 xfs_perag_put(pag);
Nathan Scottce8e9222006-01-11 15:39:08 +1100923 xfs_buf_free(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 }
925 }
926}
927
928
929/*
Dave Chinner0e6e8472011-03-26 09:16:45 +1100930 * Lock a buffer object, if it is not already locked.
Dave Chinner90810b92010-11-30 15:16:16 +1100931 *
932 * If we come across a stale, pinned, locked buffer, we know that we are
933 * being asked to lock a buffer that has been reallocated. Because it is
934 * pinned, we know that the log has not been pushed to disk and hence it
935 * will still be locked. Rather than continuing to have trylock attempts
936 * fail until someone else pushes the log, push it ourselves before
937 * returning. This means that the xfsaild will not get stuck trying
938 * to push on stale inode buffers.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939 */
940int
Christoph Hellwig0c842ad2011-07-08 14:36:19 +0200941xfs_buf_trylock(
942 struct xfs_buf *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943{
944 int locked;
945
Nathan Scottce8e9222006-01-11 15:39:08 +1100946 locked = down_trylock(&bp->b_sema) == 0;
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000947 if (locked)
Nathan Scottce8e9222006-01-11 15:39:08 +1100948 XB_SET_OWNER(bp);
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000949
Christoph Hellwig0c842ad2011-07-08 14:36:19 +0200950 trace_xfs_buf_trylock(bp, _RET_IP_);
951 return locked;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953
954/*
Dave Chinner0e6e8472011-03-26 09:16:45 +1100955 * Lock a buffer object.
Dave Chinnered3b4d62010-05-21 12:07:08 +1000956 *
957 * If we come across a stale, pinned, locked buffer, we know that we
958 * are being asked to lock a buffer that has been reallocated. Because
959 * it is pinned, we know that the log has not been pushed to disk and
960 * hence it will still be locked. Rather than sleeping until someone
961 * else pushes the log, push it ourselves before trying to get the lock.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962 */
Nathan Scottce8e9222006-01-11 15:39:08 +1100963void
964xfs_buf_lock(
Christoph Hellwig0c842ad2011-07-08 14:36:19 +0200965 struct xfs_buf *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966{
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000967 trace_xfs_buf_lock(bp, _RET_IP_);
968
Dave Chinnered3b4d62010-05-21 12:07:08 +1000969 if (atomic_read(&bp->b_pin_count) && (bp->b_flags & XBF_STALE))
Dave Chinnerebad8612010-09-22 10:47:20 +1000970 xfs_log_force(bp->b_target->bt_mount, 0);
Nathan Scottce8e9222006-01-11 15:39:08 +1100971 down(&bp->b_sema);
972 XB_SET_OWNER(bp);
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000973
974 trace_xfs_buf_lock_done(bp, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975}
976
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977void
Nathan Scottce8e9222006-01-11 15:39:08 +1100978xfs_buf_unlock(
Christoph Hellwig0c842ad2011-07-08 14:36:19 +0200979 struct xfs_buf *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980{
Nathan Scottce8e9222006-01-11 15:39:08 +1100981 XB_CLEAR_OWNER(bp);
982 up(&bp->b_sema);
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000983
984 trace_xfs_buf_unlock(bp, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985}
986
Nathan Scottce8e9222006-01-11 15:39:08 +1100987STATIC void
988xfs_buf_wait_unpin(
989 xfs_buf_t *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990{
991 DECLARE_WAITQUEUE (wait, current);
992
Nathan Scottce8e9222006-01-11 15:39:08 +1100993 if (atomic_read(&bp->b_pin_count) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994 return;
995
Nathan Scottce8e9222006-01-11 15:39:08 +1100996 add_wait_queue(&bp->b_waiters, &wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997 for (;;) {
998 set_current_state(TASK_UNINTERRUPTIBLE);
Nathan Scottce8e9222006-01-11 15:39:08 +1100999 if (atomic_read(&bp->b_pin_count) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000 break;
Jens Axboe7eaceac2011-03-10 08:52:07 +01001001 io_schedule();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002 }
Nathan Scottce8e9222006-01-11 15:39:08 +11001003 remove_wait_queue(&bp->b_waiters, &wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004 set_current_state(TASK_RUNNING);
1005}
1006
1007/*
1008 * Buffer Utility Routines
1009 */
1010
Dave Chinnere8aaba92014-10-02 09:04:22 +10001011void
1012xfs_buf_ioend(
1013 struct xfs_buf *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014{
Dave Chinnere8aaba92014-10-02 09:04:22 +10001015 bool read = bp->b_flags & XBF_READ;
1016
1017 trace_xfs_buf_iodone(bp, _RET_IP_);
Dave Chinner1813dd62012-11-14 17:54:40 +11001018
1019 bp->b_flags &= ~(XBF_READ | XBF_WRITE | XBF_READ_AHEAD);
Dave Chinnerd5929de2013-02-27 13:25:54 +11001020
Dave Chinner61be9c52014-10-02 09:04:31 +10001021 /*
1022 * Pull in IO completion errors now. We are guaranteed to be running
1023 * single threaded, so we don't need the lock to read b_io_error.
1024 */
1025 if (!bp->b_error && bp->b_io_error)
1026 xfs_buf_ioerror(bp, bp->b_io_error);
1027
Dave Chinnere8aaba92014-10-02 09:04:22 +10001028 /* Only validate buffers that were read without errors */
1029 if (read && !bp->b_error && bp->b_ops) {
1030 ASSERT(!bp->b_iodone);
Dave Chinner1813dd62012-11-14 17:54:40 +11001031 bp->b_ops->verify_read(bp);
Dave Chinnere8aaba92014-10-02 09:04:22 +10001032 }
1033
1034 if (!bp->b_error)
1035 bp->b_flags |= XBF_DONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036
Christoph Hellwig80f6c292010-08-18 05:29:11 -04001037 if (bp->b_iodone)
Nathan Scottce8e9222006-01-11 15:39:08 +11001038 (*(bp->b_iodone))(bp);
1039 else if (bp->b_flags & XBF_ASYNC)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 xfs_buf_relse(bp);
Dave Chinner595bff72014-10-02 09:05:14 +10001041 else
Dave Chinner1813dd62012-11-14 17:54:40 +11001042 complete(&bp->b_iowait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043}
1044
Dave Chinnere8aaba92014-10-02 09:04:22 +10001045static void
1046xfs_buf_ioend_work(
1047 struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048{
Dave Chinnere8aaba92014-10-02 09:04:22 +10001049 struct xfs_buf *bp =
Brian Fosterb29c70f2014-12-04 09:43:17 +11001050 container_of(work, xfs_buf_t, b_ioend_work);
Dave Chinner1813dd62012-11-14 17:54:40 +11001051
Dave Chinnere8aaba92014-10-02 09:04:22 +10001052 xfs_buf_ioend(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053}
1054
Alexander Kuleshov211fe1a2016-01-04 16:10:42 +11001055static void
Dave Chinnere8aaba92014-10-02 09:04:22 +10001056xfs_buf_ioend_async(
1057 struct xfs_buf *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058{
Brian Fosterb29c70f2014-12-04 09:43:17 +11001059 INIT_WORK(&bp->b_ioend_work, xfs_buf_ioend_work);
1060 queue_work(bp->b_ioend_wq, &bp->b_ioend_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061}
1062
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063void
Nathan Scottce8e9222006-01-11 15:39:08 +11001064xfs_buf_ioerror(
1065 xfs_buf_t *bp,
1066 int error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067{
Dave Chinner24513372014-06-25 14:58:08 +10001068 ASSERT(error <= 0 && error >= -1000);
1069 bp->b_error = error;
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001070 trace_xfs_buf_ioerror(bp, error, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071}
1072
Christoph Hellwig901796a2011-10-10 16:52:49 +00001073void
1074xfs_buf_ioerror_alert(
1075 struct xfs_buf *bp,
1076 const char *func)
1077{
1078 xfs_alert(bp->b_target->bt_mount,
Dave Chinneraa0e8832012-04-23 15:58:52 +10001079"metadata I/O error: block 0x%llx (\"%s\") error %d numblks %d",
Dave Chinner24513372014-06-25 14:58:08 +10001080 (__uint64_t)XFS_BUF_ADDR(bp), func, -bp->b_error, bp->b_length);
Christoph Hellwig901796a2011-10-10 16:52:49 +00001081}
1082
Christoph Hellwiga2dcf5d2012-07-13 02:24:10 -04001083int
1084xfs_bwrite(
1085 struct xfs_buf *bp)
1086{
1087 int error;
1088
1089 ASSERT(xfs_buf_islocked(bp));
1090
1091 bp->b_flags |= XBF_WRITE;
Dave Chinner27187752014-10-02 09:04:56 +10001092 bp->b_flags &= ~(XBF_ASYNC | XBF_READ | _XBF_DELWRI_Q |
1093 XBF_WRITE_FAIL | XBF_DONE);
Christoph Hellwiga2dcf5d2012-07-13 02:24:10 -04001094
Dave Chinner595bff72014-10-02 09:05:14 +10001095 error = xfs_buf_submit_wait(bp);
Christoph Hellwiga2dcf5d2012-07-13 02:24:10 -04001096 if (error) {
1097 xfs_force_shutdown(bp->b_target->bt_mount,
1098 SHUTDOWN_META_IO_ERROR);
1099 }
1100 return error;
1101}
1102
Christoph Hellwigb8f82a42009-11-14 16:17:22 +00001103STATIC void
Nathan Scottce8e9222006-01-11 15:39:08 +11001104xfs_buf_bio_end_io(
Christoph Hellwig4246a0b2015-07-20 15:29:37 +02001105 struct bio *bio)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106{
Nathan Scottce8e9222006-01-11 15:39:08 +11001107 xfs_buf_t *bp = (xfs_buf_t *)bio->bi_private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108
Dave Chinner37eb17e2012-11-12 22:09:46 +11001109 /*
1110 * don't overwrite existing errors - otherwise we can lose errors on
1111 * buffers that require multiple bios to complete.
1112 */
Christoph Hellwig4246a0b2015-07-20 15:29:37 +02001113 if (bio->bi_error) {
Dave Chinner61be9c52014-10-02 09:04:31 +10001114 spin_lock(&bp->b_lock);
1115 if (!bp->b_io_error)
Christoph Hellwig4246a0b2015-07-20 15:29:37 +02001116 bp->b_io_error = bio->bi_error;
Dave Chinner61be9c52014-10-02 09:04:31 +10001117 spin_unlock(&bp->b_lock);
1118 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119
Dave Chinner37eb17e2012-11-12 22:09:46 +11001120 if (!bp->b_error && xfs_buf_is_vmapped(bp) && (bp->b_flags & XBF_READ))
James Bottomley73c77e22010-01-25 11:42:24 -06001121 invalidate_kernel_vmap_range(bp->b_addr, xfs_buf_vmap_len(bp));
1122
Dave Chinnere8aaba92014-10-02 09:04:22 +10001123 if (atomic_dec_and_test(&bp->b_io_remaining) == 1)
1124 xfs_buf_ioend_async(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125 bio_put(bio);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126}
1127
Dave Chinner3e85c862012-06-22 18:50:09 +10001128static void
1129xfs_buf_ioapply_map(
1130 struct xfs_buf *bp,
1131 int map,
1132 int *buf_offset,
1133 int *count,
1134 int rw)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001135{
Dave Chinner3e85c862012-06-22 18:50:09 +10001136 int page_index;
1137 int total_nr_pages = bp->b_page_count;
1138 int nr_pages;
1139 struct bio *bio;
1140 sector_t sector = bp->b_maps[map].bm_bn;
1141 int size;
1142 int offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143
Nathan Scottce8e9222006-01-11 15:39:08 +11001144 total_nr_pages = bp->b_page_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145
Dave Chinner3e85c862012-06-22 18:50:09 +10001146 /* skip the pages in the buffer before the start offset */
1147 page_index = 0;
1148 offset = *buf_offset;
1149 while (offset >= PAGE_SIZE) {
1150 page_index++;
1151 offset -= PAGE_SIZE;
Christoph Hellwigf538d4d2005-11-02 10:26:59 +11001152 }
1153
Dave Chinner3e85c862012-06-22 18:50:09 +10001154 /*
1155 * Limit the IO size to the length of the current vector, and update the
1156 * remaining IO count for the next time around.
1157 */
1158 size = min_t(int, BBTOB(bp->b_maps[map].bm_len), *count);
1159 *count -= size;
1160 *buf_offset += size;
Christoph Hellwig34951f52011-07-26 15:06:44 +00001161
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162next_chunk:
Nathan Scottce8e9222006-01-11 15:39:08 +11001163 atomic_inc(&bp->b_io_remaining);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164 nr_pages = BIO_MAX_SECTORS >> (PAGE_SHIFT - BBSHIFT);
1165 if (nr_pages > total_nr_pages)
1166 nr_pages = total_nr_pages;
1167
1168 bio = bio_alloc(GFP_NOIO, nr_pages);
Nathan Scottce8e9222006-01-11 15:39:08 +11001169 bio->bi_bdev = bp->b_target->bt_bdev;
Kent Overstreet4f024f32013-10-11 15:44:27 -07001170 bio->bi_iter.bi_sector = sector;
Nathan Scottce8e9222006-01-11 15:39:08 +11001171 bio->bi_end_io = xfs_buf_bio_end_io;
1172 bio->bi_private = bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173
Dave Chinner0e6e8472011-03-26 09:16:45 +11001174
Dave Chinner3e85c862012-06-22 18:50:09 +10001175 for (; size && nr_pages; nr_pages--, page_index++) {
Dave Chinner0e6e8472011-03-26 09:16:45 +11001176 int rbytes, nbytes = PAGE_SIZE - offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177
1178 if (nbytes > size)
1179 nbytes = size;
1180
Dave Chinner3e85c862012-06-22 18:50:09 +10001181 rbytes = bio_add_page(bio, bp->b_pages[page_index], nbytes,
1182 offset);
Nathan Scottce8e9222006-01-11 15:39:08 +11001183 if (rbytes < nbytes)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184 break;
1185
1186 offset = 0;
Dave Chinneraa0e8832012-04-23 15:58:52 +10001187 sector += BTOBB(nbytes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188 size -= nbytes;
1189 total_nr_pages--;
1190 }
1191
Kent Overstreet4f024f32013-10-11 15:44:27 -07001192 if (likely(bio->bi_iter.bi_size)) {
James Bottomley73c77e22010-01-25 11:42:24 -06001193 if (xfs_buf_is_vmapped(bp)) {
1194 flush_kernel_vmap_range(bp->b_addr,
1195 xfs_buf_vmap_len(bp));
1196 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197 submit_bio(rw, bio);
1198 if (size)
1199 goto next_chunk;
1200 } else {
Dave Chinner37eb17e2012-11-12 22:09:46 +11001201 /*
1202 * This is guaranteed not to be the last io reference count
Dave Chinner595bff72014-10-02 09:05:14 +10001203 * because the caller (xfs_buf_submit) holds a count itself.
Dave Chinner37eb17e2012-11-12 22:09:46 +11001204 */
1205 atomic_dec(&bp->b_io_remaining);
Dave Chinner24513372014-06-25 14:58:08 +10001206 xfs_buf_ioerror(bp, -EIO);
Dave Chinnerec53d1d2010-07-20 17:52:59 +10001207 bio_put(bio);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208 }
Dave Chinner3e85c862012-06-22 18:50:09 +10001209
1210}
1211
1212STATIC void
1213_xfs_buf_ioapply(
1214 struct xfs_buf *bp)
1215{
1216 struct blk_plug plug;
1217 int rw;
1218 int offset;
1219 int size;
1220 int i;
1221
Dave Chinnerc163f9a2013-03-12 23:30:34 +11001222 /*
1223 * Make sure we capture only current IO errors rather than stale errors
1224 * left over from previous use of the buffer (e.g. failed readahead).
1225 */
1226 bp->b_error = 0;
1227
Brian Fosterb29c70f2014-12-04 09:43:17 +11001228 /*
1229 * Initialize the I/O completion workqueue if we haven't yet or the
1230 * submitter has not opted to specify a custom one.
1231 */
1232 if (!bp->b_ioend_wq)
1233 bp->b_ioend_wq = bp->b_target->bt_mount->m_buf_workqueue;
1234
Dave Chinner3e85c862012-06-22 18:50:09 +10001235 if (bp->b_flags & XBF_WRITE) {
1236 if (bp->b_flags & XBF_SYNCIO)
1237 rw = WRITE_SYNC;
1238 else
1239 rw = WRITE;
1240 if (bp->b_flags & XBF_FUA)
1241 rw |= REQ_FUA;
1242 if (bp->b_flags & XBF_FLUSH)
1243 rw |= REQ_FLUSH;
Dave Chinner1813dd62012-11-14 17:54:40 +11001244
1245 /*
1246 * Run the write verifier callback function if it exists. If
1247 * this function fails it will mark the buffer with an error and
1248 * the IO should not be dispatched.
1249 */
1250 if (bp->b_ops) {
1251 bp->b_ops->verify_write(bp);
1252 if (bp->b_error) {
1253 xfs_force_shutdown(bp->b_target->bt_mount,
1254 SHUTDOWN_CORRUPT_INCORE);
1255 return;
1256 }
Dave Chinner400b9d82014-08-04 12:42:40 +10001257 } else if (bp->b_bn != XFS_BUF_DADDR_NULL) {
1258 struct xfs_mount *mp = bp->b_target->bt_mount;
1259
1260 /*
1261 * non-crc filesystems don't attach verifiers during
1262 * log recovery, so don't warn for such filesystems.
1263 */
1264 if (xfs_sb_version_hascrc(&mp->m_sb)) {
1265 xfs_warn(mp,
1266 "%s: no ops on block 0x%llx/0x%x",
1267 __func__, bp->b_bn, bp->b_length);
1268 xfs_hex_dump(bp->b_addr, 64);
1269 dump_stack();
1270 }
Dave Chinner1813dd62012-11-14 17:54:40 +11001271 }
Dave Chinner3e85c862012-06-22 18:50:09 +10001272 } else if (bp->b_flags & XBF_READ_AHEAD) {
1273 rw = READA;
1274 } else {
1275 rw = READ;
1276 }
1277
1278 /* we only use the buffer cache for meta-data */
1279 rw |= REQ_META;
1280
1281 /*
1282 * Walk all the vectors issuing IO on them. Set up the initial offset
1283 * into the buffer and the desired IO size before we start -
1284 * _xfs_buf_ioapply_vec() will modify them appropriately for each
1285 * subsequent call.
1286 */
1287 offset = bp->b_offset;
1288 size = BBTOB(bp->b_io_length);
1289 blk_start_plug(&plug);
1290 for (i = 0; i < bp->b_map_count; i++) {
1291 xfs_buf_ioapply_map(bp, i, &offset, &size, rw);
1292 if (bp->b_error)
1293 break;
1294 if (size <= 0)
1295 break; /* all done */
1296 }
1297 blk_finish_plug(&plug);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298}
1299
Dave Chinner595bff72014-10-02 09:05:14 +10001300/*
1301 * Asynchronous IO submission path. This transfers the buffer lock ownership and
1302 * the current reference to the IO. It is not safe to reference the buffer after
1303 * a call to this function unless the caller holds an additional reference
1304 * itself.
1305 */
Dave Chinner0e95f192012-04-23 15:58:46 +10001306void
Dave Chinner595bff72014-10-02 09:05:14 +10001307xfs_buf_submit(
1308 struct xfs_buf *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309{
Dave Chinner595bff72014-10-02 09:05:14 +10001310 trace_xfs_buf_submit(bp, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001312 ASSERT(!(bp->b_flags & _XBF_DELWRI_Q));
Dave Chinner595bff72014-10-02 09:05:14 +10001313 ASSERT(bp->b_flags & XBF_ASYNC);
1314
1315 /* on shutdown we stale and complete the buffer immediately */
1316 if (XFS_FORCED_SHUTDOWN(bp->b_target->bt_mount)) {
1317 xfs_buf_ioerror(bp, -EIO);
1318 bp->b_flags &= ~XBF_DONE;
1319 xfs_buf_stale(bp);
1320 xfs_buf_ioend(bp);
1321 return;
1322 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323
Christoph Hellwig375ec69d2011-08-23 08:28:03 +00001324 if (bp->b_flags & XBF_WRITE)
Nathan Scottce8e9222006-01-11 15:39:08 +11001325 xfs_buf_wait_unpin(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326
Dave Chinner61be9c52014-10-02 09:04:31 +10001327 /* clear the internal error state to avoid spurious errors */
1328 bp->b_io_error = 0;
1329
Eric Sandeen8d6c1212014-04-17 08:15:28 +10001330 /*
Dave Chinner595bff72014-10-02 09:05:14 +10001331 * The caller's reference is released during I/O completion.
1332 * This occurs some time after the last b_io_remaining reference is
1333 * released, so after we drop our Io reference we have to have some
1334 * other reference to ensure the buffer doesn't go away from underneath
1335 * us. Take a direct reference to ensure we have safe access to the
1336 * buffer until we are finished with it.
Dave Chinnere11bb802014-10-02 09:04:11 +10001337 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338 xfs_buf_hold(bp);
1339
Eric Sandeen8d6c1212014-04-17 08:15:28 +10001340 /*
Dave Chinnere11bb802014-10-02 09:04:11 +10001341 * Set the count to 1 initially, this will stop an I/O completion
1342 * callout which happens before we have started all the I/O from calling
1343 * xfs_buf_ioend too early.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344 */
Nathan Scottce8e9222006-01-11 15:39:08 +11001345 atomic_set(&bp->b_io_remaining, 1);
1346 _xfs_buf_ioapply(bp);
Dave Chinnere11bb802014-10-02 09:04:11 +10001347
Eric Sandeen8d6c1212014-04-17 08:15:28 +10001348 /*
Dave Chinner595bff72014-10-02 09:05:14 +10001349 * If _xfs_buf_ioapply failed, we can get back here with only the IO
1350 * reference we took above. If we drop it to zero, run completion so
1351 * that we don't return to the caller with completion still pending.
Eric Sandeen8d6c1212014-04-17 08:15:28 +10001352 */
Dave Chinnere8aaba92014-10-02 09:04:22 +10001353 if (atomic_dec_and_test(&bp->b_io_remaining) == 1) {
Dave Chinner595bff72014-10-02 09:05:14 +10001354 if (bp->b_error)
Dave Chinnere8aaba92014-10-02 09:04:22 +10001355 xfs_buf_ioend(bp);
1356 else
1357 xfs_buf_ioend_async(bp);
1358 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359
Nathan Scottce8e9222006-01-11 15:39:08 +11001360 xfs_buf_rele(bp);
Dave Chinner595bff72014-10-02 09:05:14 +10001361 /* Note: it is not safe to reference bp now we've dropped our ref */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362}
1363
1364/*
Dave Chinner595bff72014-10-02 09:05:14 +10001365 * Synchronous buffer IO submission path, read or write.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366 */
1367int
Dave Chinner595bff72014-10-02 09:05:14 +10001368xfs_buf_submit_wait(
1369 struct xfs_buf *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370{
Dave Chinner595bff72014-10-02 09:05:14 +10001371 int error;
1372
1373 trace_xfs_buf_submit_wait(bp, _RET_IP_);
1374
1375 ASSERT(!(bp->b_flags & (_XBF_DELWRI_Q | XBF_ASYNC)));
1376
1377 if (XFS_FORCED_SHUTDOWN(bp->b_target->bt_mount)) {
1378 xfs_buf_ioerror(bp, -EIO);
1379 xfs_buf_stale(bp);
1380 bp->b_flags &= ~XBF_DONE;
1381 return -EIO;
1382 }
1383
1384 if (bp->b_flags & XBF_WRITE)
1385 xfs_buf_wait_unpin(bp);
1386
1387 /* clear the internal error state to avoid spurious errors */
1388 bp->b_io_error = 0;
1389
1390 /*
1391 * For synchronous IO, the IO does not inherit the submitters reference
1392 * count, nor the buffer lock. Hence we cannot release the reference we
1393 * are about to take until we've waited for all IO completion to occur,
1394 * including any xfs_buf_ioend_async() work that may be pending.
1395 */
1396 xfs_buf_hold(bp);
1397
1398 /*
1399 * Set the count to 1 initially, this will stop an I/O completion
1400 * callout which happens before we have started all the I/O from calling
1401 * xfs_buf_ioend too early.
1402 */
1403 atomic_set(&bp->b_io_remaining, 1);
1404 _xfs_buf_ioapply(bp);
1405
1406 /*
1407 * make sure we run completion synchronously if it raced with us and is
1408 * already complete.
1409 */
1410 if (atomic_dec_and_test(&bp->b_io_remaining) == 1)
1411 xfs_buf_ioend(bp);
1412
1413 /* wait for completion before gathering the error from the buffer */
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001414 trace_xfs_buf_iowait(bp, _RET_IP_);
Dave Chinner595bff72014-10-02 09:05:14 +10001415 wait_for_completion(&bp->b_iowait);
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001416 trace_xfs_buf_iowait_done(bp, _RET_IP_);
Dave Chinner595bff72014-10-02 09:05:14 +10001417 error = bp->b_error;
1418
1419 /*
1420 * all done now, we can release the hold that keeps the buffer
1421 * referenced for the entire IO.
1422 */
1423 xfs_buf_rele(bp);
1424 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425}
1426
Christoph Hellwig88ee2df2015-06-22 09:44:29 +10001427void *
Nathan Scottce8e9222006-01-11 15:39:08 +11001428xfs_buf_offset(
Christoph Hellwig88ee2df2015-06-22 09:44:29 +10001429 struct xfs_buf *bp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430 size_t offset)
1431{
1432 struct page *page;
1433
Dave Chinner611c9942012-04-23 15:59:07 +10001434 if (bp->b_addr)
Chandra Seetharaman62926042011-07-22 23:40:15 +00001435 return bp->b_addr + offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436
Nathan Scottce8e9222006-01-11 15:39:08 +11001437 offset += bp->b_offset;
Dave Chinner0e6e8472011-03-26 09:16:45 +11001438 page = bp->b_pages[offset >> PAGE_SHIFT];
Christoph Hellwig88ee2df2015-06-22 09:44:29 +10001439 return page_address(page) + (offset & (PAGE_SIZE-1));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440}
1441
1442/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443 * Move data into or out of a buffer.
1444 */
1445void
Nathan Scottce8e9222006-01-11 15:39:08 +11001446xfs_buf_iomove(
1447 xfs_buf_t *bp, /* buffer to process */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448 size_t boff, /* starting buffer offset */
1449 size_t bsize, /* length to copy */
Dave Chinnerb9c48642010-01-20 10:47:39 +11001450 void *data, /* data address */
Nathan Scottce8e9222006-01-11 15:39:08 +11001451 xfs_buf_rw_t mode) /* read/write/zero flag */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452{
Dave Chinner795cac72012-04-23 15:58:53 +10001453 size_t bend;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454
1455 bend = boff + bsize;
1456 while (boff < bend) {
Dave Chinner795cac72012-04-23 15:58:53 +10001457 struct page *page;
1458 int page_index, page_offset, csize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459
Dave Chinner795cac72012-04-23 15:58:53 +10001460 page_index = (boff + bp->b_offset) >> PAGE_SHIFT;
1461 page_offset = (boff + bp->b_offset) & ~PAGE_MASK;
1462 page = bp->b_pages[page_index];
1463 csize = min_t(size_t, PAGE_SIZE - page_offset,
1464 BBTOB(bp->b_io_length) - boff);
1465
1466 ASSERT((csize + page_offset) <= PAGE_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467
1468 switch (mode) {
Nathan Scottce8e9222006-01-11 15:39:08 +11001469 case XBRW_ZERO:
Dave Chinner795cac72012-04-23 15:58:53 +10001470 memset(page_address(page) + page_offset, 0, csize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471 break;
Nathan Scottce8e9222006-01-11 15:39:08 +11001472 case XBRW_READ:
Dave Chinner795cac72012-04-23 15:58:53 +10001473 memcpy(data, page_address(page) + page_offset, csize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474 break;
Nathan Scottce8e9222006-01-11 15:39:08 +11001475 case XBRW_WRITE:
Dave Chinner795cac72012-04-23 15:58:53 +10001476 memcpy(page_address(page) + page_offset, data, csize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001477 }
1478
1479 boff += csize;
1480 data += csize;
1481 }
1482}
1483
1484/*
Nathan Scottce8e9222006-01-11 15:39:08 +11001485 * Handling of buffer targets (buftargs).
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486 */
1487
1488/*
Dave Chinner430cbeb2010-12-02 16:30:55 +11001489 * Wait for any bufs with callbacks that have been submitted but have not yet
1490 * returned. These buffers will have an elevated hold count, so wait on those
1491 * while freeing all the buffers only held by the LRU.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001492 */
Dave Chinnere80dfa12013-08-28 10:18:05 +10001493static enum lru_status
1494xfs_buftarg_wait_rele(
1495 struct list_head *item,
Vladimir Davydov3f97b162015-02-12 14:59:35 -08001496 struct list_lru_one *lru,
Dave Chinnere80dfa12013-08-28 10:18:05 +10001497 spinlock_t *lru_lock,
1498 void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001499
Dave Chinnere80dfa12013-08-28 10:18:05 +10001500{
1501 struct xfs_buf *bp = container_of(item, struct xfs_buf, b_lru);
Dave Chinnera4082352013-08-28 10:18:06 +10001502 struct list_head *dispose = arg;
Dave Chinnere80dfa12013-08-28 10:18:05 +10001503
1504 if (atomic_read(&bp->b_hold) > 1) {
Dave Chinnera4082352013-08-28 10:18:06 +10001505 /* need to wait, so skip it this pass */
Dave Chinnere80dfa12013-08-28 10:18:05 +10001506 trace_xfs_buf_wait_buftarg(bp, _RET_IP_);
Dave Chinnera4082352013-08-28 10:18:06 +10001507 return LRU_SKIP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508 }
Dave Chinnera4082352013-08-28 10:18:06 +10001509 if (!spin_trylock(&bp->b_lock))
1510 return LRU_SKIP;
Dave Chinnere80dfa12013-08-28 10:18:05 +10001511
Dave Chinnera4082352013-08-28 10:18:06 +10001512 /*
1513 * clear the LRU reference count so the buffer doesn't get
1514 * ignored in xfs_buf_rele().
1515 */
1516 atomic_set(&bp->b_lru_ref, 0);
1517 bp->b_state |= XFS_BSTATE_DISPOSE;
Vladimir Davydov3f97b162015-02-12 14:59:35 -08001518 list_lru_isolate_move(lru, item, dispose);
Dave Chinnera4082352013-08-28 10:18:06 +10001519 spin_unlock(&bp->b_lock);
1520 return LRU_REMOVED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001521}
1522
Dave Chinnere80dfa12013-08-28 10:18:05 +10001523void
1524xfs_wait_buftarg(
1525 struct xfs_buftarg *btp)
1526{
Dave Chinnera4082352013-08-28 10:18:06 +10001527 LIST_HEAD(dispose);
1528 int loop = 0;
1529
Dave Chinner85bec542016-01-19 08:28:10 +11001530 /*
1531 * We need to flush the buffer workqueue to ensure that all IO
1532 * completion processing is 100% done. Just waiting on buffer locks is
1533 * not sufficient for async IO as the reference count held over IO is
1534 * not released until after the buffer lock is dropped. Hence we need to
1535 * ensure here that all reference counts have been dropped before we
1536 * start walking the LRU list.
1537 */
1538 drain_workqueue(btp->bt_mount->m_buf_workqueue);
1539
Dave Chinnera4082352013-08-28 10:18:06 +10001540 /* loop until there is nothing left on the lru list. */
1541 while (list_lru_count(&btp->bt_lru)) {
Dave Chinnere80dfa12013-08-28 10:18:05 +10001542 list_lru_walk(&btp->bt_lru, xfs_buftarg_wait_rele,
Dave Chinnera4082352013-08-28 10:18:06 +10001543 &dispose, LONG_MAX);
1544
1545 while (!list_empty(&dispose)) {
1546 struct xfs_buf *bp;
1547 bp = list_first_entry(&dispose, struct xfs_buf, b_lru);
1548 list_del_init(&bp->b_lru);
Dave Chinnerac8809f2013-12-12 16:34:38 +11001549 if (bp->b_flags & XBF_WRITE_FAIL) {
1550 xfs_alert(btp->bt_mount,
Joe Perchesf41febd2015-07-29 11:52:04 +10001551"Corruption Alert: Buffer at block 0x%llx had permanent write failures!",
Dave Chinnerac8809f2013-12-12 16:34:38 +11001552 (long long)bp->b_bn);
Joe Perchesf41febd2015-07-29 11:52:04 +10001553 xfs_alert(btp->bt_mount,
1554"Please run xfs_repair to determine the extent of the problem.");
Dave Chinnerac8809f2013-12-12 16:34:38 +11001555 }
Dave Chinnera4082352013-08-28 10:18:06 +10001556 xfs_buf_rele(bp);
1557 }
1558 if (loop++ != 0)
1559 delay(100);
1560 }
Dave Chinnere80dfa12013-08-28 10:18:05 +10001561}
1562
1563static enum lru_status
1564xfs_buftarg_isolate(
1565 struct list_head *item,
Vladimir Davydov3f97b162015-02-12 14:59:35 -08001566 struct list_lru_one *lru,
Dave Chinnere80dfa12013-08-28 10:18:05 +10001567 spinlock_t *lru_lock,
1568 void *arg)
1569{
1570 struct xfs_buf *bp = container_of(item, struct xfs_buf, b_lru);
1571 struct list_head *dispose = arg;
1572
1573 /*
Dave Chinnera4082352013-08-28 10:18:06 +10001574 * we are inverting the lru lock/bp->b_lock here, so use a trylock.
1575 * If we fail to get the lock, just skip it.
1576 */
1577 if (!spin_trylock(&bp->b_lock))
1578 return LRU_SKIP;
1579 /*
Dave Chinnere80dfa12013-08-28 10:18:05 +10001580 * Decrement the b_lru_ref count unless the value is already
1581 * zero. If the value is already zero, we need to reclaim the
1582 * buffer, otherwise it gets another trip through the LRU.
1583 */
Dave Chinnera4082352013-08-28 10:18:06 +10001584 if (!atomic_add_unless(&bp->b_lru_ref, -1, 0)) {
1585 spin_unlock(&bp->b_lock);
Dave Chinnere80dfa12013-08-28 10:18:05 +10001586 return LRU_ROTATE;
Dave Chinnera4082352013-08-28 10:18:06 +10001587 }
Dave Chinnere80dfa12013-08-28 10:18:05 +10001588
Dave Chinnera4082352013-08-28 10:18:06 +10001589 bp->b_state |= XFS_BSTATE_DISPOSE;
Vladimir Davydov3f97b162015-02-12 14:59:35 -08001590 list_lru_isolate_move(lru, item, dispose);
Dave Chinnera4082352013-08-28 10:18:06 +10001591 spin_unlock(&bp->b_lock);
Dave Chinnere80dfa12013-08-28 10:18:05 +10001592 return LRU_REMOVED;
1593}
1594
Andrew Mortonaddbda42013-08-28 10:18:06 +10001595static unsigned long
Dave Chinnere80dfa12013-08-28 10:18:05 +10001596xfs_buftarg_shrink_scan(
Dave Chinnerff57ab22010-11-30 17:27:57 +11001597 struct shrinker *shrink,
Ying Han1495f232011-05-24 17:12:27 -07001598 struct shrink_control *sc)
David Chinnera6867a62006-01-11 15:37:58 +11001599{
Dave Chinnerff57ab22010-11-30 17:27:57 +11001600 struct xfs_buftarg *btp = container_of(shrink,
1601 struct xfs_buftarg, bt_shrinker);
Dave Chinner430cbeb2010-12-02 16:30:55 +11001602 LIST_HEAD(dispose);
Andrew Mortonaddbda42013-08-28 10:18:06 +10001603 unsigned long freed;
Dave Chinner430cbeb2010-12-02 16:30:55 +11001604
Vladimir Davydov503c3582015-02-12 14:58:47 -08001605 freed = list_lru_shrink_walk(&btp->bt_lru, sc,
1606 xfs_buftarg_isolate, &dispose);
Dave Chinner430cbeb2010-12-02 16:30:55 +11001607
1608 while (!list_empty(&dispose)) {
Dave Chinnere80dfa12013-08-28 10:18:05 +10001609 struct xfs_buf *bp;
Dave Chinner430cbeb2010-12-02 16:30:55 +11001610 bp = list_first_entry(&dispose, struct xfs_buf, b_lru);
1611 list_del_init(&bp->b_lru);
1612 xfs_buf_rele(bp);
1613 }
1614
Dave Chinnere80dfa12013-08-28 10:18:05 +10001615 return freed;
1616}
1617
Andrew Mortonaddbda42013-08-28 10:18:06 +10001618static unsigned long
Dave Chinnere80dfa12013-08-28 10:18:05 +10001619xfs_buftarg_shrink_count(
1620 struct shrinker *shrink,
1621 struct shrink_control *sc)
1622{
1623 struct xfs_buftarg *btp = container_of(shrink,
1624 struct xfs_buftarg, bt_shrinker);
Vladimir Davydov503c3582015-02-12 14:58:47 -08001625 return list_lru_shrink_count(&btp->bt_lru, sc);
David Chinnera6867a62006-01-11 15:37:58 +11001626}
1627
Linus Torvalds1da177e2005-04-16 15:20:36 -07001628void
1629xfs_free_buftarg(
Christoph Hellwigb7963132009-03-03 14:48:37 -05001630 struct xfs_mount *mp,
1631 struct xfs_buftarg *btp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632{
Dave Chinnerff57ab22010-11-30 17:27:57 +11001633 unregister_shrinker(&btp->bt_shrinker);
Glauber Costaf5e1dd32013-08-28 10:18:18 +10001634 list_lru_destroy(&btp->bt_lru);
Dave Chinnerff57ab22010-11-30 17:27:57 +11001635
Christoph Hellwigb7963132009-03-03 14:48:37 -05001636 if (mp->m_flags & XFS_MOUNT_BARRIER)
1637 xfs_blkdev_issue_flush(btp);
David Chinnera6867a62006-01-11 15:37:58 +11001638
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10001639 kmem_free(btp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001640}
1641
Eric Sandeen3fefdee2013-11-13 14:53:45 -06001642int
1643xfs_setsize_buftarg(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644 xfs_buftarg_t *btp,
Eric Sandeen3fefdee2013-11-13 14:53:45 -06001645 unsigned int sectorsize)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646{
Eric Sandeen7c71ee72014-01-21 16:46:23 -06001647 /* Set up metadata sector size info */
Eric Sandeen6da54172014-01-21 16:45:52 -06001648 btp->bt_meta_sectorsize = sectorsize;
1649 btp->bt_meta_sectormask = sectorsize - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001650
Nathan Scottce8e9222006-01-11 15:39:08 +11001651 if (set_blocksize(btp->bt_bdev, sectorsize)) {
Dave Chinner4f107002011-03-07 10:00:35 +11001652 xfs_warn(btp->bt_mount,
Dmitry Monakhova1c6f0572015-04-13 16:31:37 +04001653 "Cannot set_blocksize to %u on device %pg",
1654 sectorsize, btp->bt_bdev);
Dave Chinner24513372014-06-25 14:58:08 +10001655 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656 }
1657
Eric Sandeen7c71ee72014-01-21 16:46:23 -06001658 /* Set up device logical sector size mask */
1659 btp->bt_logical_sectorsize = bdev_logical_block_size(btp->bt_bdev);
1660 btp->bt_logical_sectormask = bdev_logical_block_size(btp->bt_bdev) - 1;
1661
Linus Torvalds1da177e2005-04-16 15:20:36 -07001662 return 0;
1663}
1664
1665/*
Eric Sandeen3fefdee2013-11-13 14:53:45 -06001666 * When allocating the initial buffer target we have not yet
1667 * read in the superblock, so don't know what sized sectors
1668 * are being used at this early stage. Play safe.
Nathan Scottce8e9222006-01-11 15:39:08 +11001669 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670STATIC int
1671xfs_setsize_buftarg_early(
1672 xfs_buftarg_t *btp,
1673 struct block_device *bdev)
1674{
Eric Sandeena96c4152014-04-14 19:00:29 +10001675 return xfs_setsize_buftarg(btp, bdev_logical_block_size(bdev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676}
1677
Linus Torvalds1da177e2005-04-16 15:20:36 -07001678xfs_buftarg_t *
1679xfs_alloc_buftarg(
Dave Chinnerebad8612010-09-22 10:47:20 +10001680 struct xfs_mount *mp,
Eric Sandeen34dcefd2014-04-14 19:01:00 +10001681 struct block_device *bdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682{
1683 xfs_buftarg_t *btp;
1684
Dave Chinnerb17cb362013-05-20 09:51:12 +10001685 btp = kmem_zalloc(sizeof(*btp), KM_SLEEP | KM_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686
Dave Chinnerebad8612010-09-22 10:47:20 +10001687 btp->bt_mount = mp;
Nathan Scottce8e9222006-01-11 15:39:08 +11001688 btp->bt_dev = bdev->bd_dev;
1689 btp->bt_bdev = bdev;
Dave Chinner0e6e8472011-03-26 09:16:45 +11001690 btp->bt_bdi = blk_get_backing_dev_info(bdev);
Dave Chinner0e6e8472011-03-26 09:16:45 +11001691
Linus Torvalds1da177e2005-04-16 15:20:36 -07001692 if (xfs_setsize_buftarg_early(btp, bdev))
1693 goto error;
Glauber Costa5ca302c2013-08-28 10:18:18 +10001694
1695 if (list_lru_init(&btp->bt_lru))
1696 goto error;
1697
Dave Chinnere80dfa12013-08-28 10:18:05 +10001698 btp->bt_shrinker.count_objects = xfs_buftarg_shrink_count;
1699 btp->bt_shrinker.scan_objects = xfs_buftarg_shrink_scan;
Dave Chinnerff57ab22010-11-30 17:27:57 +11001700 btp->bt_shrinker.seeks = DEFAULT_SEEKS;
Dave Chinnere80dfa12013-08-28 10:18:05 +10001701 btp->bt_shrinker.flags = SHRINKER_NUMA_AWARE;
Dave Chinnerff57ab22010-11-30 17:27:57 +11001702 register_shrinker(&btp->bt_shrinker);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703 return btp;
1704
1705error:
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10001706 kmem_free(btp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707 return NULL;
1708}
1709
Linus Torvalds1da177e2005-04-16 15:20:36 -07001710/*
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001711 * Add a buffer to the delayed write list.
1712 *
1713 * This queues a buffer for writeout if it hasn't already been. Note that
1714 * neither this routine nor the buffer list submission functions perform
1715 * any internal synchronization. It is expected that the lists are thread-local
1716 * to the callers.
1717 *
1718 * Returns true if we queued up the buffer, or false if it already had
1719 * been on the buffer list.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001720 */
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001721bool
Nathan Scottce8e9222006-01-11 15:39:08 +11001722xfs_buf_delwri_queue(
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001723 struct xfs_buf *bp,
1724 struct list_head *list)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725{
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001726 ASSERT(xfs_buf_islocked(bp));
1727 ASSERT(!(bp->b_flags & XBF_READ));
1728
1729 /*
1730 * If the buffer is already marked delwri it already is queued up
1731 * by someone else for imediate writeout. Just ignore it in that
1732 * case.
1733 */
1734 if (bp->b_flags & _XBF_DELWRI_Q) {
1735 trace_xfs_buf_delwri_queued(bp, _RET_IP_);
1736 return false;
1737 }
David Chinnera6867a62006-01-11 15:37:58 +11001738
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001739 trace_xfs_buf_delwri_queue(bp, _RET_IP_);
1740
Dave Chinnerd808f612010-02-02 10:13:42 +11001741 /*
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001742 * If a buffer gets written out synchronously or marked stale while it
1743 * is on a delwri list we lazily remove it. To do this, the other party
1744 * clears the _XBF_DELWRI_Q flag but otherwise leaves the buffer alone.
1745 * It remains referenced and on the list. In a rare corner case it
1746 * might get readded to a delwri list after the synchronous writeout, in
1747 * which case we need just need to re-add the flag here.
Dave Chinnerd808f612010-02-02 10:13:42 +11001748 */
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001749 bp->b_flags |= _XBF_DELWRI_Q;
1750 if (list_empty(&bp->b_list)) {
1751 atomic_inc(&bp->b_hold);
1752 list_add_tail(&bp->b_list, list);
David Chinner585e6d82007-02-10 18:32:29 +11001753 }
David Chinner585e6d82007-02-10 18:32:29 +11001754
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001755 return true;
David Chinner585e6d82007-02-10 18:32:29 +11001756}
1757
Dave Chinner089716a2010-01-26 15:13:25 +11001758/*
1759 * Compare function is more complex than it needs to be because
1760 * the return value is only 32 bits and we are doing comparisons
1761 * on 64 bit values
1762 */
1763static int
1764xfs_buf_cmp(
1765 void *priv,
1766 struct list_head *a,
1767 struct list_head *b)
1768{
1769 struct xfs_buf *ap = container_of(a, struct xfs_buf, b_list);
1770 struct xfs_buf *bp = container_of(b, struct xfs_buf, b_list);
1771 xfs_daddr_t diff;
1772
Mark Tinguelyf4b42422012-12-04 17:18:02 -06001773 diff = ap->b_maps[0].bm_bn - bp->b_maps[0].bm_bn;
Dave Chinner089716a2010-01-26 15:13:25 +11001774 if (diff < 0)
1775 return -1;
1776 if (diff > 0)
1777 return 1;
1778 return 0;
1779}
1780
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001781static int
1782__xfs_buf_delwri_submit(
1783 struct list_head *buffer_list,
1784 struct list_head *io_list,
1785 bool wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001786{
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001787 struct blk_plug plug;
1788 struct xfs_buf *bp, *n;
1789 int pinned = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001791 list_for_each_entry_safe(bp, n, buffer_list, b_list) {
1792 if (!wait) {
1793 if (xfs_buf_ispinned(bp)) {
1794 pinned++;
1795 continue;
1796 }
1797 if (!xfs_buf_trylock(bp))
1798 continue;
1799 } else {
1800 xfs_buf_lock(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001801 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001802
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001803 /*
1804 * Someone else might have written the buffer synchronously or
1805 * marked it stale in the meantime. In that case only the
1806 * _XBF_DELWRI_Q flag got cleared, and we have to drop the
1807 * reference and remove it from the list here.
1808 */
1809 if (!(bp->b_flags & _XBF_DELWRI_Q)) {
1810 list_del_init(&bp->b_list);
1811 xfs_buf_relse(bp);
1812 continue;
1813 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001815 list_move_tail(&bp->b_list, io_list);
1816 trace_xfs_buf_delwri_split(bp, _RET_IP_);
1817 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001818
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001819 list_sort(NULL, io_list, xfs_buf_cmp);
Christoph Hellwiga1b7ea52011-03-30 11:05:09 +00001820
1821 blk_start_plug(&plug);
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001822 list_for_each_entry_safe(bp, n, io_list, b_list) {
Dave Chinnerac8809f2013-12-12 16:34:38 +11001823 bp->b_flags &= ~(_XBF_DELWRI_Q | XBF_ASYNC | XBF_WRITE_FAIL);
Dave Chinnercf53e992014-10-02 09:04:01 +10001824 bp->b_flags |= XBF_WRITE | XBF_ASYNC;
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001825
Dave Chinnercf53e992014-10-02 09:04:01 +10001826 /*
1827 * we do all Io submission async. This means if we need to wait
1828 * for IO completion we need to take an extra reference so the
1829 * buffer is still valid on the other side.
1830 */
1831 if (wait)
1832 xfs_buf_hold(bp);
1833 else
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001834 list_del_init(&bp->b_list);
Dave Chinner8dac3922014-10-02 09:04:40 +10001835
Dave Chinner595bff72014-10-02 09:05:14 +10001836 xfs_buf_submit(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001837 }
Christoph Hellwiga1b7ea52011-03-30 11:05:09 +00001838 blk_finish_plug(&plug);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001840 return pinned;
1841}
Nathan Scottf07c2252006-09-28 10:52:15 +10001842
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001843/*
1844 * Write out a buffer list asynchronously.
1845 *
1846 * This will take the @buffer_list, write all non-locked and non-pinned buffers
1847 * out and not wait for I/O completion on any of the buffers. This interface
1848 * is only safely useable for callers that can track I/O completion by higher
1849 * level means, e.g. AIL pushing as the @buffer_list is consumed in this
1850 * function.
1851 */
1852int
1853xfs_buf_delwri_submit_nowait(
1854 struct list_head *buffer_list)
1855{
1856 LIST_HEAD (io_list);
1857 return __xfs_buf_delwri_submit(buffer_list, &io_list, false);
1858}
1859
1860/*
1861 * Write out a buffer list synchronously.
1862 *
1863 * This will take the @buffer_list, write all buffers out and wait for I/O
1864 * completion on all of the buffers. @buffer_list is consumed by the function,
1865 * so callers must have some other way of tracking buffers if they require such
1866 * functionality.
1867 */
1868int
1869xfs_buf_delwri_submit(
1870 struct list_head *buffer_list)
1871{
1872 LIST_HEAD (io_list);
1873 int error = 0, error2;
1874 struct xfs_buf *bp;
1875
1876 __xfs_buf_delwri_submit(buffer_list, &io_list, true);
1877
1878 /* Wait for IO to complete. */
1879 while (!list_empty(&io_list)) {
1880 bp = list_first_entry(&io_list, struct xfs_buf, b_list);
1881
1882 list_del_init(&bp->b_list);
Dave Chinnercf53e992014-10-02 09:04:01 +10001883
1884 /* locking the buffer will wait for async IO completion. */
1885 xfs_buf_lock(bp);
1886 error2 = bp->b_error;
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001887 xfs_buf_relse(bp);
1888 if (!error)
1889 error = error2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890 }
1891
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001892 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893}
1894
Christoph Hellwig04d8b282005-11-02 10:15:05 +11001895int __init
Nathan Scottce8e9222006-01-11 15:39:08 +11001896xfs_buf_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897{
Nathan Scott87582802006-03-14 13:18:19 +11001898 xfs_buf_zone = kmem_zone_init_flags(sizeof(xfs_buf_t), "xfs_buf",
1899 KM_ZONE_HWALIGN, NULL);
Nathan Scottce8e9222006-01-11 15:39:08 +11001900 if (!xfs_buf_zone)
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001901 goto out;
Christoph Hellwig04d8b282005-11-02 10:15:05 +11001902
Christoph Hellwig23ea4032005-06-21 15:14:01 +10001903 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001905 out:
Nathan Scott87582802006-03-14 13:18:19 +11001906 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001907}
1908
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909void
Nathan Scottce8e9222006-01-11 15:39:08 +11001910xfs_buf_terminate(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001911{
Nathan Scottce8e9222006-01-11 15:39:08 +11001912 kmem_zone_destroy(xfs_buf_zone);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001913}